---

PsController.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 <PsController.h>
#include <PsObjectDescriptor.h>
#include <PsnDoubleList.h>
#include <PsnSequentialSemaphore.h>
#include <math.h>
#include <PsObjectDescriptor.h>
#include <PsSimulatedObject.h>
#include <PsnSvmLink.h>
#include <typeinfo>
#include <PsDuplicatedObject.h>
#include "PsName.h"
#include "PsNameServer.h"
#include "PsnScheduler.h"
#include "PsnFrameScheduler.h"

#include <unistd.h>
#include "PsEvent.h"
#include "PsSystemEventIdentifier.h"
#include "PsUserException.h"
#include "PsNullOutputCreator.h"

PsDate PsController::initialSimulationDate = 0 ;
PsController::WarningLevels PsController::warningLevel = PsController::NoWarnings ;

PsKernelObjectAbstractFactory * PsController::kernelObjectFactory = NULL ;

bool PsController::setKernelObjectFactory ( PsKernelObjectAbstractFactory * aFactory )
{
   if ( kernelObjectFactory != NULL ) 
      {
         kernelObjectFactory = aFactory ;
         return true ;
      }
   else 
      {
         return false ;
      }
}

PsKernelObjectAbstractFactory * PsController::getKernelObjectFactory ( ) 
{
   if ( kernelObjectFactory == NULL ) 
      {
         kernelObjectFactory = new PsKernelObjectClassicFactory () ;
      }

   return kernelObjectFactory ;
}

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

PsController::PsController(PsObjectDescriptor & initialObjects,
                           const PsDate & initialDate )   :  
   PsSimulatedObject(*this, initialObjects ), 
   _simulationTree ( initialObjects ),
   _nbStepsByCycle ( 0 ),
   _controledObjectsSignalsDispatcher( *this ),
   _numberOfSimulatedSteps ( 0 ),
   _showDateAndStepNumber ( false ),
   _scheduler (NULL),
   _forcedCompute (false)
{

   PsNullOutputCreator::setController(this) ;

   initialSimulationDate = initialDate ;

   //as a controller created throught this constructor has no controller, create the illusion of being handled
   _objectHandle = createReferenceObjectHandle( *this ) ;
   _computeStatePointer = const_cast<PsnReferenceObjectHandle::SimulatedObjectComputingState *>(&(dynamic_cast<PsnReferenceObjectHandle *>(_objectHandle)->getComputingState () )) ;
   
   //connect the object description to the controller
   _simulationTree._pointerToSimulatedObject = this ;
   _simulationTree._destroySimulatedObject =  false ;

  //create data structures for system events managed by the controller
  _systemEventsList [ 0 ] = new list <PsEvent *> () ;
  _systemEventsList [ 1 ] = new list <PsEvent *> () ;
  _currentWritableSystemEventsList = 0 ;

  //create data structures to keep track of objects needing activation because they have pending events
  _objectsNeedingActivationList[0]=new list<PsnReferenceObjectHandle *> () ;
  _objectsNeedingActivationList[1]=new list<PsnReferenceObjectHandle *> () ;
  _currentListOfObjectsNeedingActivation = 0 ;

   // initialisation de l'état du controleur
  assert ( _computeStatePointer != NULL ) ;
   *_computeStatePointer = PsnReferenceObjectHandle::initial ;
}

void PsController::finish()
{
#ifdef _DEBUGEXEC
   cerr<<"PsController::finish()"<<endl;
#endif
   //call destroyObject on all the sons
   for ( PsObjectDescriptor::SonsContainerType::iterator i = _simulationTree.getSons().begin() ;
         i !=  _simulationTree.getSons().end() ;
         ++i )
      {
         assert ( (*i) != NULL ) ;
         destroyObject ( (*i)->getName() ,true ) ;
      }
}


PsController::~PsController() 
{
  int i;
  int minor;
  
  if ( _scheduler != NULL ) 
     {
        delete _scheduler ;
        _scheduler = NULL ;
     }

  // destruction of data structures related to event handling
  for(i=0;i<2;i++) 
     {
        if ( _systemEventsList[i] != NULL ) delete  _systemEventsList[i] ;
        if ( _objectsNeedingActivationList[i] != NULL) delete _objectsNeedingActivationList[i];
     }

  purgeMemoryFromOldEvents ( _date + _stepPeriod ) ;
  
  // destruction of pending registrations
  for ( map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.begin() ;
        i != _pendingRegistrationRequests.end() ;
        ++i )
     {
        // delete the signal dispatcher
        delete i->second ;
        
        // removal from the map omitted, because automatic at destruction of the data member
     }
  

  if ( _objectHandle != NULL ) delete _objectHandle ;
}



void PsController::createControlledObjects( const PsObjectDescriptor * subTree ) 
{
   assert ( subTree != NULL ) ;
   //go through the simulation tree to find all objects that have to be created
   list<PsObjectDescriptor *>::const_iterator i = subTree->getSons()->begin() ;

   while ( i != subTree->getSons()->end() )
      {
         assert ( *i != NULL ) ;
#ifdef _DEBUGOBJECTCREATION
         cerr<<"Creating "<< (*i)->getName() << endl ;
#endif
         //create the object
         createReferenceObject ( *i ) ;
         
         //create the subTree of that object
         createControlledObjects ( *i ) ;
         
#ifdef _DEBUGOBJECTCREATION
         cerr<<"Created "<< (*i)->getName() << endl ;
#endif
         ++i ;
      }
}



