---

PsnReferenceObjectHandle.cxx

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The software has been developed within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *  
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#include <PsnReferenceObjectHandle.h>
#include <PsSimulatedObject.h>
#include <PsObjectDescriptor.h>
#include <PsController.h>
#include <typeinfo>
#include "PsEventListener.h"

#include "PsnCurrentActiveObject.h"
//-----------------------------------------------------------------------------

PsnReferenceObjectHandle::PsnReferenceObjectHandle (PsSimulatedObject & objet, PsController & ctrl)
              : PsnObjectHandle (objet),
                _controller (ctrl),
                _signalDispatcher ( new PsnSignalDispatcher (ctrl) )
{
   for(int i=0 ; i<2 ; i++) 
      {
         _isInObjectNeedingActivationList[i]= false ;
      }
   _computingState = initial ;
   _dateOfLastEventManagement = PsController::initialSimulationDate - 1 ;
   _dateOfLastActivation = PsController::initialSimulationDate - 1 ;

   _eventList = new list <PsEvent *> * [ 2 ] ;
   _eventList [ 0 ] = new list <PsEvent *>() ;
   _eventList [ 1 ] = new list <PsEvent *>() ;
   _currentWritableEventList = 0 ;
   
   const  list <PsEventListener *> & listOfEventListeners = _myObject.getEventListeners () ;
   list <PsEventListener *>::const_iterator eventListenersIterator = listOfEventListeners.begin() ;
   while ( eventListenersIterator != listOfEventListeners.end() ) 
      {
        (*eventListenersIterator)->registerEvents() ;
        ++eventListenersIterator ;
      }
}

PsnReferenceObjectHandle::PsnReferenceObjectHandle (PsSimulatedObject & objet, 
                                                    PsController & ctrl, 
                                                    PsnSignalDispatcher * signalDispatcher )
   : PsnObjectHandle ( objet ),
     _controller ( ctrl ),
     _signalDispatcher ( signalDispatcher )
{
   assert ( _signalDispatcher != NULL ) ;
   for(int i=0;i<2;i++) 
      {
         _isInObjectNeedingActivationList[i]= false ;
      }
   _computingState = initial ;
   _dateOfLastEventManagement = PsController::initialSimulationDate - 1 ;
   _dateOfLastActivation = PsController::initialSimulationDate - 1 ;

   /* cast for compilation with MIPS-Pro compiler 7.3 */
   _eventList = (list <PsEvent *> **) new list <PsEvent *> * [ 2 ] ;
   _eventList [ 0 ] = new list <PsEvent *>() ;
   _eventList [ 1 ] = new list <PsEvent *>() ;
   _currentWritableEventList = 0 ;
   
   const  list <PsEventListener *> & listOfEventListeners = _myObject.getEventListeners () ;
   list <PsEventListener *>::const_iterator eventListenersIterator = listOfEventListeners.begin() ;
   while ( eventListenersIterator != listOfEventListeners.end() ) 
      {
         (*eventListenersIterator)->registerEvents() ;
         ++eventListenersIterator ;
   }
}

//-----------------------------------------------------------------------------

PsnReferenceObjectHandle::~PsnReferenceObjectHandle () 
{
   //cerr<<"PsnReferenceObjectHandle:"<<this<<":~PsnReferenceObjectHandle () "<<endl;

  delete _eventList[0] ;
  delete _eventList[1] ;
  delete [] _eventList ;
  for (virtualEventTableType::iterator i = _virtualEventTable.begin();
       i != _virtualEventTable.end();
       ++i )
     {
        delete (*i).second ;
     }
  assert (_signalDispatcher != NULL) ;
  delete _signalDispatcher ;
}

void PsnReferenceObjectHandle::init() 
{
   PsnCurrentActiveObject changeContext ( &_myObject ) ;
#ifdef _DEBUGEXEC
   cerr<<"init for object "<<_myObject.getName()<<endl;
#endif
   _myObject.init () ;
#ifdef _DEBUGEXEC
   cerr<<"init for "<<_myObject.getName()<<" done"<<endl;
#endif
   // do not treat init as an activation to enable init and compute in the same simulation step
}



