---

PsSimulatedObject.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 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 "PsName.h"
#include <PsSimulatedObject.h>
//#include <PsnReferenceObjectHandle.h>
//#include <PsnMirrorObjectHandle.h>
#include <PsObjectDescriptor.h>
#include <PsnReferenceObjectHandle.h>
#include <PsnMirrorObjectHandle.h>
#include <PsOutput.h>
#include <PsNameToPointerMap.h>
#include <PsInput.h>
#include <PsString.h>
#include <PsnSemaphore.h>
#include <PsEventIdentifier.h>
#include "PsEvent.h"
#include "PsEventListener.h"
#include "PsSystemEventIdentifier.h"
#ifdef _PSGUI
#include <PsCtrlLocGui.h>
extern "C" IlvBoolean IlvSetLanguage();
#endif
#ifdef _REACT
#include <PsReactController.h>
#endif

//------------------------------------------------------------------
#include <PsnMirrorObjectHandle.h>
#include "PsSimulatedObjectCreator.h"
#include "PsSynchronisationMessage.h" 


PsnObjectHandle * PsSimulatedObject::getObjectHandle() const 
{
   return _objectHandle ;
}


void PsSimulatedObject::setObjectHandle( PsnObjectHandle * objectHandle ) 
{
   assert ( _objectHandle == NULL ) ;
   _objectHandle = objectHandle ;
}

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

const PsObjectDescriptor & PsSimulatedObject::getObjectDescriptor () const {
   return _objectDescriptor ;
}



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

PsSimulatedObject::PsSimulatedObject ( PsController & ctrl, const PsObjectDescriptor & objectDecriptor ) : 
   PsFlowable(),
   _controller ( ctrl ),
   _objectDescriptor ( objectDecriptor ),
   _objectHandle ( NULL )
{
   _objectDescriptor._pointerToSimulatedObject = this ;
}

//------------------------------------------------------------------
PsSimulatedObject:: ~PsSimulatedObject ()
{
  // destroy inputs, outputs and control parameters
   
  PsNameToPointerMap<PsOutputNT>::iterator pOutput; // iterateur
  PsOutputNT *outputCourante;
  PsNameToPointerMap<PsOutputNT>::iterator pParam; // iterateur
  PsOutputNT *paramCourant;
  PsNameToPointerMap<PsInputNT>::iterator pInput; // iterateur
  PsInputNT *inputCourant;

  // Pour toutes les outputs, on detruit ;

#ifdef _DEBUGEXEC
  cerr<<"PsSimulatedObject:: ~PsSimulatedObject ()  : destruction des paramètres ";
#endif
  for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++)
    {
      paramCourant = getPointerToControlParameterNamed ((*pParam).first);
      delete paramCourant;
    }
#ifdef _DEBUGEXEC
  cerr<<"effective"<<endl;
  cerr<<"PsSimulatedObject:: ~PsSimulatedObject ()  : destruction des entrées ";
#endif
  for(pInput= _inputTable.begin(); pInput!=_inputTable.end();pInput++)
    {
      inputCourant = getPointerToInputNamed ((*pInput).first);
      delete inputCourant ;
    }
#ifdef _DEBUGEXEC
  cerr<<"effective"<<endl;
  cerr<<"PsSimulatedObject:: ~PsSimulatedObject ()  : destruction des outputs ";
#endif
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
    {
       outputCourante = getPointerToOutputNamed ((*pOutput).first);
       delete outputCourante;
    }
#ifdef _DEBUGEXEC
  cerr<<"effective"<<endl;
  cerr<<"PsSimulatedObject:: ~PsSimulatedObject ()  : encapsulated classes creators destruction ";
#endif
 
#ifdef _DEBUGEXEC
  cerr<<"effective"<<endl;
#endif
  PsNameToPointerMap<PsSimulatedObjectCreator>::iterator pEncapsulatedClassesTable ;
  for( pEncapsulatedClassesTable = _encapsulatedClassesTable.begin() ;
       pEncapsulatedClassesTable != _encapsulatedClassesTable.end() ;
       pEncapsulatedClassesTable++ )
     {
        delete (*pEncapsulatedClassesTable).second ;
     }

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

}