void PsController::computeScheduling(bool fromOriginal)
{
   //cerr<<"PsController::computeScheduling at date "<<_date<<endl;
  
   list<PsObjectDescriptor * > objectDescriptorList ;
   int freq;
   
   _simulationTree.getDescendants( &objectDescriptorList );
   
   list<PsObjectDescriptor * >::iterator i ;
 
   //remove objects with no frequency from the list
   i = objectDescriptorList.begin () ;

   while ( i != objectDescriptorList.end() )
      {
         if ( fromOriginal )
            {
               if ((*i)->getOriginalFrequency() == 0 )
                  {
                     i = objectDescriptorList.erase ( i ) ;
                  }
               else
                  {
                     ++i ;
                  }
            }
         else
            {
               if ( (*i)->getFrequency() == 0 )
                  {
                     i = objectDescriptorList.erase ( i ) ;
                  }
               else
                  {
                     ++i ;
                  }
            }
      }

    i = objectDescriptorList.begin () ;
   
   if ( i == objectDescriptorList.end() ) 
      {
         //no objects need regular activation
         if ( fromOriginal )
            {
               _stepFrequency = _simulationTree.getOriginalFrequency() ;
            }
         else 
            {
               _stepFrequency = _simulationTree.getFrequency() ;
            }
         if ( _stepFrequency == 0 ) 
            {
               warning ("Controller needs a frequency: assigning 1", SomeWarnings) ;
               _stepFrequency = 1 ;
           }
        setCycleFrequency(_stepFrequency) ;
     }
  else 
     {
        //initialise the loop with coherant values
        if (fromOriginal)
           {
              setCycleFrequency ( (*i)->getOriginalFrequency() ) ;
           }
        else
           {
              setCycleFrequency ( (*i)->getFrequency() ) ; 
           }
        _stepFrequency = 1 ;
     }
  
  while ( i != objectDescriptorList.end() )
    {
       if (fromOriginal)
          {
             freq = (*i)->getOriginalFrequency() ;

             if ( freq != (*i)->getFrequency() ) //the objects frequency has changed previously,
                {
                   //reset it:
                   (*i)->setFrequency ( freq ) ;
                   
                   //send MaskChangeObjectFrequency to the object
                   PsnReferenceObjectHandle * referenceObjectHandle = _referenceObjectsMap.getObjectOfIndex ((*i)->getName() ) ;
                   if ( referenceObjectHandle != NULL )
                      {
                         //use receive event is sub optimal, because MaskChangeObjectFrequency is a system event, thus implying a copy is sent back to the controller, whithout effect
                         referenceObjectHandle->receiveEvent ( new PsValuedEvent<PsFrequency> (PsSystemEventIdentifier::MaskChangeObjectFrequency,
                                                                                               _date,
                                                                                               getName(),
                                                                                               (*i)->getName(),
                                                                                               (*i)->getFrequency() ) );
                      }            
                }
          }
       else
          {
             freq = (*i)->getFrequency() ; 
          }


      if (freq != 0) 
         {
            setCycleFrequency ( gcd( freq, getCycleFrequency() ) ) ;
            _stepFrequency=(int)((freq*_stepFrequency)/gcd(freq,_stepFrequency));  //lcm(freq,_stepFrequency);
         }

      ++ i ;
    }

  assert ( _stepFrequency != 0 ) ;
  
  if ( _stepFrequency != _simulationTree.getFrequency() )
     {//the controller has changed frequency
        
        _simulationTree.setFrequency( _stepFrequency ) ;

        fireSignal(PsSystemEventIdentifier::MaskControllerFrequencyChange) ;
     }
  
  _stepPeriod = int(1000./_stepFrequency);

  _nbStepsByCycle = _stepFrequency/getCycleFrequency() ;

  if ( _scheduler != NULL ) delete _scheduler ;
  
  _scheduler = createScheduler() ;
  
}



PsnScheduler * PsController::createScheduler () {

   return new PsnFrameScheduler ( _nbStepsByCycle ) ;

}



void PsController::scheduleControlledObjects() 
{
   PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab;

   //for all controlled objects
   for (pTab=_referenceObjectsMap.begin(); pTab!= _referenceObjectsMap.end(); pTab++)
      {
         if ((*pTab).second != getObjectHandle() ) //a controller shouldn't schedule itself. 
            {
               //schedule object correctly on the each frame of a cycle
               scheduleObject((*pTab).second);
            } 
      } 
}



void PsController::scheduleObject(PsnReferenceObjectHandle* ref) {

   assert (_scheduler != NULL) ;
   
   int objectFrequency = ref->getSimulatedObject().getObjectDescriptor().getFrequency() ;

#ifndef NDEBUG
   int adaptedFrequency = computeAdequateFrequency ( objectFrequency ) ;
   assert ( (objectFrequency == adaptedFrequency) || ( objectFrequency == 0 ) ) ;
#endif

   if ( objectFrequency != 0 ) 
     {
        int nbFramesARaterPlusUn=int(_controller._stepFrequency/objectFrequency);
        
        for(int minor=0;minor<_nbStepsByCycle;minor++) 
           {
              if (minor%nbFramesARaterPlusUn==0) 
                 {  //earliest execution 
                    _scheduler->addToScheduable( ref , minor );
                 }
           }
        if ( ref->getComputingState() == PsnReferenceObjectHandle::running ) 
           {
              _scheduler->schedule ( ref ) ;
           }   
     }
}



PsFrequency PsController::computeAdequateFrequency(const PsFrequency & suggestedFrequency) {
   PsFrequency result ;
   list <PsFrequency> listOfAvailableFrequencies ;

   // construct the list of frequencies that can be scheduled without changing the frame structure
   for ( int i = 1 ; i <= _nbStepsByCycle ; ++i )
      {
         if ( _stepFrequency % i == 0 )
            {
               listOfAvailableFrequencies.push_back(_stepFrequency / i ) ;
            }
      }

   // find the closest frequency in listOfAvailableFrequencies to suggestedFrequency

   list<PsFrequency>::const_iterator frequencyIterator = listOfAvailableFrequencies.begin() ;
   while ( frequencyIterator != listOfAvailableFrequencies.end() && 
           ( suggestedFrequency <= *frequencyIterator ) )
      {
         ++frequencyIterator ;
      }
   
   if (frequencyIterator == listOfAvailableFrequencies.end() )
      { //the suggested frequency is < _cycleFrequency
         result = getCycleFrequency() ; //cannot schedule object slower than _cycleFrequency
      }
   else 
      { 
         if ( frequencyIterator == listOfAvailableFrequencies.begin() )
            { // *(listOfAvailableFrequencies.begin()) == _stepFrequency < suggestedFrequency
               result = _stepFrequency ; //cannot scheduleObject faster the _stepFrequency
            }
         else 
            { // *(frequencyIterator) < suggestedFrequency <= *(frequencyIterator--)
               PsFrequency lowerEstimate = *frequencyIterator ;
               -- frequencyIterator ;
               PsFrequency higherEstimate = *frequencyIterator ;

               // lowerEstimate < suggestedFrequency <= higherEstimate
               if ( (suggestedFrequency - lowerEstimate) < (higherEstimate - suggestedFrequency) )
                  {
                     result = lowerEstimate ;
                  }
               else
                  {
                     result = higherEstimate ;
                  }
            }
      }
   return result ;
}



void PsController::init() 
{

   PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab;
   
   computeScheduling(true) ;

#ifdef _USESSTREAM
   ostringstream warningMessage ;
   warningMessage << "PsController::init : controler's cycle frequency : " << getCycleFrequency() <<" Hz"<< endl ;
   warningMessage << "PsController::init : controler's step frequency : " << _stepFrequency <<" Hz"<< endl ;
   warning ( warningMessage.str() , AllWarnings ) ;
#else   
   ostrstream warningMessage ;
   warningMessage << "PsController::init : controler's cycle frequency : " << getCycleFrequency() <<" Hz"<< endl ;
   warningMessage << "PsController::init : controler's step frequency : " << _stepFrequency <<" Hz"<< endl ;
   warningMessage.put('\0');
   warning ( warningMessage.str() , AllWarnings ) ;
   delete warningMessage.str() ;
#endif

   createControlledObjects ( &_simulationTree ) ;
         
   scheduleControlledObjects() ;

   _referenceObjectsMap.addObjectWithIndex (getName(), (PsnReferenceObjectHandle *)getObjectHandle());

   PsNameToPointerMap<PsInputNT>::iterator i;

   //pretend init order was sent just before initialsimulationDate
   _date = PsController::initialSimulationDate - _stepPeriod ;
   
   //all initial simulation objects are started
   for ( pTab = _referenceObjectsMap.begin();
         pTab != _referenceObjectsMap.end(); 
         pTab++ )
      {
         sendInitialEventsTo ( *(*pTab).second, _date ) ;
      }

   advanceSimulatedDate() ;

   //only if initialisation happens at a different simulation date than the first simulation step
   //reactToControlledObjectsSystemEvents(); 
}