void PsnReferenceObjectHandle::compute() 
{
#ifdef _DEBUGEXEC
   cerr<<"PsnReferenceObjectHandle::compute() last activated at "<<_dateOfLastActivation<<", now is "
       <<_controller.getSimulatedDate()<<endl;
#endif   
   if ( _controller.getSimulatedDate() > _dateOfLastActivation ) 
     {
       
       _dateOfLastActivation = _controller.getSimulatedDate() ;
    
       PsnCurrentActiveObject changeContext ( &_myObject ) ;
#ifdef _DEBUGEXEC
       cerr<<"PsnReferenceObjectHandle::compute : processing events of "<<_myObject.getName()<<endl;
#endif
       processEvents () ;
#ifdef _DEBUGEXEC
       cerr<<"PsnReferenceObjectHandle::compute : events processed, computing"<<endl;
#endif
       _myObject.compute () ;
#ifdef _DEBUGEXEC
       cerr<<"PsnReferenceObjectHandle::compute : computation finished for "<<_myObject.getName()<<endl;
#endif
     }
#ifdef _DEBUGEXEC
   else
      {
         cerr<<"PsnReferenceObjectHandle::compute : controller allready activated at "<<_controller.getSimulatedDate()<<endl;
      }
#endif
}

void PsnReferenceObjectHandle::processEvents () 
{
   bool eventsProcessed = false ;
#if defined  (_DEBUGEXEC)
   cerr<<"PsnReferenceObjectHandle::processEvents () of "<<getSimulatedObject().getName()<<" last activated at "<<_dateOfLastEventManagement<<", now is "
       <<_controller.getSimulatedDate()<<endl;
#endif   
   if (_controller.getSimulatedDate() > _dateOfLastEventManagement ) 
      {
         switchEventList() ;
         list< PsEvent * > & myEventList = getCurrentEventList() ;
         eventsProcessed = ! myEventList.empty() ;
         list< PsEvent * >::iterator i = myEventList.begin() ;
         list< PsEvent * >::iterator toErase ;
         if ( eventsProcessed ) _myObject.prepareEventProcessing ( myEventList ) ;
         while ( i != myEventList.end() ) 
            {
#ifdef _DEBUGEVT
               cout << "PsnReferenceObjectHandle::processEvents (): processing" << *(*i) << endl ;
#endif
               virtualEventTableType::iterator listeners = _virtualEventTable.find ( (*i)->eventId ) ;
               bool finished = false ;
               if ( listeners != _virtualEventTable.end() ) 
                  {
                     list <PsEventListener * >::iterator aListener = listeners->second->begin() ;
                     while ( aListener != listeners->second->end() && ! finished )
                        {
                           (*aListener)->prepareEventProcessing ( myEventList , i ) ;
                           finished = (*aListener)->processEvent ( *i ) ;
                           ++aListener ;
                        }
                  }
               if ( ! finished ) 
                  {
                     if ( _myObject.processEvent ( *i ) ) {
                        delete (*i) ;
                     }
                  }
               else 
                  {
                     delete (*i) ;
                  }
               toErase = i ;
               i++ ;
               myEventList.erase ( toErase ) ;
            }
         if ( eventsProcessed ) _myObject.eventsProcessed ( myEventList ) ;
         _dateOfLastEventManagement = _controller.getSimulatedDate() ;      
      }  
   else 
      {
         //processEvents has already been called, and is called again 
#ifdef _DEBUGEVT
         cerr <<"PsnReferenceObjectHandle::processEvents event processing postponed for "<<getSimulatedObject().getName()<<endl;
#endif
         _controller.postponeEventProcessing ( this ) ;
      }
}



bool operator < (const PsnReferenceObjectHandle & un,
                 const PsnReferenceObjectHandle & deux) 
{   
   return un._myObject. getObjectDescriptor ().getName()<deux._myObject. getObjectDescriptor ().getName();
}

bool operator <= (const PsnReferenceObjectHandle & un,
                  const PsnReferenceObjectHandle & deux) 
{
   return un._myObject.getObjectDescriptor ().getName()<=deux._myObject.getObjectDescriptor ().getName();
}