void PsSimulatedObject::deleteInput(const PsName & nom) {
   PsInputNT * obj;
   obj = (_inputTable)[nom];
   _inputTable.erase(nom);
   if(obj!=NULL) {
      delete obj;
   }
}

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

PsOutputNT * PsSimulatedObject::getPointerToControlParameterNamed (const PsName & nomAtt) const {
   return (_controlParameterTable.getObjectOfIndex (nomAtt)) ;
} 
 
//---------------------------------------------------------------------

PsOutputNT * PsSimulatedObject::getPointerToOutputNamed (const PsName & nomAtt) const {
   PsOutputNT * ref ;
   ref = _outputTable.getObjectOfIndex (nomAtt) ;
   if (ref == NULL) {
#ifdef _USESSTREAM
      ostringstream warningMessage ;
      warningMessage<< "PsSimulatedObject::getPointerToOutputNamed: "
                    << nomAtt << " is an unknown output for object "<<getName()<<endl ;
      PsController::warning (warningMessage.str(), PsController::AllWarnings) ;
#else
         ostrstream warningMessage ;
         warningMessage<< "PsSimulatedObject::getPointerToOutputNamed: "
                       << nomAtt << " is an unknown output for object "<<getName()<<endl ;
         warningMessage.put ('\0') ;
         PsController::warning (warningMessage.str(), PsController::AllWarnings) ;
         delete warningMessage.str() ;
#endif
   }
   return ref ;
} 

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

PsInputNT * PsSimulatedObject::getPointerToInputNamed (const PsName & nomAtt) const {
   return (_inputTable.getObjectOfIndex (nomAtt));
} 


//------------------------------------------------------------------
// Nom symbolique de l'objet
const PsName & PsSimulatedObject::getName() const {
    return _objectDescriptor.getName();
}

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

PsController & PsSimulatedObject::getController () const {
  return _controller;
}


void PsSimulatedObject::init() 
{
}



void PsSimulatedObject::compute ()
{
}

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

void PsSimulatedObject::finish() 
{
}

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

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

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

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

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

PsSimulatedObject * PsSimulatedObject::getFather () const {
   //refObjet n'est pas toujours initialisé en distribué.
   if ( _objectDescriptor.getFathersObjectDescriptor() != NULL )
      {
         return  _controller.getPointerToSimulatedObjectNamed(_objectDescriptor.getFathersObjectDescriptor()->getName());
      }
   else
      {
         return NULL ;
      }
}
const PsConfigurationParameterDescriptor * PsSimulatedObject::getConfigurationParameters() const {
   return _objectDescriptor.getConfigurationParameters();
}


const PsNameToPointerMap<PsInputNT> & PsSimulatedObject::getInputTable () const 
{
   return _inputTable ;
}

const PsNameToPointerMap<PsOutputNT> & PsSimulatedObject::getOutputTable () const  
{
   return _outputTable ;
}