void PsController::run()
{
   PsnReferenceObjectHandle * objectHandle = dynamic_cast<PsnReferenceObjectHandle *> ( _objectHandle ) ;
   assert ( objectHandle != NULL ) ;
   *_computeStatePointer = PsnReferenceObjectHandle::running ;
   while(*_computeStatePointer == PsnReferenceObjectHandle::running) 
      {
         runControllersStep (objectHandle) ;
      }//while
}


void PsController::runControllersStep(PsnReferenceObjectHandle * objectHandle)
{
#ifdef _DEBUGEXEC
   cerr<<"PsController::runControllersStep"<<endl;
#endif
   assert ( objectHandle != NULL );
   _forcedCompute = true ;

   //the controller has to process system events adressed to itself
   objectHandle->processEvents() ;

   //the controller has schedule itself
   if( (*_computeStatePointer == PsnReferenceObjectHandle::running) ||
       _forcedCompute ) 
      {
         objectHandle->compute();
      }
   _forcedCompute = false ;
}

void PsController::compute ()
{
   computeNextSimulationStep();
   purgeMemoryFromOldEvents ( getPurgeDate() ) ;
   advanceSimulatedDate();
}



PsDate PsController::getPurgeDate()
{
   return _date - _stepPeriod ;
}


void PsController::purgeMemoryFromOldEvents ( const PsDate & dateOfOldestKept )
{
   // purge old events with no known receiver
   map<PsName, list <PsEvent *> >::iterator pendingEventsMapIterator = _pendingEventsList.begin() ;
   while ( pendingEventsMapIterator != _pendingEventsList.end() )
      {
        list<PsEvent *>::iterator eventListIterator = pendingEventsMapIterator->second.begin() ;
        while ( eventListIterator != pendingEventsMapIterator->second.end() )
           {
              if ( (*eventListIterator)->date < dateOfOldestKept )
                 {
                    delete *eventListIterator ;
                    eventListIterator = pendingEventsMapIterator->second.erase ( eventListIterator ) ;
                 }
              else 
                 {
                    ++ eventListIterator ;
                 }
           }
         if ( pendingEventsMapIterator->second.empty() )
            {
               _pendingEventsList.erase ( pendingEventsMapIterator++ ) ;
            }
         else
            {
               pendingEventsMapIterator++ ;
            }
      }


   //purge deleted objects, objects handles and object descriptors
   bool disposableElements = !_deletedObjectHandles.empty() ;
   pair <PsDate, PsnObjectHandle *> examinedObjectHandle ;
   while ( disposableElements )
      {
         examinedObjectHandle = _deletedObjectHandles.front() ;
         if ( examinedObjectHandle.first < dateOfOldestKept )
            {
#ifdef _DEBUGEXEC
               cerr<<"PsDistributedController::eventsProcessed: deleting "<<examinedObjectHandle.second->getSimulatedObject().getName()<<endl;
#endif
               deleteObjectHandle ( examinedObjectHandle.second ) ;
               _deletedObjectHandles.pop_front() ;
               disposableElements = !_deletedObjectHandles.empty() ;
            }
         else 
            {
               disposableElements = false ;
            }
      }
}

void PsController::advanceSimulatedDate() 
{
   
   _numberOfSimulatedSteps++;  
      
   _date = _date + _stepPeriod;  

   if (_showDateAndStepNumber) 
      {
         cout<< "Controller starting simulation step number : "<< _numberOfSimulatedSteps
             << " with date being "<<_date<<endl;
      }
}

void PsController::computeNextSimulationStep () 
{
#ifdef _DEBUGEXEC
   cerr<<"PsController::computeNextSimulationStep"<<endl;
   cerr<<"calling reactToControlledObjectsSystemEvents ";
#endif
   reactToControlledObjectsSystemEvents () ;
#ifdef _DEBUGEXEC
   cerr<<"done "<<endl;
#endif
   _scheduler->runStep( (_numberOfSimulatedSteps - 1) % _nbStepsByCycle ) ;

   processEventsOfSuspendedObjects () ;

#ifdef _VERIFCOHERANCE
   //fast coded trace generator for the default controller
   PsString nomFich("/tmp/simul.") ;
   nomFich<<date;
   ofstream fichier(nomFich.getCString());
   assert ( fichier.good() ) ;
   processEventsOfSuspendedObjects () ;
   PsList<PsName> * maListe = listDescendantsOfType( TYPEINFO(PsSimulatedObject) );
   PsList<PsName>::iterator i = maListe->begin();
   for(;i!=maListe->end(); ++i) {
      try {
         fichier<<getPointerToSimulatedObjectNamed(*i)->getName()<<" "<<*getPointerToSimulatedObjectNamed(*i)<<";"<<endl;
      }
      catch (PsException e) {
         fichier<<";"<<endl;
      }
   }
   fichier<<"_____________"<<endl;
   fichier.close() ;
   delete maListe ;   
#endif
#ifdef _DEBUGEXEC
   cerr<<"PsController::computeNextSimulationStep done"<<endl;
#endif
}


void 
PsController::createObject(const PsObjectDescriptor & newObjectDescription, const PsName & fathersName )
{
  PsValuedEvent<PsPair<PsObjectDescriptor,PsName> > creationEvent(PsSystemEventIdentifier::MaskNewObject,
                                                                  getSimulatedDate(),
                                                                  getName(),
                                                                  getName(),
                                                                  PsPair<PsObjectDescriptor,PsName>(newObjectDescription,
                                                                                                    fathersName) );
  sendEvent (creationEvent) ;
}


void
PsController::destroyObject(const PsName & name, bool recursively )  // name of the object to destroy
{
   PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed ( name ) ;
   
   if( objectDescriptor != NULL )
      {
         if ( recursively ) 
            {
               for ( PsObjectDescriptor::SonsContainerType::iterator i = objectDescriptor->getSons().begin() ;
                     i !=  objectDescriptor->getSons().end() ;
                     ++i )
                  {
                     assert ( (*i) != NULL ) ;
                     destroyObject ( (*i)->getName() ,true ) ;
                  }
            }
         sendEvent(name, PsSystemEventIdentifier::MaskStop);
         sendEvent(name, PsSystemEventIdentifier::MaskDelete);
      }
   else 
      {
#ifdef _USESSTREAM
         ostringstream warningMessage ;
         warningMessage<<"PsController::destroyObject "<<name<<" not found"<<endl;
         PsName::getNameServer()->printToStream(warningMessage,"\n") ;
         warning (warningMessage.str(), SomeWarnings) ;
#else
         ostrstream warningMessage ;
         warningMessage<<"PsController::destroyObject "<<name<<" not found"<<endl;
         PsName::getNameServer()->printToStream(warningMessage,"\n") ;
         warningMessage.put ('\0') ;
         warning (warningMessage.str(), SomeWarnings) ;
         delete warningMessage.str() ;
#endif
      }
}



