OMKSimulatedObject.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 developped 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 "OMKName.h"
#include <OMKSimulatedObject.h>
#include <OMKObjectDescriptor.h>
#include <OMKReferenceObjectHandle.h>
#include <OMKMirrorObjectHandle.h>
#include <OMKOutput.h>
#include <OMKInput.h>
#include <OMKEventIdentifier.h>
#include "OMKEvent.h"
#include "OMKEventListener.h"
#include "OMKSystemEventIdentifier.h"
#ifdef _PSGUI
#include <OMKCtrlLocGui.h>
extern "C" IlvBoolean IlvSetLanguage();
#endif
#ifdef _REACT
#include <OMKReactController.h>
#endif
#include "OMKTracer.h"
#include <algorithm>
//------------------------------------------------------------------
#include <OMKMirrorObjectHandle.h>
#include "OMKSynchronisationMessage.h" 

using namespace std ;
using namespace OMK ;



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

ObjectHandle * SimulatedObject::getObjectHandle() const 
{
   return _objectHandle ;
}

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

void SimulatedObject::setObjectHandle( ObjectHandle * objectHandle ) 
{
   //OMASSERT ( _objectHandle == NULL ) ; // TDTD 09-05-2006 commentaire cause noyau Chadi : pour la migration
   _objectHandle = objectHandle ;
}

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

const ObjectDescriptor & SimulatedObject::getObjectDescriptor () const {
   return _objectDescriptor ;
}

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

SimulatedObject::SimulatedObject( Controller & ctrl, const ObjectDescriptor & objectDecriptor ) : 
   Flowable(),
   _controller ( ctrl ),
   _objectDescriptor ( objectDecriptor ),
   _objectHandle ( NULL )
{
   _objectDescriptor._pointerToSimulatedObject = this ;
}

//------------------------------------------------------------------
SimulatedObject::~SimulatedObject()
{
  // destroy inputs, outputs and control parameters
   
  NameToPointerMap<OutputNT>::iterator pOutput; // iterateur
  OutputNT *outputCourante;
  NameToPointerMap<OutputNT>::iterator pParam; // iterateur
  OutputNT *paramCourant;
  NameToPointerMap<InputNT>::iterator pInput; // iterateur
  InputNT *inputCourant;

  // Pour toutes les outputs, on detruit ;

  OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject:: ~SimulatedObject ()  : control parameters destruction" ) ;
  for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++)
    {
      paramCourant = getPointerToControlParameterNamed ((*pParam).first);
      delete paramCourant;
    }
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject:: ~SimulatedObject ()  : control parameters destruction done" << std::endl << "inputs destruction" ) ;
  for(pInput= _inputTable.begin(); pInput!=_inputTable.end();pInput++)
    {
      inputCourant = getPointerToInputNamed ((*pInput).first);
      delete inputCourant ;
    }
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject:: ~SimulatedObject ()  : inputs destruction done" << std::endl << "outputs destruction" ) ;
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
    {
       outputCourante = getPointerToOutputNamed ((*pOutput).first);
       delete outputCourante;
    }
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject:: ~SimulatedObject ()  : outputs destruction done" << std::endl << "encapsulated classes creators destruction " ) ;

  // update the object descriptor
  _objectDescriptor._pointerToSimulatedObject = NULL ;

  // Delete all the remaining event listeners
  for( std::list <EventListener *>::iterator listener = _listOfEventListeners.begin() ;
       listener != _listOfEventListeners.end() ; listener = _listOfEventListeners.begin() )
  {
    delete *listener ;
  }
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject:: ~SimulatedObject ()  : done" ) ;
}

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

void SimulatedObject::deleteInput( const Name & name )
{
  InputNT * obj = _inputTable[ name ] ;
  _inputTable.erase( name ) ;
  delete obj ;
}

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

OutputNT * SimulatedObject::getPointerToControlParameterNamed( const Name & nomAtt  ) const
{
  return _controlParameterTable.getObjectOfIndex (nomAtt) ;
} 
 
//---------------------------------------------------------------------

OutputNT * SimulatedObject::getPointerToOutputNamed( const Name & nomAtt ) const
{
   OutputNT * ref = _outputTable.getObjectOfIndex (nomAtt) ;
   if (ref == NULL) {
     OMTRACEID( OMK_DEBUG_OMK_EXEC, "SimulatedObject::getPointerToOutputNamed: \""
                << nomAtt << "\" is an unknown output for object \"" 
                << getName() << "\"" ) ;
   }
   return ref ;
}

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