const PsNameToPointerMap<PsOutputNT> & PsSimulatedObject::getControlParameterTable () const  
{
   return _controlParameterTable ;
}

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

 void PsSimulatedObject::sendEvent ( const PsEvent & event ) {
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent ( const PsEvent & )"<<endl;
    cerr<<"   Sent "<<event.eventId<<" to "<<event.receiver <<" at "<<event.date<<endl;
#endif
    PsSimulatedObject * 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 PsSimulatedObject::sendEvent ( PsEvent * event ) {
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent ( PsEvent * )"<<endl;
    cerr<<"   Sent "<<event->eventId<<" to "<<event->receiver <<" at "<<event->date<<endl;
#endif
    PsSimulatedObject * 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 PsSimulatedObject::sendEvent ( PsSimulatedObject & receiver , const PsEventIdentifier & eventId ) {
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent ( PsSimulatedObject & "<<receiver<<" const PsEventIdentifier & "<<eventId <<" )"<<endl;
#endif
    sendEvent (&receiver, eventId ) ;
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent () fin"<<endl;
#endif
 }

 void PsSimulatedObject::sendEvent ( PsSimulatedObject * receiver , const PsEventIdentifier & eventId ) {
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent ( PsSimulatedObject * "<<receiver<<" const PsEventIdentifier & "<<eventId <<" )"<<endl;
#endif
    assert ( receiver != NULL ) ;
    if ( receiver->getObjectHandle() != NULL )
       {
          receiver->getObjectHandle()->receiveEvent (new PsEvent (eventId,
                                                                  _controller.getSimulatedDate (),
                                                                  getName (),
                                                                  receiver->getName ()) ) ;
       }
    else
       //could happen during creation when the object handle is not yet created.
       {
          getController().addToPendingEvents(new PsEvent (eventId,
                                                          _controller.getSimulatedDate (),
                                                          getName (),
                                                          receiver->getName ())  ) ; 
       }
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent () fin"<<endl;
#endif
 }
 
 void PsSimulatedObject::sendEvent ( const PsName & receiver , const PsEventIdentifier & eventId ) {
#ifdef _DEBUGEVT
    cerr<<"PsSimulatedObject::sendEvent ( const PsName & , const PsEventIdentifier & )"<<endl;
    cerr<<"   Sent "<<eventId<<" to "<<receiver <<" at "<<_controller.getSimulatedDate ()<<endl;
#endif
    PsSimulatedObject * objDest= _controller.getPointerToSimulatedObjectNamed( receiver ) ;
    if ( (objDest == NULL) ) 
       {
          getController().addToPendingEvents(new PsEvent (eventId,
                                                          _controller.getSimulatedDate (),
                                                          getName (),
                                                          receiver) )  ; 
       }
    else if ( objDest->getObjectHandle() == NULL )
       {
          getController().addToPendingEvents (new PsEvent (eventId,
                                                           _controller.getSimulatedDate (),
                                                           getName (),
                                                           receiver) ) ;
       }
    else {
       objDest->getObjectHandle()->receiveEvent (new PsEvent (eventId,
                                                              _controller.getSimulatedDate (),
                                                              getName (),
                                                              receiver) ) ;
    } 
 }

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

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

//------------------------------------------------------------------
void PsSimulatedObject::prepareEventProcessing ( list <PsEvent *> & ) {

}

bool PsSimulatedObject::processEvent (PsEvent * event) {
   return true ;
}

void PsSimulatedObject::eventsProcessed ( list <PsEvent *> & ) {

}


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

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

void PsSimulatedObject::extract (istream & in)
{
  PsNameToPointerMap<PsOutputNT>::iterator pOutput; // iterateur
  PsOutputNT *outputCourante;
  PsNameToPointerMap<PsOutputNT>::iterator pParam; // iterateur
  PsOutputNT *paramCourant;

  // Pour toutes les outputs, on stocke
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
    {
      outputCourante = (*pOutput).second;
      in >> *outputCourante;
    } 
 bool avecParam;
  in >> avecParam;
#ifdef _DEBUGPVMMESS
  cerr<<endl<<avecParam<<" "<<true<<" "<<false<<endl;;
#endif
  if (avecParam) {
     //cerr<<"PsSimulatedObject::extract extraction des paramètres de "<<getName()<<" ";
     for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++) {
        paramCourant = (*pParam).second;
        in >> *paramCourant;
        //cerr<<(*pParam).first<<" ";
     }
     //cerr<<endl;
  }
#ifdef DEBUG
  cout << "PsSimulatedObject::extract fin : " << getName() << endl ;
#endif
}

//------------------------------------------------------------------
void PsSimulatedObject::pack ( PsOutgoingSynchronisationMessage & out) const
{
   //make sure the object has been encapsulated in an object handle
   assert (getObjectHandle() != NULL) ;

#ifdef _DEBUGPVMMESS
   cout << "PsSimulatedObject:"<<this<<":pack"<< endl ;
#endif

   // store the value of all outputs
   for(PsNameToPointerMap<PsOutputNT>::const_iterator pOutput = _outputTable.begin(); 
       pOutput != _outputTable.end(); 
       ++pOutput)
     {
#ifdef _DEBUGPVMMESS
        cerr<<(*pOutput).first<<" ";
#endif
        pOutput->second->pack (out) ;
     } 
  
   bool mettreParam = ( getObjectHandle()->controlParametersChanged() ) || 
                      (getSimulatedDate() == PsController::initialSimulationDate) ;

#ifdef _DEBUGPVMMESS
   cerr<<endl ;
   if ( mettreParam )
      {
         cerr<<"PsSimulatedObject:"<<this<<":pack: packing control parameters"<<endl;
      }
   else
      {
         cerr<<"PsSimulatedObject:"<<this<<":pack: not packing control parameters"<<endl;
      }
#endif

   if(mettreParam) 
      {
         out<<PsSynchronisationMessage::controlParameters;
         for(PsNameToPointerMap<PsOutputNT>::const_iterator pParam= _controlParameterTable.begin(); 
             pParam!= _controlParameterTable.end(); 
             pParam++) 
            {
#ifdef _DEBUGPVMMESS
               cout << (*pParam).first << " ";
#endif
               (*pParam).second->pack(out) ;
            }
      }
   else
      {
         out<<PsSynchronisationMessage::noControlParameters;
      }
#ifdef DEBUG
  cerr << "PsSimulatedObject:"<<this<<":pack done "<< endl ;
#endif
  out << PsSynchronisationMessage::endOfSynchronisationFragment ;
}

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

#ifdef _DEBUGPVMMESS
   cout << "PsSimulatedObject:"<<this<<":packAllValues"<< endl ;
#endif

   // store the value of all outputs
   for(PsNameToPointerMap<PsOutputNT>::const_iterator pOutput = _outputTable.begin(); 
       pOutput != _outputTable.end(); 
       ++pOutput)
     {
#ifdef _DEBUGPVMMESS
        cerr<<(*pOutput).first<<" ";
#endif
        pOutput->second->packAllValues (out) ;
     } 
  

#ifdef _DEBUGPVMMESS
   cerr<<endl ;
   cerr<<"PsSimulatedObject:"<<this<<":pack: packing control parameters"<<endl;
#endif

   out<<PsSynchronisationMessage::controlParameters;
   for(PsNameToPointerMap<PsOutputNT>::const_iterator pParam= _controlParameterTable.begin(); 
       pParam!= _controlParameterTable.end(); 
       pParam++) 
      {
#ifdef _DEBUGPVMMESS
         cout << (*pParam).first << " ";
#endif
         (*pParam).second->packAllValues(out) ;
      }
   
#ifdef DEBUG
  cerr << "PsSimulatedObject:"<<this<<":pack done "<< endl ;
#endif
  out << PsSynchronisationMessage::endOfSynchronisationFragment ;
}