void PsController::changeObjectsFather (PsObjectDescriptor * object, PsObjectDescriptor * newFather)
{
   assert ( object != NULL ) ;
   assert ( newFather != NULL ) ;
   object->setFathersDescription( newFather ) ;
}



void PsController::changeObjectsFather (const PsName & name, const PsName & newFather)
{
   PsObjectDescriptor * object = _simulationTree.findDescendantNamed ( name ) ;
   if ( object != NULL )
      {
         PsObjectDescriptor * father = _simulationTree.findDescendantNamed ( newFather ) ;
         if (father != NULL) 
            {
               object->setFathersDescription( father ) ;
            }
         else
            {
#ifdef _USESSTREAM
               ostringstream warningMessage ; 
               warningMessage<<"PsController::changeObjectsFather new father ("<<newFather
                             <<") for object "<<name<<"doesn't exist"<<endl;
               warning (warningMessage.str(), SomeWarnings) ;
#else
               ostrstream warningMessage ; 
               warningMessage<<"PsController::changeObjectsFather new father ("<<newFather
                             <<") for object "<<name<<"doesn't exist"<<endl;
               warningMessage.put('\0') ;
               warning (warningMessage.str(), SomeWarnings) ;
               delete warningMessage.str() ;
#endif
            }
      }
   else
      {
#ifdef _USESSTREAM
         ostringstream warningMessage ; 
         warningMessage<<"PsController::changeObjectsFather object "<<name<<"doesn't exist"<<endl;
         warning (warningMessage.str(), SomeWarnings) ;
#else
         ostrstream warningMessage ; 
         warningMessage<<"PsController::changeObjectsFather object "<<name<<"doesn't exist"<<endl;
         warningMessage.put ('\0') ;
         warning (warningMessage.str(), SomeWarnings) ;
         delete warningMessage.str() ;
#endif
      }
}



bool PsController::addToPendingRegistrations(const PsEventIdentifier & sig, 
                                             const PsName & producer,
                                             const PsEventIdentifier & eventId,
                                             const PsName & registrant)
{
   _mutexPendingDataStructures.protect() ;
   map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ;
   if ( i == _pendingRegistrationRequests.end() )
      {
         i = _pendingRegistrationRequests.insert ( pair <PsName,PsnSignalDispatcher *> (producer,
                                                                                       new PsnSignalDispatcher(*this) ) ).first ;
      }

   i->second->registerForSignal( sig, registrant, eventId ) ;

   _mutexPendingDataStructures.unprotect() ;

   return true ;
}

bool PsController::removeFromPendingRegistrations ( const PsEventIdentifier & sig,
                                                    const PsName & producer,
                                                    const PsName & registrant)
{
   bool result ;
   _mutexPendingDataStructures.protect() ;
   map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ;
   if ( i == _pendingRegistrationRequests.end() )
      {
         result = false ;
      }
   else 
      {
         result = i->second->cancelRegistrationForSignal ( sig, registrant ) ;
      }

   _mutexPendingDataStructures.unprotect() ;

   return result ;
}



void PsController::addToPendingEvents (PsEvent * event) 
{
   if (event != NULL)
      {
#ifdef _USESSTREAM
         ostringstream warningMessage ;
         warningMessage<<"PsController::addToPendingEvents : Adding "<<*event<<" to pending events"
                       <<" of yet unexisting object: "<<event->receiver<<endl;
         warning ( warningMessage.str() , AllWarnings ) ;
#else
         ostrstream warningMessage ;
         warningMessage<<"PsController::addToPendingEvents : Adding "<<*event<<" to pending events"
                       <<" of yet unexisting object: "<<event->receiver<<endl;
         warningMessage.put('\0') ;
         warning ( warningMessage.str() , AllWarnings ) ;
         delete warningMessage.str() ;
#endif
         _mutexPendingDataStructures.protect() ;
         map<PsName, list <PsEvent *> >::iterator pendingEventsMapIterator = _pendingEventsList.find( event->receiver ) ;
         if ( pendingEventsMapIterator != _pendingEventsList.end() )
            {
               pendingEventsMapIterator->second.push_back(event) ;
            }
         else
            {
               _pendingEventsList.insert (pair<PsName, list<PsEvent *> > (event->receiver, list<PsEvent *>(1,event) ) ) ;
            }
         _mutexPendingDataStructures.unprotect() ;
      }
}


void PsController::sendInitialEventsTo ( PsnReferenceObjectHandle & objectHandle, const PsDate & dateOfMaskStart )
{ 
   if (&objectHandle.getSimulatedObject() != this )
      {
#ifdef _DEBUGEXEC
        cerr<<"Sending init event to "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl; 
#endif
        PsEvent * startEvent = new PsEvent(PsSystemEventIdentifier::MaskStart, 
                                           dateOfMaskStart,
                                           getName(),
                                           objectHandle.getSimulatedObject().getObjectDescriptor().getName() ) ;
         sendEvent ( startEvent ) ;

         //objects whose frequency is 0 must be suspended
         if( objectHandle.getSimulatedObject().getObjectDescriptor().getFrequency() == 0 ) 
            {
               sendEvent(&objectHandle.getSimulatedObject(),PsSystemEventIdentifier::MaskSuspend);
            }
         
         //send any pending events 

         /* no mutex protection needed, because this is only called during controller's system event processing */

         map<PsName, list <PsEvent *> >::iterator pendingEvents = _pendingEventsList.find(objectHandle.getSimulatedObject().getObjectDescriptor().getName() ) ;
         if ( pendingEvents != _pendingEventsList.end() )
            {
#ifdef _DEBUGEXEC
               cerr<<"Found pending events for "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl;
#endif
               for ( list <PsEvent *>::iterator pendingEventsListIterator = pendingEvents->second.begin() ;
                     pendingEventsListIterator != pendingEvents->second.end() ;
                     ++pendingEventsListIterator)
                  {
#ifdef _DEBUGEXEC
                     cerr<<"sent "<<**pendingEventsListIterator<< "to "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl;
#endif
                     objectHandle.getSimulatedObject().sendEvent(*pendingEventsListIterator) ; 
                  }
               _pendingEventsList.erase ( pendingEvents ) ;
            }
      }
   
}