InputNT * SimulatedObject::getPointerToInputNamed( const Name & nomAtt ) const
{
  return _inputTable.getObjectOfIndex (nomAtt) ;
} 


//------------------------------------------------------------------
// Symbolic name for object
const Name & SimulatedObject::getName() const
{
  return _objectDescriptor.getName() ;
}

//------------------------------------------------------------------
// accesseur sur le controleur local de la simulation en lecture

Controller & SimulatedObject::getController () const {
  return _controller;
}

void SimulatedObject::postConstruction() 
{
}

void SimulatedObject::init() 
{
}

void SimulatedObject::emigrate()
{
}

void SimulatedObject::immigrate(Event * event)
{
}
void SimulatedObject::compute ()
{
}

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

void SimulatedObject::finish() 
{
}

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

float SimulatedObject::getPeriod () const 
{
   return 1.f / _objectDescriptor.getFrequency () ;
}

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

const ObjectDescriptor & SimulatedObject::getFathersDescriptor () const {
   if ( _objectDescriptor.getFathersObjectDescriptor () != NULL ) 
      {
         return *_objectDescriptor.getFathersObjectDescriptor () ;
      }
   else 
      {
         return _objectDescriptor ;
      }
} 

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

SimulatedObject * SimulatedObject::getFather () const {
   //refObjet is not always initialised in a distributed environment
   if ( _objectDescriptor.getFathersObjectDescriptor() != NULL )
      {
         return  _controller.getPointerToSimulatedObjectNamed(_objectDescriptor.getFathersObjectDescriptor()->getName());
      }
   else
      {
         return NULL ;
      }
}
const ConfigurationParameterDescriptor * SimulatedObject::getConfigurationParameters() const {
   return _objectDescriptor.getConfigurationParameters();
}


const NameToPointerMap<InputNT> & SimulatedObject::getInputTable () const 
{
   return _inputTable ;
}

const NameToPointerMap<OutputNT> & SimulatedObject::getOutputTable () const  
{
   return _outputTable ;
}

const NameToPointerMap<OutputNT> & SimulatedObject::getControlParameterTable () const  
{
   return _controlParameterTable ;
}

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

void SimulatedObject::sendEvent( const Event &event ) 
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "SimulatedObject::sendEvent( const Event & \""
             << event.eventId << "\" ) to \"" << event.receiver << "\" at " << event.date ) ;
  SimulatedObject *objDest = _controller.getPointerToSimulatedObjectNamed( event.receiver ) ;
  if( objDest == NULL )
  {
    getController().addToPendingEvents( event.clone() ) ; 
  }
  else if( objDest->getObjectHandle() == NULL )
  {
    getController().addToPendingEvents( event.clone() ) ; 
  }
  else
  {
    objDest->getObjectHandle()->receiveEvent( event ) ;
  }
}

void SimulatedObject::sendEvent( Event *event )
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "SimulatedObject::sendEvent ( Event * \"" << event->eventId 
             << "\" ) to \"" << event->receiver << "\" at " << event->date ) ;
  SimulatedObject *objDest = _controller.getPointerToSimulatedObjectNamed( event->receiver ) ;
  if( objDest == NULL ) 
  {
    getController().addToPendingEvents( event ) ; 
  }
  else if( objDest->getObjectHandle() == NULL )
  {
    getController().addToPendingEvents( event ) ; 
  }
  else
  {
    objDest->getObjectHandle()->receiveEvent( event ) ;
  }    
}

void SimulatedObject::sendEvent( SimulatedObject &receiver, const EventIdentifier &eventId )
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "SimulatedObject::sendEvent ( SimulatedObject & \"" << receiver.getName()
             << "\", const EventIdentifier & \"" << eventId << "\" )" ) ;
  sendEvent( &receiver, eventId ) ;
}