void PsSimulatedObject::unpack (PsIncomingSynchronisationMessage & in) 
{

#ifdef _DEBUGPVMMESS
   cout << "PsSimulatedObject:"<<this<<":unpack"<< endl ;
#endif
   PsName attributeName ;
   PsNameToPointerMap<PsOutputNT>::iterator pOutput = _outputTable.begin();
   
   
   attributeName.unpack( in ) ;
   while ( (attributeName != PsSynchronisationMessage::controlParameters)
           && (attributeName != PsSynchronisationMessage::noControlParameters) )
      {
         if ( pOutput->first == attributeName )
            {
               (pOutput->second)->unpack(in) ;
               ++pOutput ;
            }
         else
            {
               do 
                  {
                     ++pOutput ;
                     assert ( 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 == PsSynchronisationMessage::controlParameters) 
      {
         //the control parameters have been added to the synchronisation message
         pOutput =  _controlParameterTable.begin();
         attributeName.unpack ( in ) ;
         while ( attributeName != PsSynchronisationMessage::endOfSynchronisationFragment )
            {
               if ( pOutput->first == attributeName )
                  {
                     (pOutput->second)->unpack( in ) ;
                     ++pOutput ;
                  }
               else
                  {
                     do 
                        {
                           ++pOutput ;
                           assert ( 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 PsnPvmMessage::endOfSyncronisationMessage 
         attributeName.unpack ( in ) ;
      }    
}


void PsSimulatedObject::unpackAllValues (PsIncomingSynchronisationMessage & in) 
{

#ifdef _DEBUGPVMMESS
   cout << "PsSimulatedObject:"<<this<<":unpackAllValues"<< endl ;
#endif
   PsName attributeName ;
   PsNameToPointerMap<PsOutputNT>::iterator pOutput = _outputTable.begin();
   
   attributeName.unpack( in ) ;
   while ( (attributeName != PsSynchronisationMessage::controlParameters)
           && (attributeName != PsSynchronisationMessage::noControlParameters) )
      {
         if ( pOutput->first == attributeName )
            {
               (pOutput->second)->unpackAllValues(in) ;
               ++pOutput ;
            }
         else
            {
               do 
                  {
                     ++pOutput ;
                     assert ( 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 == PsSynchronisationMessage::controlParameters) 
      {
         //the control parameters have been added to the synchronisation message
         pOutput =  _controlParameterTable.begin();
         attributeName.unpack ( in ) ;
         while ( attributeName != PsSynchronisationMessage::endOfSynchronisationFragment )
            {
               if ( pOutput->first == attributeName )
                  {
                     (pOutput->second)->unpackAllValues( in ) ;
                     ++pOutput ;
                  }
               else
                  {
                     do 
                        {
                           ++pOutput ;
                           assert ( 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 PsnPvmMessage::endOfSyncronisationMessage 
         attributeName.unpack ( in ) ;
      }    
}



void PsSimulatedObject::insertInStream (ostream & out) const
{
  PsNameToPointerMap<PsOutputNT>::const_iterator pOutput; // iterateur
  PsOutputNT * outputCourante;
  PsNameToPointerMap<PsOutputNT>::const_iterator pParam; // iterateur
  PsOutputNT *paramCourant;
#ifdef DEBUG
  cout << "PsSimulatedObject::insertInStream"<< endl ;
#endif

  // Pour toutes les outputs, on stocke
  for(pOutput= _outputTable.begin(); pOutput!= _outputTable.end(); pOutput++)
    {
#ifdef _DEBUGPVMMESS
       cerr<<(*pOutput).first<<" ";
#endif
      outputCourante = (*pOutput).second;
      out << *outputCourante << " ";
#ifdef _DEBUGPVMMESS
      cerr << *outputCourante << " "<<endl;
#endif
    }  
  bool mettreParam = getObjectHandle()->controlParametersChanged();
  if(getSimulatedDate()==PsController::initialSimulationDate) mettreParam=true;
#ifdef _DEBUGPVMMESS
  cerr<<endl<<mettreParam<<" "<<true<<" "<<false<<endl;;
#endif
  out<<mettreParam<<" ";
  if(mettreParam) {
     for(pParam= _controlParameterTable.begin(); pParam!= _controlParameterTable.end(); pParam++) {
        paramCourant = (*pParam).second;
#ifdef _DEBUGPVMMESS
        cout << (*pParam).first << " ";
#endif
        out << *paramCourant << " ";
     }
  }
#ifdef DEBUG
  cout << "PsSimulatedObject::insertInStream fini"<< endl ;
#endif
}

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



void PsSimulatedObject::fireSignal(const PsEventIdentifier & sig) 
{
  PsEvent event(sig,getSimulatedDate(),getName(),getName()) ;
  //does firing a signal during creation have any sense ? yes
  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 ) ;
     }
}

bool PsSimulatedObject::registerForSignalBy ( const PsEventIdentifier & sig, 
                                              const PsName & producer )
{
   return registerForSignalBy ( sig, producer, sig ) ;
}



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



bool PsSimulatedObject::registerForSignalBy(const PsEventIdentifier & sig, 
                                            PsSimulatedObject * producer )
{
   return registerForSignalBy ( sig , producer , sig ) ;
}



bool PsSimulatedObject::registerForSignalBy(const PsEventIdentifier & sig, 
                                            PsSimulatedObject & producer )
{
   return registerForSignalBy ( sig , producer , sig ) ;
}



bool PsSimulatedObject::registerForSignalBy(const PsEventIdentifier & sig, 
                                            PsSimulatedObject * producer,
                                            const PsEventIdentifier & eventId )
{
   assert ( 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 PsSimulatedObject::registerForSignalBy(const PsEventIdentifier & sig, 
                                            PsSimulatedObject & producer,
                                            const PsEventIdentifier & 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 PsSimulatedObject::registerForSignal( const PsEventIdentifier & sig ) 
{
   return _controller.receiveRegistrationForSignal ( sig, getName(), sig);
}



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



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

bool PsSimulatedObject::cancelRegistrationForSignalBy(const PsEventIdentifier & sig, PsSimulatedObject * producer)
{
   assert ( 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 PsSimulatedObject::cancelRegistrationForSignalBy(const PsEventIdentifier & sig, PsSimulatedObject & 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 PsSimulatedObject::cancelRegistrationForSignal(const PsEventIdentifier & sig) 
{
   return _controller.receiveCancellationForSignal(sig,getName());
}


const PsDate & PsSimulatedObject::getSimulatedDate () const {
   return _controller.getSimulatedDate();
}



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



const list < PsEventListener * > & PsSimulatedObject::getEventListeners () const 
{
   return _listOfEventListeners ;
}

void PsSimulatedObject::addEventListener ( PsEventListener & eventListener ) 
{
   _listOfEventListeners.push_front( & eventListener) ;
}

void PsSimulatedObject::registerEventListenerForEvent ( PsEventListener & eventListener, 
                                                        const PsEventIdentifier & 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
   //therefore, the following assertion should allways be verified
   assert ( getObjectHandle () != NULL ); 

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

   eventListener.addToListenedEventIds ( eventId ) ;
}



void PsSimulatedObject::addInstanceCreator(const PsName & className, PsSimulatedObjectCreator * instanceCreator ) 
{
   pair<PsNameToPointerMap < PsSimulatedObjectCreator >::iterator, bool> result = 
      _encapsulatedClassesTable.insert (pair<const PsName, PsSimulatedObjectCreator *>(className,instanceCreator) ) ;
   if ( !result.second )
      //the instance creator was not inserted because an instance creator was allready
      {
         if ( PsController::warningLevel >= PsController::AllWarnings )
            {
               cerr<<"PsSimulatedObject::addInstanceCreator "
                   <<"replaced an instance creator for class "
                   <<className<<endl;
            }
         delete result.first->second ;
         result.first->second = instanceCreator ;
      }
}



const PsNameToPointerMap < PsSimulatedObjectCreator > & 
PsSimulatedObject::getEncapsulatedClassesTable () const 
{
   return _encapsulatedClassesTable ;
}



PsSimulatedObject * 
PsSimulatedObject::createInstanceOfEncapsulatedClass(const PsObjectDescriptor & objectDescriptor ) const
{
#ifdef _DEBUGOBJECTCREATION
  cerr <<"PsSimulatedObject::createInstanceOfEncapsulatedClass (...)"<<endl;
#endif

  PsSimulatedObject * result = NULL ;
  PsNameToPointerMap < PsSimulatedObjectCreator >::const_iterator i = _encapsulatedClassesTable.find(objectDescriptor.getClass () ) ;
  if (i != _encapsulatedClassesTable.end() )
     {
        assert ( i->second != NULL ) ;
        result = i->second->createSimulatedObject( getController() , objectDescriptor ) ;
     }
#ifdef _DEBUGOBJECTCREATION
  cerr <<"PsSimulatedObject::createInstanceOfEncapsulatedClass returns "<<result<<endl;
#endif
  return result ;
}

---