PsnObjectHandle *
PsController::removeObjectFromDataStructures(const PsName & nom) {
    PsnReferenceObjectHandle * referentiel = NULL ;

    referentiel = _referenceObjectsMap.getObjectOfIndex(nom);
    //Purge all data structures related to event management
    for(int i=0;i<2;i++) 
       {
          _objectsNeedingActivationList[i]->remove( referentiel );
       }

    _listOfObjectsWithPostPonedEvents.remove ( referentiel ) ;

    _referenceObjectsMap.erase(nom);

    _scheduler->unschedule( referentiel ) ;

    _scheduler->removeFromScheduable( referentiel ) ;
    
    return referentiel;
}


void PsController::deleteObjectHandle ( PsnObjectHandle * objectHandle )
{
   
   PsObjectDescriptor * objectDescriptor  = const_cast<PsObjectDescriptor *>(& objectHandle->getSimulatedObject().getObjectDescriptor() ) ;

   delete objectHandle ;

   //The object description is referenced by the simulation tree and the simulated object
   //delete the object description only if it isn't referenced by its simulated object 
   if ( objectDescriptor->_pointerToSimulatedObject == NULL ) 
      {
#ifdef _DEBUGEXEC
         cerr<<"PsController::deleteObject: deleting object descriptor of object "<<objectDescriptor->getName()<<endl;
#endif
         delete objectDescriptor;
      }
}

void 
PsController::deleteObject( PsObjectDescriptor * objectDescriptor )
{
#ifdef _DEBUGEXEC
   cerr <<"PsController::deleteObject "<<objectDescriptor->getName()<<endl;
#endif

   if (objectDescriptor != &getObjectDescriptor() )
      //shouldn't delete oneself !
      {   
         assert ( objectDescriptor != NULL) ;
         
         // remove from the kernel's data structures
         PsnObjectHandle * toDelete = removeObjectFromDataStructures( objectDescriptor->getName() ) ;
         
         //remove the object descriptor from the simulation tree
         if ( objectDescriptor->getFathersObjectDescriptor() != objectDescriptor )
            {
               objectDescriptor->getFathersObjectDescriptor()->removeSon ( objectDescriptor ) ;
            }

         if ( toDelete != NULL )
            {
               //put the object handle in the list of object to be deleted
               _deletedObjectHandles.push_back ( make_pair ( _date, toDelete) ) ;
            }
      }
}

//******************************************************

PsSimulatedObject * PsController::createDescribedObject(const PsObjectDescriptor * description ) 
{
   PsSimulatedObject * obj = description->createDescribedObject() ;

   return obj;
}


//--------------------------------------------------------
void PsController::processNewObjectDeclaration ( PsObjectDescriptor & declaration, const PsDate & declarationDate )
{
   PsnReferenceObjectHandle * objectHandle = createReferenceObject (  & declaration ) ;
   assert ( objectHandle != NULL ) ;
   if ( declaration.getFrequency() != computeAdequateFrequency ( declaration.getFrequency() ) )
      {
         //the whole scheduling data structure needs recalculating
         computeScheduling ( false ) ;
         
         //the new object will therefore be scheduled with all the others
         scheduleControlledObjects() ;
      }
   else
      {
         scheduleObject ( objectHandle ) ;
      }
   sendInitialEventsTo ( *objectHandle, declarationDate ) ;
}


PsnReferenceObjectHandle *
PsController::createReferenceObject (const PsObjectDescriptor * objectDescription)
     
{
   assert (objectDescription != NULL );
#ifdef _DEBUGOBJECTCREATION
   cerr<<"PsController::createReferenceObject "<<endl;
#endif
   PsnReferenceObjectHandle * result = NULL ;

   PsSimulatedObject * createdObject = createDescribedObject ( objectDescription ) ;

   if (createdObject != NULL) 
      {
         result = createReferenceObjectHandle (*createdObject);
         
         _referenceObjectsMap.addObjectWithIndex (objectDescription->getName(), result);
         
      }
   else
      {
         cerr<<"PsController::createReferenceObject unable to create"<<*objectDescription<<endl;
      }
#ifdef _DEBUGOBJECTCREATION
         cerr<<"PsController::createReferenceObject ended"<<endl;
#endif
   return result;
}

PsDuplicatedObject *
PsController::getPointerToDuplicatedObjectNamed (const PsName & nom) 
{
   PsString messErreur="PsController::getPointerToDuplicatedObjectNamed ";
   PsSimulatedObject * resultatPossible;
   PsDuplicatedObject * resul;  
   //Soit l'objet est déjà un référentiel, soit il faut en faire un référentiel
   resultatPossible=getPointerToSimulatedObjectNamed(nom);
   if (resultatPossible==NULL) {
      PsnReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex(nom);
      if (refe==NULL) {
         messErreur=messErreur+"\n Pas d'objet "+nom+" dans le processus";
         PsController::error(messErreur.getCString());
      }   
   }
   else {
      resul=dynamic_cast<PsDuplicatedObject *>(resultatPossible);
      if (resul==NULL) {
         messErreur=messErreur+": Impossible d'obtenir un pointeur sur l'objet : ";
         messErreur=messErreur+nom+": Ce n'est pas un objet duplicable";
         PsController::error(messErreur.getCString());
      }
   }
   return resul;
}

PsSimulatedObject *
PsController::getPointerToSimulatedObjectNamed (const PsName & nom) 
{
   PsSimulatedObject * resul;  
   //Soit l'objet est déjà un référentiel, soit il faut en faire un référentiel
   PsnReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex(nom);
   if (refe==NULL) {
      if ( nom == getName() ) {
         resul = this ;
      }
      else 
         {
            resul = NULL;
         }
   }
   else {
      resul=&refe->getSimulatedObject();  
   }
  return resul;
}

const PsObjectDescriptor & PsController::getObjectDescriptorOfObject(const PsName & objectName) 
{
   if (_simulationTree.findDescendantNamed(objectName) != NULL )
      {
         return *(_simulationTree.findDescendantNamed(objectName));
      }
   else 
      {
         //the object might have just been deleted : look for it in _deletedObjectHandles
         list <pair <PsDate, PsnObjectHandle *> >::iterator i = _deletedObjectHandles.begin() ;
         while ( i != _deletedObjectHandles.end() )
            {
               if (i->second->getSimulatedObject().getName() == objectName )
                  {
                     return i->second->getSimulatedObject().getObjectDescriptor() ;
                  }
               ++i ;
            }
         PsUserException e("UnknownObject :") ; 
         e<<objectName ;
         throw e ;
      }
}
   


//**********************************************
// aspects frequentiels
const PsDate & 
PsController::getSimulatedDate () const 
{
    return _date;
}

void PsController::setCycleFrequency(int newFreq) 
{
   _cycleFrequency = newFreq ;
   _cyclePeriod = 1000/newFreq ; 
}

int PsController::getCycleFrequency() const 
{
   return _cycleFrequency ;
}


int PsController::getCyclePeriod() const 
{
   return _cyclePeriod ;
}



int PsController::lcm (const int a, const int b) {
   return (a * b / gcd (a, b)) ;
}
 
int PsController::gcd (const int a, const int b) {
  int res = a ;
  if (b != 0) {
     res = gcd (b, a % b) ;
  }
  return res ;
}