void SimulatedObject::sendEvent( SimulatedObject *receiver, const EventIdentifier &eventId )
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "SimulatedObject::sendEvent ( SimulatedObject * \"" << receiver
             << "\", const EventIdentifier & \"" << eventId << "\" )" ) ;
  OMASSERT( receiver != NULL ) ;
  if( receiver->getObjectHandle() != NULL )
  {
    receiver->getObjectHandle()->receiveEvent( new Event( eventId,
                                                             _controller.getSimulatedDate (),
                                                             getName (),
                                                             receiver->getName () ) ) ;
  }
  else
  { //could happen during creation when the object handle is not yet created.
    getController().addToPendingEvents( new Event( eventId,
                                                      _controller.getSimulatedDate (),
                                                      getName (),
                                                      receiver->getName () ) ) ;
  }
}

void SimulatedObject::sendEvent( const Name &receiver, const EventIdentifier &eventId )
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "SimulatedObject::sendEvent( const Name & \"" << receiver 
             <<"\", const EventIdentifier & \"" << eventId << "\" ) at " << _controller.getSimulatedDate() ) ;
  SimulatedObject *objDest = _controller.getPointerToSimulatedObjectNamed( receiver ) ;
  if ( objDest == NULL )
  {
    getController().addToPendingEvents( new Event( eventId,
                                                      _controller.getSimulatedDate (),
                                                      getName (),
                                                      receiver ) ) ;
  }
  else
  {
    sendEvent( objDest, eventId ) ;
  }
}

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

 bool SimulatedObject::processEventsASAP () const 
 {
    //default mode : processEvents at the object's frequency.
    return false ;
 }

//------------------------------------------------------------------
void SimulatedObject::prepareEventProcessing ( list <Event *> & ) {

}

bool SimulatedObject::processEvent (Event * event) {
   return true ;
}

void SimulatedObject::eventsProcessed ( list <Event *> & ) {

}


//------------------------- insertion et extraction d'un objet dans un flot ---------------------

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

void SimulatedObject::extract (istream & in)
{
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":extract" ) ;
  NameToPointerMap<OutputNT>::iterator pOutput; // iterateur
  OutputNT *outputCourante;
  NameToPointerMap<OutputNT>::iterator pParam; // iterateur
  OutputNT *paramCourant;

  // Pour toutes les outputs, on stocke
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
  {
    outputCourante = (*pOutput).second;
    in >> *outputCourante;
  } 
  bool avecParam;
  in >> avecParam;
  if (avecParam) 
  {
    OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":extract extract parameters" ) ;
    for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++)
    {
            paramCourant = (*pParam).second;
            in >> *paramCourant;
            OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pParam).first ) ;
    }
  }
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":extract done " ) ;
}

//------------------------------------------------------------------
void SimulatedObject::pack ( OutgoingSynchronisationMessage & out) const
{
  //make sure the object has been encapsulated in an object handle
  OMASSERT( getObjectHandle() != NULL ) ;
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":pack" ) ;

  // store the value of all outputs
  for( NameToPointerMap<OutputNT>::const_iterator pOutput = _outputTable.begin(); 
       pOutput != _outputTable.end(); 
       ++pOutput)
  {
    OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pOutput).first ) ;
    pOutput->second->pack (out) ;
  } 
  
  bool mettreParam = ( getObjectHandle()->controlParametersChanged() ) || 
                     (getSimulatedDate() == Controller::initialSimulationDate) ;

  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":pack: " << ( mettreParam ? "packing control parameters" : "control parameters not packed" ) );

  if(mettreParam) 
  {
    out << SynchronisationMessage::controlParameters;
    for( NameToPointerMap<OutputNT>::const_iterator pParam= _controlParameterTable.begin(); 
               pParam!= _controlParameterTable.end(); 
               pParam++) 
    {
      OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pParam).first ) ;
      (*pParam).second->pack(out) ;
    }
  }
  else
  {
          out << SynchronisationMessage::noControlParameters;
  }
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":pack done " ) ;
  out << SynchronisationMessage::endOfSynchronisationFragment ;
}

void SimulatedObject::packAllValues ( OutgoingSynchronisationMessage & out) const
{
  //make sure the object has been encapsulated in an object handle
  OMASSERT (getObjectHandle() != NULL) ;

  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:"<< this <<":packAllValues" ) ;

  // store the value of all outputs
  for( NameToPointerMap<OutputNT>::const_iterator pOutput = _outputTable.begin(); 
       pOutput != _outputTable.end(); 
       ++pOutput)
  {
    OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pOutput).first ) ;
          pOutput->second->packAllValues (out) ;
  } 
  
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:"<< this <<":pack: packing control parameters" ) ;
  out<<SynchronisationMessage::controlParameters;
  for( NameToPointerMap<OutputNT>::const_iterator pParam = _controlParameterTable.begin(); 
       pParam!= _controlParameterTable.end(); 
       pParam++) 
  {
    OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pParam).first ) ;
    (*pParam).second->packAllValues(out) ;
  }

  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:"<< this <<":pack done " ) ;
  out << SynchronisationMessage::endOfSynchronisationFragment ;
}


