OMKReferenceObjectHandle.cpp

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 <OMKReferenceObjectHandle.h>
#include <OMKSimulatedObject.h>
#include <OMKController.h>
#include <typeinfo>
#include "OMKEventListener.h"

#include "OMKCurrentActiveObject.h"
#include <assert.h>
#include <algorithm>
using namespace std ;
using namespace OMK ;


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

ReferenceObjectHandle::ReferenceObjectHandle( SimulatedObject & objet, 
                                                                            Controller & ctrl, 
                                                                            SignalDispatcher * signalDispatcher )
: ObjectHandle ( objet ),
  _controller ( ctrl ),
  _signalDispatcher ( signalDispatcher ? signalDispatcher : new SignalDispatcher (ctrl) )
{
   assert ( _signalDispatcher != NULL ) ;

   for( int i = 0 ; i<2 ; i++ ) 
   {
           _isInObjectNeedingActivationList[i]= false ;
   }
   _computingState = initial ;
   _dateOfLastEventManagement = Controller::initialSimulationDate - 1 ;
   _dateOfLastActivation = Controller::initialSimulationDate - 1 ;

   _eventList = new std::list <Event *> * [ 2 ] ;
   _eventList [ 0 ] = new std::list <Event *>() ;
   _eventList [ 1 ] = new std::list <Event *>() ;
   _currentWritableEventList = 0 ;
   
   // register the event listeners already added to the object
   const  list <EventListener *> & listOfEventListeners = _myObject.getEventListeners () ;
   for( list< EventListener * >::const_iterator eventListenersIterator = listOfEventListeners.begin() ;
        eventListenersIterator != listOfEventListeners.end() ;
        ++eventListenersIterator )
   {
           (*eventListenersIterator)->registerEvents() ;
   }
}

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

ReferenceObjectHandle::~ReferenceObjectHandle () 
{
   //cerr<<"ReferenceObjectHandle:"<<this<<":~ReferenceObjectHandle () "<<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 ReferenceObjectHandle::init() 
{
   CurrentActiveObject changeContext ( &_myObject ) ;
   OMTRACEID( OMK_DEBUG_OMK_EXEC, "init for " << debugMsg( &_myObject ) ) ;
   _myObject.init () ;
   OMTRACEID( OMK_DEBUG_OMK_EXEC, "init for " << debugMsg( &_myObject ) << " done" ) ;
   // do not treat init as an activation to enable init and compute in the same simulation step
}

void ReferenceObjectHandle::initAfterMorphose() 
{
   CurrentActiveObject changeContext ( &_myObject ) ;
   _myObject.init () ;
}

void ReferenceObjectHandle::setMigrationCaseToTrue ()
{
  _migrationCase = true ;
}

void ReferenceObjectHandle::setMorphosisPhaseTrue () 
{
   OMASSERTM( false, "this code must not be called" ) ;
}
void ReferenceObjectHandle::compute() 
{
   OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::compute() last activated at "<<_dateOfLastActivation<<", now is "
       <<_controller.getSimulatedDate() ) ;

   if ( _controller.getSimulatedDate() > _dateOfLastActivation ) 
   {
     
     _dateOfLastActivation = _controller.getSimulatedDate() ;
  
     CurrentActiveObject changeContext ( &_myObject ) ;
     OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::compute : processing events of " << debugMsg( &_myObject ) ) ;
     processEvents () ;
     OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::compute : events of " << debugMsg( &_myObject ) << " processed, now compute" ) ;
     _myObject.compute () ;
     OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::compute : computation finished for " << debugMsg( &_myObject ) ) ;
   }
   else
   {
           OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::compute : controller allready activated at "<<_controller.getSimulatedDate() ) ;
   }
}