//- affichage du pas -------------------------------------
//
void PsController::showDateAndStepNumber(bool show)
{
  _showDateAndStepNumber = show;
}


void PsController::error (const char * Errormess) 
{
   throw PsUserException(Errormess) ;
}

void PsController::warning ( const string & warningMessage, WarningLevels minWarningLevel )
{
   assert ( minWarningLevel != NoWarnings ) ;
   if ( warningLevel >= minWarningLevel )
      {
         cerr<<warningMessage<<endl ;
      }
   if ( warningLevel == ExceptionOnWarnings )
      {
         throw warningMessage ;
      }
   if ( warningLevel == FatalWarnings )
      {
         exit ( -1 ) ;
      }
}


void PsController::switchSystemEventList() {
   _currentWritableSystemEventsList = 1 - _currentWritableSystemEventsList ;
}

void PsController::actOnSystemEvent ( PsEvent * event ) 
{
   //do not send a copy of a system event to oneself (avoids redundancy), except if the controller is being controlled
   if (event->receiver != getName() )
      {
         _mutexSystemEventsList.protect() ;
         PsEvent::insertInList ( _systemEventsList[ _currentWritableSystemEventsList ],
                                 event->clone() );
         _mutexSystemEventsList.unprotect() ;
      }
   else if (this != & getController() )
      {
         //the controller is being controlled : send a copy of the event to the controllers controller
         getController().actOnSystemEvent ( event ) ;
      }
}
 
bool PsController::processEvent (PsEvent * event ) 
{
   const PsEventIdentifier & eventId ( event->eventId ) ;
   if (eventId == PsSystemEventIdentifier::MaskRestart) 
      {
         if (*_computeStatePointer == PsnReferenceObjectHandle::stopped)
            {
               *_computeStatePointer = PsnReferenceObjectHandle::initial ;
               //implementation very difficult, because the original simulation tree has been modified
               init() ;
               assert (false) ; 
            }
         else
            {
               warning(" PsController::processEvent should be stopped before restarted", AllWarnings);
            }
      }
   else if ( eventId == PsSystemEventIdentifier::MaskResume ) 
      {
         *_computeStatePointer = PsnReferenceObjectHandle::running;
      } 
   else if ( eventId == PsSystemEventIdentifier::MaskSuspend ) 
      {
         if (*_computeStatePointer != PsnReferenceObjectHandle::suspended )
            {
               // moving in suspended mode
               // stop computations, even forced
               _forcedCompute = false ;
               *_computeStatePointer = PsnReferenceObjectHandle::suspended ;
            }
      } 
   else if ( eventId == PsSystemEventIdentifier::MaskStop ) 
      {
         if (*_computeStatePointer != PsnReferenceObjectHandle::stopped )
            {
               *_computeStatePointer=PsnReferenceObjectHandle::stopped ;
               
               finish() ;
            }
         
      } 
   else if ( eventId == PsSystemEventIdentifier::MaskStart ) 
      {
      
         *_computeStatePointer=PsnReferenceObjectHandle::running;
         //this produces incorrect behaviour from the point of view of an object controlling the controller
         //if(_date==PsController::initialSimulationDate) advanceSimulatedDate();
         
      } 
   else if (eventId == PsSystemEventIdentifier::MaskDelete ) 
      {
         *_computeStatePointer=PsnReferenceObjectHandle::destroyed;
      } 
   else if ( eventId == PsSystemEventIdentifier::MaskNewObject ) 
      {
         PsValuedEvent <PsPair <PsObjectDescriptor,PsName> > * creationEvent = dynamic_cast<PsValuedEvent <PsPair <PsObjectDescriptor,PsName> >* > ( event ) ;
         
         assert (creationEvent != NULL ) ;
         
         // add the described object in the simulation tree : this is a declaration
         PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed( creationEvent->value.first.getName() );
         if ( objectDescriptor == NULL )
            {
               PsObjectDescriptor * newObjectDescriptor = new PsObjectDescriptor(creationEvent->value.first) ;
               PsObjectDescriptor * fathersDescription = _simulationTree.findDescendantNamed ( creationEvent->value.second ) ;
               if (fathersDescription == NULL)
                  {
                     fathersDescription = & _simulationTree ;
#ifdef _USESSTREAM
                     ostringstream warningMessage ;
                     warningMessage<<"Attached new object named "<<newObjectDescriptor->getName()<<" to "<<getName()
                                   <<" because object "<<creationEvent->value.second<<"is unknown"<<endl;
                     warning ( warningMessage.str() , SomeWarnings ) ;
#else
                     ostrstream warningMessage ;
                     warningMessage<<"Attached new object named "<<newObjectDescriptor->getName()<<" to "<<getName()
                                   <<" because object "<<creationEvent->value.second<<"is unknown"<<endl;
                     warningMessage.put ('\0') ;
                     warning ( warningMessage.str() , SomeWarnings ) ;
                     delete warningMessage.str() ;
#endif
                  }
               changeObjectsFather (newObjectDescriptor, fathersDescription) ;

               //create the described object
               processNewObjectDeclaration ( *newObjectDescriptor, event->date ) ;
               
               // notify other objects that an object has been created
               fireValuedSignal(PsSystemEventIdentifier::MaskObjectCreated,creationEvent->value.first.getName() ) ;
            }
         else
            {
#ifdef _USESSTREAM
               ostringstream warningMessage ;
               warningMessage<<"WARNING: an object of name "<<creationEvent->value.first.getName()<<" already exists"<<endl;
               warning ( warningMessage.str() , SomeWarnings ) ;
#else
               ostrstream warningMessage ;
               warningMessage<<"WARNING: an object of name "<<creationEvent->value.first.getName()<<" already exists"<<endl;
               warningMessage.put ('\0') ;
               warning ( warningMessage.str() , SomeWarnings ) ;
               delete warningMessage.str() ;
#endif
            }
      }
   else if ( eventId == PsSystemEventIdentifier::MaskRecomputeScheduling)
      {
         computeScheduling( true ) ;

         scheduleControlledObjects() ;
      }
   else 
      {
#ifdef _USESSTREAM
         ostringstream warningMessage ;
         warningMessage<<"WARNING:PsController::traiterEvt événement système non géré"<<endl;
         warning ( warningMessage.str() , SomeWarnings ) ;
#else
         ostrstream warningMessage ;
         warningMessage<<"WARNING:PsController::traiterEvt événement système non géré"<<endl;
         warningMessage.put('\0') ;
         warning ( warningMessage.str() , SomeWarnings ) ;
         delete warningMessage.str() ;
#endif
      } 
   return true ;
}