void SimulatedObject::unpack (IncomingSynchronisationMessage & in) 
{
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:"<< this <<":unpack" ) ;
  Name attributeName ;
  NameToPointerMap<OutputNT>::iterator pOutput = _outputTable.begin();

  attributeName.unpack( in ) ;
  while( (attributeName != SynchronisationMessage::controlParameters)
            && (attributeName != SynchronisationMessage::noControlParameters) )
  {
          if ( pOutput->first == attributeName )
          {
      (pOutput->second)->unpack(in) ;
      ++pOutput ;
          }
          else
          {
            do 
                  {
        ++pOutput ;
        OMASSERT ( pOutput != _outputTable.end() ) ;// a new output has been added : not accepted
                  } while ( pOutput->first != attributeName ) ;

      (pOutput->second)->unpack ( in ) ;
      ++pOutput ;
    }
          attributeName.unpack ( in ) ;
  }
   
  if (attributeName == SynchronisationMessage::controlParameters) 
  {
    //the control parameters have been added to the synchronisation message
    pOutput =  _controlParameterTable.begin();
    attributeName.unpack ( in ) ;
    while ( attributeName != SynchronisationMessage::endOfSynchronisationFragment )
    {
      if ( pOutput->first == attributeName )
      {
        (pOutput->second)->unpack( in ) ;
        ++pOutput ;
      }
      else
      {
        do 
        {
          ++pOutput ;
          OMASSERT ( pOutput != _controlParameterTable.end() ) ;// a new control parameter has been added : not accepted
        } while ( pOutput->first != attributeName ) ;

        (pOutput->second)->unpack (in) ;
        ++pOutput ;
      }
      attributeName.unpack ( in ) ;
    }
  }
  else
  { // consume the OMKPvmMessage::endOfSyncronisationMessage 
    attributeName.unpack ( in ) ;
  }    
}


void SimulatedObject::unpackAllValues (IncomingSynchronisationMessage & in) 
{
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:"<< this <<":unpackAllValues" ) ;
  Name attributeName ;
  NameToPointerMap<OutputNT>::iterator pOutput = _outputTable.begin();

  attributeName.unpack( in ) ;
  while( (attributeName != SynchronisationMessage::controlParameters)
    && (attributeName != SynchronisationMessage::noControlParameters) )
  {
    if ( pOutput->first == attributeName )
    {
      (pOutput->second)->unpackAllValues(in) ;
      ++pOutput ;
    }
    else
    {
      do 
      {
        ++pOutput ;
        OMASSERT ( pOutput != _outputTable.end() ) ;// a new output has been added : not accepted
      } while ( pOutput->first != attributeName ) ;

      (pOutput->second)->unpackAllValues ( in ) ;
      ++pOutput ;
    }
    attributeName.unpack ( in ) ;
  }

  if (attributeName == SynchronisationMessage::controlParameters) 
  {
    //the control parameters have been added to the synchronisation message
    pOutput =  _controlParameterTable.begin();
    attributeName.unpack ( in ) ;
    while ( attributeName != SynchronisationMessage::endOfSynchronisationFragment )
    {
      if ( pOutput->first == attributeName )
      {
        (pOutput->second)->unpackAllValues( in ) ;
        ++pOutput ;
      }
      else
      {
        do 
        {
          ++pOutput ;
          OMASSERT ( pOutput != _controlParameterTable.end() ) ;// a new control parameter has been added : not accepted
        } while ( pOutput->first != attributeName ) ;

        (pOutput->second)->unpackAllValues (in) ;
        ++pOutput ;
      }
      attributeName.unpack ( in ) ;
    }
  }
  else
  {
    // consume the OMKPvmMessage::endOfSyncronisationMessage 
    attributeName.unpack ( in ) ;
  }    
}