void ReferenceObjectHandle::processEvents () 
{
   bool eventsProcessed = false ;
   OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::processEvents () of " << debugMsg( &getSimulatedObject() ) << " last activated at " 
       << _dateOfLastEventManagement << ", now is " <<_controller.getSimulatedDate() ) ;

   if (_controller.getSimulatedDate() > _dateOfLastEventManagement ) 
      {
         switchEventList() ;
         list< Event * > & myEventList = getCurrentEventList() ;
         eventsProcessed = ! myEventList.empty() ;
         if ( eventsProcessed ) _myObject.prepareEventProcessing ( myEventList ) ; /*Mathias Lorente's suggestion*/
         list< Event * >::iterator i = myEventList.begin() ;
         list< Event * >::iterator toErase ;
         // if ( eventsProcessed ) _myObject.prepareEventProcessing ( myEventList ) ;
         while ( i != myEventList.end() ) 
            {
         OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::processEvents (): processing" << *(*i) ) ;
               virtualEventTableType::iterator listeners = _virtualEventTable.find ( (*i)->eventId ) ;
               bool finished = false ;
               if ( listeners != _virtualEventTable.end() ) 
                  {
                     list <EventListener * >::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 
   OMTRACEID( OMK_DEBUG_OMK_EXEC, "ReferenceObjectHandle::processEvents event processing postponed for " << debugMsg( &getSimulatedObject() ) ) ;
         _controller.postponeEventProcessing ( this ) ;
      }
}



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

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

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

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

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

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

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



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


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

void ReferenceObjectHandle::receiveEvent (Event * event) 
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "ReferenceObjectHandle::receiveEvent(Event *)" << std::endl 
     << "  \"" << event->receiver << "\" received event \"" << event->eventId << "\" at " << event->date ) ;
   //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
#ifdef _OMK_MUTEX_
      _mutexForListEvt.protect() ;
#endif
      Event::insertInList (_eventList[_currentWritableEventList], event) ;
#ifdef _OMK_MUTEX_
      _mutexForListEvt.unprotect() ;
#endif
   }
   else {
      delete event ;
   }
}

// Modification 2007/05/11 Benoit Chanclou
// Avoid twice registration of the same event handler
void ReferenceObjectHandle::registerEventListenerForEvent( EventListener & eventListener, 
                                                                                                  const EventIdentifier & eventId )
{
  // Look for an entry in the map for this event id
  virtualEventTableType::iterator i = _virtualEventTable.find( eventId ) ;
  if (i != _virtualEventTable.end() ) 
  {
    // Yes, the event id is already registered, add the listener to the list managed for it
    // To avoid twice registration of the same event handler
    list < EventListener *>* listeners = (*i).second ;
    if( find( listeners->begin(), listeners->end(), & eventListener ) == listeners->end() )
    {
      listeners->push_back( &eventListener ) ;
    }
  } 
  else
  {
    // No, must create the entry and add the listener
    _virtualEventTable[ eventId ] = new list< EventListener *>( 1, &eventListener ) ;
  }
}
void ReferenceObjectHandle::unregisterEventListener( EventListener & eventListener ) 
{
  for( virtualEventTableType::iterator eventId = _virtualEventTable.begin() ;
       eventId != _virtualEventTable.end() ;
       eventId++ )
  {
    list < EventListener *>* listeners = (*eventId).second ;
    list < EventListener *>::iterator eventListenerPos = find( listeners->begin(), listeners->end(), & eventListener ) ;
    if( eventListenerPos != listeners->end() )
    {
      listeners->erase( eventListenerPos ) ;
    }
  }
}

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

void ReferenceObjectHandle::switchEventList () {
#ifdef _OMK_MUTEX_
   _mutexForListEvt.protect() ;
#endif
   _currentWritableEventList = 1 - _currentWritableEventList ;
#ifdef _OMK_MUTEX_
   _mutexForListEvt.unprotect() ;
#endif
}

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


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

bool ReferenceObjectHandle::receiveRegistrationForSignal ( const EventIdentifier & sigId, 
                                                              const Name & registrant, 
                                                              const EventIdentifier & eventId ) 
{
   return _signalDispatcher->registerForSignal( sigId, registrant, eventId ) ;
}



bool ReferenceObjectHandle::cancelRegistrationForSignal ( const EventIdentifier & sigId, 
                                                   const Name & registrant ) 
{
   return _signalDispatcher->cancelRegistrationForSignal ( sigId, registrant ) ;
}

---