void PsController::processStartEventOf(PsnReferenceObjectHandle * objectHandle) 
{

   if(objectHandle->getComputingState() == PsnReferenceObjectHandle::initial) 
      {
         setComputingState (objectHandle, PsnReferenceObjectHandle::running ) ;
         noActivationNeededFor ( objectHandle );
#ifdef _DEBUGEVT
         cerr<<"PsController:: Init of "<<objectHandle->getSimulatedObject().getName()<<endl;
#endif
         objectHandle->init() ;
#ifdef _DEBUGEVT
         cerr<<"PsController:: end of init of "<<objectHandle->getSimulatedObject().getName()<<endl;
#endif
         
         _scheduler->schedule( objectHandle );

   }
}



void PsController::processDeleteEventOf(PsnReferenceObjectHandle * objectHandle) 
{
#ifdef _DEBUGEXEC
   cerr<<" PsController::processDeleteEventOf() "<<objectHandle->getSimulatedObject().getName()<<endl;
#endif
   if(objectHandle->getComputingState() == PsnReferenceObjectHandle::stopped) 
      {
         fireValuedSignal( PsSystemEventIdentifier::MaskObjectDestroyed, objectHandle->getSimulatedObject().getObjectDescriptor().getName() ) ;
         setComputingState ( objectHandle, PsnReferenceObjectHandle::destroyed );
         deleteObject(const_cast<PsObjectDescriptor *>(&objectHandle->getSimulatedObject().getObjectDescriptor()) );
      }         
}


void PsController::reactToControlledObjectsSystemEvents() {

   PsSimulatedObject * receiverObject ;
   PsnReferenceObjectHandle * receiverReferential ;
   PsEvent * currentEvent ;

   switchSystemEventList() ;
   list< PsEvent * > & myEventList = *_systemEventsList [ 1 - _currentWritableSystemEventsList ] ;
   list< PsEvent * >::iterator i = myEventList.begin() ;
   list< PsEvent * >::iterator toErase ;
   while ( i != myEventList.end() ) {

      receiverObject = getPointerToSimulatedObjectNamed( (*i)->receiver ) ;
      currentEvent = (*i) ;

      if ( receiverObject == NULL ) 
         {
#ifdef _USESSTREAM
            ostringstream warningMessage ;
            warningMessage<<"WARNING : object "
                          << currentEvent ->receiver.getCString() 
                          <<", who has received event "
                          << *currentEvent 
                          <<"  doesn't exist (anymore)"<<endl;
            warning ( warningMessage.str() , AllWarnings ) ;
#else
            ostrstream warningMessage ;
            warningMessage<<"WARNING : object "
                          << currentEvent ->receiver.getCString() 
                          <<", who has received event "
                          << *currentEvent 
                          <<"  doesn't exist (anymore)"<<endl;
            warningMessage.put('\0') ;
            warning ( warningMessage.str() , AllWarnings ) ;
            delete warningMessage.str() ;
#endif
         }
      else {
         receiverReferential = dynamic_cast<PsnReferenceObjectHandle *>(receiverObject->getObjectHandle() );
         assert (receiverReferential != NULL) ;
#if defined (_DEBUGEXEC) || defined (_DEBUGEVT) 
         cerr<<*currentEvent<<" received by "<<receiverObject->getName() <<endl;
#endif
         if ( currentEvent->eventId == PsSystemEventIdentifier::MaskStart ) 
            {
               processStartEventOf ( receiverReferential );
            }

         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskStop ) {
#ifdef _DEBUGEVT
            cout<< currentEvent->receiver <<" will be stopped "<<endl;
#endif
          if((receiverReferential->getComputingState() == PsnReferenceObjectHandle::running)||
             (receiverReferential->getComputingState() == PsnReferenceObjectHandle::suspended)) 
             {
                setComputingState (receiverReferential, PsnReferenceObjectHandle::stopped );
                receiverReferential->processEvents () ;
                receiverObject -> finish() ;
                _scheduler->unschedule( receiverReferential ); 
             } 
         }
         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskSuspend ) {
#ifdef _DEBUGEVT
          cout<<currentEvent->receiver <<" will be suspended "<<endl;
#endif
          if(receiverReferential->getComputingState() == PsnReferenceObjectHandle::running) 
             {
             setComputingState (receiverReferential, PsnReferenceObjectHandle::suspended ) ;
             hasEventsToProcess (receiverReferential) ; // à la fin du pas de temps l'événement MaskSuspend sera traité, ainsi que d'autres événements éventuels
             _scheduler->unschedule ( receiverReferential ); 
             }      
          else
             {
                assert ( false ) ;
             }
         }
         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskResume ) 
            {
#ifdef _DEBUGEVT
               cout<<currentEvent->receiver <<" will resume execution"<<endl;
#endif
               if ( receiverReferential -> getComputingState() == PsnReferenceObjectHandle::suspended ) 
                  {
                     setComputingState (receiverReferential, PsnReferenceObjectHandle::running );
                     // inutile de traiter l'événement : les compute à venir le feront
                     noActivationNeededFor ( receiverReferential );
                     
                     _scheduler->schedule( (PsnReferenceObjectHandle *)receiverObject -> getObjectHandle() );
                  }
         }
         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskDelete ) 
            {
               processDeleteEventOf ( receiverReferential ) ;
            }
         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskRestart ) {
#ifdef _DEBUGEVT
          cout<<currentEvent->receiver <<" will be restarted"<<endl;
#endif
          if (receiverReferential->getComputingState() == PsnReferenceObjectHandle::stopped) 
             {
                setComputingState(receiverReferential, PsnReferenceObjectHandle::running) ;
                // inutile de traiter l'événement : les compute à venir le feront
                noActivationNeededFor( receiverReferential );
                
                receiverObject->init();
                //on sait que c'est un référentiel 
                _scheduler->schedule( receiverReferential ) ;
             }
         }
         else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskChangeObjectFrequency ) 
            {
               PsValuedEvent<PsFrequency> * realEvent ;
               realEvent = dynamic_cast<PsValuedEvent<PsFrequency> *> (currentEvent ) ;
               assert (realEvent != NULL) ;
               PsObjectDescriptor * objectDescription = _simulationTree.findDescendantNamed (realEvent->receiver) ;
               if (objectDescription != NULL)
                  {
                     objectDescription->setFrequency ( realEvent->value ) ;
                     if ( realEvent->value == computeAdequateFrequency ( realEvent->value ) )
                        {
                           PsnReferenceObjectHandle * referenceObjectHandle = _referenceObjectsMap.getObjectOfIndex (realEvent->receiver) ;
                           if ( referenceObjectHandle != NULL )
                              {
                                 _scheduler->unschedule( referenceObjectHandle ) ;
                                 
                                 _scheduler->removeFromScheduable( referenceObjectHandle ) ;

                                 scheduleObject ( _referenceObjectsMap.getObjectOfIndex (realEvent->receiver) ) ;
                              }
                        }
                     else 
                        {
                           computeScheduling ( false ) ; //false necessary because otherwise no change would happen
                           scheduleControlledObjects () ;
                        }
                  }
               else
                  {
#ifdef _USESSTREAM
                     ostringstream warningMessage ;
                     warningMessage<<"PsController received MaskChangeObjectFrequency for "<<realEvent->receiver<<" which is unknown "<<endl;
                     warning ( warningMessage.str() , SomeWarnings ) ;
#else
                     ostrstream warningMessage ;
                     warningMessage<<"PsController received MaskChangeObjectFrequency for "<<realEvent->receiver<<" which is unknown "<<endl;
                     warningMessage.put('\0') ;
                     warning ( warningMessage.str() , SomeWarnings ) ;
                     delete warningMessage.str() ;
#endif
                  }
            }
      }
      toErase = i ;
      i++ ;
      myEventList.erase ( toErase ) ;
   }
}