void SimulatedObject::insertInStream (ostream & out) const
{
  NameToPointerMap<OutputNT>::const_iterator pOutput; // iterateur
  OutputNT * outputCourante;
  NameToPointerMap<OutputNT>::const_iterator pParam; // iterateur
  OutputNT *paramCourant;
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject::insertInStream" ) ;

  // Pour toutes les outputs, on stocke
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
  {
    outputCourante = (*pOutput).second;
    OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pOutput).first << endl << *outputCourante ) ;
    out << *outputCourante << " ";
  }  
  bool mettreParam = getObjectHandle()->controlParametersChanged()
                  || (getSimulatedDate()==Controller::initialSimulationDate) ;
  OMTRACEID( OMK_DEBUG_OMK_MULTI, mettreParam ) ;
  out << mettreParam << " ";
  if(mettreParam) 
  {
    for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++) 
    {
            paramCourant = (*pParam).second;
      OMTRACEID( OMK_DEBUG_OMK_MULTI, (*pParam).first ) ;
            out << *paramCourant << " ";
    }
  }
  OMTRACEID( OMK_DEBUG_OMK_MULTI, "SimulatedObject:" << this << ":insertInStream done" ) ;
}

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



void SimulatedObject::fireSignal(const EventIdentifier & sig) 
{
  Event event(sig,getSimulatedDate(),getName(),getName()) ;
  //does firing a signal during creation have any sense ? yes


  if ( dynamic_cast<ReferenceObjectHandle *> ( getObjectHandle()) != NULL) {
    if (getObjectHandle() != NULL ) 
    {
      getObjectHandle()->sendEventsForSignal( event , sig ) ;
    }
    else
    {  
      // no registration can have taken place, as this should only happen at object creation,
      // so just broadcast the signal
      getController().broadcastEventsForSignal ( event, sig ) ;
    }
  }
  else OMTRACE("ERREUR No send Event when SimObj DEAD");
}

bool SimulatedObject::registerForSignalBy ( const EventIdentifier & sig, 
                                              const Name & producer )
{
   return registerForSignalBy ( sig, producer, sig ) ;
}



bool SimulatedObject::registerForSignalBy ( const EventIdentifier & sig, 
                                              const Name & producer,
                                              const EventIdentifier & eventId )
{
   SimulatedObject * pointerToProducer ;
   pointerToProducer = _controller.getPointerToSimulatedObjectNamed ( producer );
   if (pointerToProducer != NULL) 
      {
         return registerForSignalBy(sig, pointerToProducer, eventId);
      }
   else 
      {
         return getController().addToPendingRegistrations ( sig , producer, eventId, getName() ) ;
      }
}



bool SimulatedObject::registerForSignalBy(const EventIdentifier & sig, 
                                            SimulatedObject * producer )
{
   return registerForSignalBy ( sig , producer , sig ) ;
}



bool SimulatedObject::registerForSignalBy(const EventIdentifier & sig, 
                                            SimulatedObject & producer )
{
   return registerForSignalBy ( sig , producer , sig ) ;
}



bool SimulatedObject::registerForSignalBy(const EventIdentifier & sig, 
                                            SimulatedObject * producer,
                                            const EventIdentifier & eventId )
{
   OMASSERT ( producer != NULL ) ;
   //unless registring for oneself during creation, the next if branch should allways be verified
   if (producer->getObjectHandle() != NULL)
      {
         return producer->getObjectHandle()->receiveRegistrationForSignal ( sig, getName(), eventId ) ;
      }
   else 
      {
         return getController().addToPendingRegistrations (sig, 
                                                           producer->getName() ,
                                                           eventId,
                                                           getName() ) ;
      }
}



bool SimulatedObject::registerForSignalBy(const EventIdentifier & sig, 
                                            SimulatedObject & producer,
                                            const EventIdentifier & eventId )
{
   if (producer.getObjectHandle() != NULL)
      {
         //unless registring for oneself during creation, the next if branch should allways be verified
         return producer.getObjectHandle()->receiveRegistrationForSignal ( sig, getName(), eventId ) ;
      }
   else 
      {
         return getController().addToPendingRegistrations (sig, 
                                                           producer.getName(),
                                                           eventId,
                                                           getName() ) ;
      }
}



bool SimulatedObject::registerForSignal( const EventIdentifier & sig ) 
{
  return _controller.receiveRegistrationForSignal ( sig, getName(), sig);
}



bool SimulatedObject::registerForSignal(const EventIdentifier & sig,
                                          const EventIdentifier & eventId) 
{
  return _controller.receiveRegistrationForSignal ( sig, getName(), eventId );
}