bool operator > (const PsnReferenceObjectHandle & un,
                 const PsnReferenceObjectHandle & deux)
{
   return !(un<=deux);
}

bool operator >= (const PsnReferenceObjectHandle & un,
                  const PsnReferenceObjectHandle & deux)
{
   return !(un<deux);
}

//-----------------------------------------------------------------------------

void PsnReferenceObjectHandle::insertInStream (ostream & out) const {
   PsController::error ("insertInStream of PsnReferenceObjectHandle used");
}

void PsnReferenceObjectHandle::extract (istream & in) 
{
   
}



//-----------------------------------------------------------------------------


void PsnReferenceObjectHandle::receiveEvent (const PsEvent & event) 
{
#ifdef _DEBUGEVT
   cerr<<"PsnReferenceObjectHandle::receiveEvent (const PsEvent &"<<event<<")"<<endl;
#endif
   receiveEvent ( event.clone() ) ;
}

void PsnReferenceObjectHandle::receiveEvent (PsEvent * event) {
#ifdef _DEBUGEVT
   cerr<<"PsnReferenceObjectHandle::receiveEvent(PsEvent *)"<<endl;
   cerr<<"  "<<event->receiver<<" received event "<<event->eventId<<" at "<<event->date<<endl;
#endif
   //DM : a copy is sent only at reception , because only at reception is the correct controller known
   if ( (event->isSystem ()) && (event->receiver == _myObject.getName()) ) 
      {
         _controller.actOnSystemEvent (event) ;
      }  
   // if the receiving object is suspended, or has fast event processing activated
   // signal the reception to the controller
   if ( _computingState == suspended || _myObject.processEventsASAP () ) 
      {
         _controller.hasEventsToProcess (this) ;
      }
   if (  _computingState != stopped || event->isSystem () ) {
      //*event is owned by the object who has the responsibility to free it
      _mutexForListEvt.protect() ;
      PsEvent::insertInList (_eventList[_currentWritableEventList], event) ;
      _mutexForListEvt.unprotect() ;
   }
   else {
      delete event ;
   }
}

void PsnReferenceObjectHandle::registerEventListenerForEvent ( PsEventListener & eventListener, 
                                                     const PsEventIdentifier & eventId ) {
   virtualEventTableType::iterator i = _virtualEventTable.find (eventId) ;
   if (i != _virtualEventTable.end() ) {
      (*i).second->push_back( &eventListener ) ;
   } 
   else {
      _virtualEventTable.insert ( virtualEventTableType::value_type(eventId,
                                                                   new list< PsEventListener *> ( 1 , &eventListener) ) );
   }
}

list <PsEvent *> & PsnReferenceObjectHandle::getCurrentEventList() {
   return *(_eventList[ 1 - _currentWritableEventList ] ) ;
}

void PsnReferenceObjectHandle::switchEventList () {
   _mutexForListEvt.protect() ;
   _currentWritableEventList = 1 - _currentWritableEventList ;
   _mutexForListEvt.unprotect() ;
}

const PsnReferenceObjectHandle::SimulatedObjectComputingState & PsnReferenceObjectHandle::getComputingState() const 
{
   return _computingState ;
}


void PsnReferenceObjectHandle::sendEventsForSignal( PsEvent & event , const PsEventIdentifier & sigId ) 
{
   //cerr<<"PsnReferenceObjectHandle::sendEventsForSignal "<<sigId<<endl;
   _signalDispatcher->sendEventsForSignal ( event, sigId ) ;
   _controller.broadcastEventsForSignal ( event , sigId ) ;
}

bool PsnReferenceObjectHandle::receiveRegistrationForSignal ( const PsEventIdentifier & sigId, 
                                                              const PsName & registrant, 
                                                              const PsEventIdentifier & eventId ) 
{
   return _signalDispatcher->registerForSignal( sigId, registrant, eventId ) ;
}



bool PsnReferenceObjectHandle::cancelRegistrationForSignal ( const PsEventIdentifier & sigId, 
                                                   const PsName & registrant ) 
{
   return _signalDispatcher->cancelRegistrationForSignal ( sigId, registrant ) ;
}

---