void PsController::noActivationNeededFor (PsnReferenceObjectHandle * refObjet) {
   _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->remove( refObjet );
   refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = false ;
   assert ( refObjet->_isInObjectNeedingActivationList[ 1 - _currentListOfObjectsNeedingActivation ] == false );
}

void PsController::hasEventsToProcess(PsnReferenceObjectHandle * refObjet) 
{
   // the object handle should be correct (because this member function is called by it)
  assert ( dynamic_cast<PsnReferenceObjectHandle *>(_objectHandle) != NULL ) ;

  //the controller shouldn't try and schedule itself if it isn't controlled
  if (refObjet != _objectHandle)
     {
        
        if (!refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ]) 
           {
#ifdef _DEBUGEVT
              cerr<<"PsController::hasEventsToProcess of "
                  << refObjet->getSimulatedObject().getName() 
                  << " at date "<< _date + _stepPeriod << endl;
#endif
              _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->push_back ( refObjet );
              refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = true ;
           } 
#ifdef _DEBUGEVT
        else 
           {
              cerr<< "PsController::hasEventsToProcess of " << refObjet->getSimulatedObject().getName() << " at date "<< _date + _stepPeriod << " not necessary "<< endl;
           }
#endif
     }
  else if ( & getController() != this )
     {
        getController().hasEventsToProcess( refObjet ) ;
     }
}

void PsController::postponeEventProcessing ( PsnReferenceObjectHandle * refObjet ) {
   _listOfObjectsWithPostPonedEvents.push_back(refObjet) ;
}

void PsController::processEventsOfSuspendedObjects() 
{   
#ifdef _DEBUGEVT
    cerr<<"PsController::processEventsOfSuspendedObjects "<< _date << endl;
#endif
    while ( ! _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->empty() ) {
       //using a iteration to be able to process ASAP events generated throught this phase
       int indiceFile = _currentListOfObjectsNeedingActivation ;
       _currentListOfObjectsNeedingActivation = 1 - _currentListOfObjectsNeedingActivation ;
       PsnReferenceObjectHandle * courant;
       list<PsnReferenceObjectHandle *>::iterator i;
       i=_objectsNeedingActivationList[indiceFile]->begin();
       while(i!=_objectsNeedingActivationList[indiceFile]->end()) {
          list<PsnReferenceObjectHandle *>::iterator needsDelete;
          courant=(*i);
          courant->processEvents () ;
          courant->_isInObjectNeedingActivationList[indiceFile]= false ;
          needsDelete=i;
          i++; 
          _objectsNeedingActivationList[indiceFile]->erase(needsDelete);
       }
    }
    list < PsnReferenceObjectHandle * >::iterator j =  _listOfObjectsWithPostPonedEvents.begin() ;
    list < PsnReferenceObjectHandle * >::iterator toErase ;
    while ( j != _listOfObjectsWithPostPonedEvents.end() ) {
       hasEventsToProcess (*j) ;
       toErase = j ;
       j++ ;
       _listOfObjectsWithPostPonedEvents.erase( toErase ) ;
    }
#ifdef _DEBUGEVT
   cerr<<"PsController::processEventsOfSuspendedObjects fin "<< _date <<endl;
#endif
}



int PsController::getOutputHistorySize(void) {
  // each output keeps an history to enable polations
  // _nbStepsByCycle * 4 --> the minimum history lenght for the default max extrapolation to work  
  // + 1 because of uncertainty about relative order of simulated object activation

   int result ;
   char * environementValue = getenv("MaskHISTORYLENGTH");
   if (environementValue == NULL ) 
      {
         result = _nbStepsByCycle*4+1 ;
      }
   else 
      {
         result = atoi (environementValue) ;
      }
   return result ;
}  


void PsController::broadcastEventsForSignal (PsEvent & event, const PsEventIdentifier & sigId) 
{
   //cerr<<"PsController::broadcastEventsForSignal "<<sigId<<endl;
   _controledObjectsSignalsDispatcher.sendEventsForSignal( event , sigId ) ;
}


bool PsController::receiveRegistrationForSignal(const PsEventIdentifier & sig,
                                                const PsName & registrant, 
                                                const PsEventIdentifier & eventId)
{
   //cerr<<"PsController::receiveRegistrationForSignal "<<sig<<" "<<registrant<<" "<<eventId<<endl;
   return _controledObjectsSignalsDispatcher.registerForSignal(sig , registrant , eventId) ;
}


bool PsController::receiveCancellationForSignal ( const PsEventIdentifier & sigId , const PsName & registrant ) {
   return _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (sigId , registrant) ;
}




PsnReferenceObjectHandle * PsController::newPsnReferenceObjectHandle(PsSimulatedObject & object, 
                                                                     PsController & controller,
                                                                     PsnSignalDispatcher * signalDispatcher)
{
   return new PsnReferenceObjectHandle(object, controller, signalDispatcher) ;
}



PsnReferenceObjectHandle * PsController::createReferenceObjectHandle(PsSimulatedObject & obj) 
{
   /* no mutex protection needed, because this member function is only called by the controller during system event processing */
#ifdef _DEBUGOBJECTCREATION
  cerr<<"PsController::createReferenceObjectHandle"<<endl;
#endif 
   PsnReferenceObjectHandle * result ;
   map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find( obj.getName() ) ;
   if ( i == _pendingRegistrationRequests.end() )
      {
         result = newPsnReferenceObjectHandle(obj,*this, new PsnSignalDispatcher (*this) );
      }
   else 
      {
         result = newPsnReferenceObjectHandle(obj,*this, i->second) ;
         _pendingRegistrationRequests.erase ( i ) ;
      }
#ifdef _DEBUGOBJECTCREATION
  cerr<<"PsController::createReferenceObjectHandle ended"<<endl;
#endif 
   return result ;
}


void PsController::setComputingState(PsnReferenceObjectHandle * handle, 
                                     PsnReferenceObjectHandle::SimulatedObjectComputingState state) const 
{
   handle->_computingState = state ;
}


PsMultipleConfigurationParameter * PsController::getSchedulingParametersOfObject(PsObjectDescriptor & objectDescription ) 
{
   return objectDescription.getSchedulingParameters () ;
}

void PsController::setProcessOfDescriptor ( PsObjectDescriptor & objectDescription, const PsName & newProcessName ) 
{
   objectDescription.setProcess ( newProcessName ) ;
}

---