bool SimulatedObject::cancelRegistrationForSignalBy(const EventIdentifier & sig, const Name & producer){
   SimulatedObject * pointerToProducer ;
   pointerToProducer = _controller.getPointerToSimulatedObjectNamed( producer );
   if (pointerToProducer != NULL) 
      {
         return cancelRegistrationForSignalBy(sig,pointerToProducer);
      }
   else 
      {
         return getController().removeFromPendingRegistrations ( sig, producer, getName() ) ;
      }
}

bool SimulatedObject::cancelRegistrationForSignalBy(const EventIdentifier & sig, SimulatedObject * producer)
{
   OMASSERT ( producer != NULL ) ;
   //unless canceling a registration for oneself during creation, the next if sould be verified
   if ( producer->getObjectHandle() != NULL )
      {
         return producer->getObjectHandle()->cancelRegistrationForSignal ( sig, getName() ) ;
      }
   else
      {
         return getController().removeFromPendingRegistrations (sig, producer->getName(), getName() ) ;
      }
}

bool SimulatedObject::cancelRegistrationForSignalBy(const EventIdentifier & sig, SimulatedObject & producer)
{
   //unless canceling a registration for oneself during creation, the next assertion sould be verified
   if ( producer.getObjectHandle() != NULL )
      {    
         return producer.getObjectHandle()->cancelRegistrationForSignal ( sig, getName() ) ;
      }
   else
      {
         return getController().removeFromPendingRegistrations (sig, producer.getName(), getName() ) ;
      }
}


bool SimulatedObject::cancelRegistrationForSignal(const EventIdentifier & sig) 
{
   return _controller.receiveCancellationForSignal(sig,getName());
}


const Date & SimulatedObject::getSimulatedDate () const {
   return _controller.getSimulatedDate();
}



bool SimulatedObject::isAncestor(const Name & name) 
{
   bool result = false ;
   const ObjectDescriptor * ancestorDescriptor = getObjectDescriptor().getFathersObjectDescriptor() ;
   while ( (ancestorDescriptor != NULL) &&
           !result )
      {
         if ( ancestorDescriptor->getName() == name)
            {
               result = true ;
            }
         ancestorDescriptor = ancestorDescriptor->getFathersObjectDescriptor() ;
      }
   return result ;
}



const list < EventListener * > & SimulatedObject::getEventListeners () const 
{
   return _listOfEventListeners ;
}

 // Modification 2007/05/11 Benoit Chanclou
 // The registration must be made for the event listener if the object 
 // handler is already created.
 // Two case to call 'registerEvents' :
 // Case 1 : The event listener is created during the object constructor call,
 // the object handler during its constructor calls 'registerEvents' for each 
 // event listeners stored in '_listOfEventListeners' (see ReferenceObjectHandle constructor).
 // Case 2 : The event listener is created after the object constructor, the 
 // 'registerEvents' which is not automatically called by the object handler 
 // must be called here
void SimulatedObject::addEventListener ( EventListener & eventListener ) 
{
  // To avoid twice registration of the same event handler
  if( find(_listOfEventListeners.begin(), _listOfEventListeners.end(), & eventListener ) == _listOfEventListeners.end() )
  {
    _listOfEventListeners.push_front( &eventListener ) ;
    if( getObjectHandle() ) 
    {
      eventListener.registerEvents() ;
    }
  }
}

void SimulatedObject::registerEventListenerForEvent( EventListener & eventListener, 
                                                       const EventIdentifier & eventId ) 
{
   //this member function should only be called by event listeners when registering the events they are associated to
   //this registration process is initiated during the creation of the assocaited object handle
   // or after its creation
   //therefore, the following assertion should allways be verified
   OMASSERT( getObjectHandle() ); 

   getObjectHandle()->registerEventListenerForEvent( eventListener , eventId ) ;
}

void SimulatedObject::unregisterEventListener( EventListener & eventListener ) 
{
  std::list <EventListener *>::iterator listener = find(_listOfEventListeners.begin(), _listOfEventListeners.end(), & eventListener ) ;
  _listOfEventListeners.erase( listener ) ;
   //this member function is only called by the destructor of the event listeners 
   OMASSERT( getObjectHandle() ); 

   getObjectHandle()->unregisterEventListener( eventListener ) ;
}

---