OMKController.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 <OMKController.h>
#include <OMKDoubleList.h>
#include <math.h>
#include <OMKObjectDescriptor.h>
#include <OMKSimulatedObject.h>
#include <typeinfo>
#include "OMKName.h"
#include "OMKNameServer.h"
#include "OMKScheduler.h"
#include "OMKFrameScheduler.h"
#include "OMKEvent.h"
#include "OMKSystemEventIdentifier.h"
#include "OMKUserException.h"
#include "OMKParametersAccessor.inl"


using namespace std ;
using namespace OMK ;


Date Controller::initialSimulationDate = 0 ;

KernelObjectAbstractFactory * Controller::kernelObjectFactory = NULL ;

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

KernelObjectAbstractFactory * Controller::getKernelObjectFactory ( ) 
{
  if ( kernelObjectFactory == NULL ) 
  {
    kernelObjectFactory = new KernelObjectClassicFactory () ;
  }

  return kernelObjectFactory ;
}

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

Controller::Controller( ObjectDescriptor & initialObjects,
                              const Date & initialDate )   
: SimulatedObject(*this, initialObjects ), 
  _simulationTree( initialObjects ),
  _numberOfSimulatedSteps( 0 ),
  _nbStepsByCycle( 0 ),
  _date( initialDate ),
  _showDateAndStepNumber( false ),
  _controledObjectsSignalsDispatcher( *this ),
  _forcedCompute( false ),
  _scheduler( NULL )
{
  // These flags are always traced
  OBT::Singleton<OBT::Tracer>::getInstance().registerId( OMK_DEBUG_WARNING ) ;
  OBT::Singleton<OBT::Tracer>::getInstance().registerId( OMK_DEBUG_FATAL_ERROR ) ;
  OBT::Singleton<OBT::Tracer>::getInstance().registerId( OMK_DEBUG_ERROR ) ;
  OBT::Singleton<OBT::Tracer>::getInstance().registerId( OMK_DEBUG_MESSAGE ) ;

  //--- Tracer initialisation
  // The file
  std::string traceFile ;
  if( ParametersAccessor::get( getConfigurationParameters(), "TraceFile", traceFile ) )
  {
    OBT::Singleton<OBT::Tracer>::getInstance().setFile( traceFile.c_str() ) ;
  }
  // The "trace all" flag
  bool traceAll = false ;
  if( ParametersAccessor::get( getConfigurationParameters(), "TraceAll", traceAll ) )
  {
    OBT::Singleton<OBT::Tracer>::getInstance().traceAll( traceAll ) ;
  }
  // The ids to register
  std::vector< std::string > traceIds ;
  if( ParametersAccessor::get( getConfigurationParameters(), "TraceIds", traceIds ) )
  {
    for( std::vector< std::string >::const_iterator i = traceIds.begin() ;
      i != traceIds.end() ;
      i++ )
    {
      OBT::Singleton<OBT::Tracer>::getInstance().registerId( i->c_str() ) ;
    }
  }

  if (getConfigurationParameters())
  {
    const ConfigurationParameterDescriptor* defaultPolatorParams= 
      getConfigurationParameters()->getSubDescriptorByName("defaultPolatorPrecisionLevel");
    if(defaultPolatorParams)
    {
      if(defaultPolatorParams->getAssociatedString()=="Constant")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::Constant;
      else if(defaultPolatorParams->getAssociatedString()=="Linear")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::Linear;
      else if(defaultPolatorParams->getAssociatedString()=="Quadratic")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::Quadratic;
      else if(defaultPolatorParams->getAssociatedString()=="Cubic")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::Cubic;
      else if(defaultPolatorParams->getAssociatedString()=="ConstantContinuous")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::ConstantContinuous;
      else if(defaultPolatorParams->getAssociatedString()=="LinearContinuous")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::LinearContinuous;
      else if(defaultPolatorParams->getAssociatedString()=="QuadraticContinuous")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::QuadraticContinuous;
      else if(defaultPolatorParams->getAssociatedString()=="CubicContinuous")
        OMK::Type::PolatorNT::defaultPrecisionLevel=OMK::Type::PolatorNT::CubicContinuous;
      else
        OMERROR( "This default polator is unknown: "
                 << defaultPolatorParams->getAssociatedString() ) ;
    }
  }

  initialSimulationDate = initialDate ;

  //as a controller created throught this constructor has no controller, create the illusion of being handled
  _objectHandle = createReferenceObjectHandle( *this ) ;
  _computeStatePointer = const_cast<ReferenceObjectHandle::SimulatedObjectComputingState *>(&(dynamic_cast<ReferenceObjectHandle *>(_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< Event * >() ;
  _systemEventsList[ 1 ] = new list< Event * >() ;
  _currentWritableSystemEventsList = 0 ;

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

  // initialisation of controller state
  OMASSERT( _computeStatePointer != 0 ) ;
  *_computeStatePointer = ReferenceObjectHandle::initial ;
}

void Controller::finish()
{
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::finish()" ) ;
  //call destroyObject on all the sons
  for ( ObjectDescriptor::SonsContainerType::iterator i = _simulationTree.getSons().begin() ;
    i !=  _simulationTree.getSons().end() ;
    ++i )
  {
    OMASSERT ( (*i) != NULL ) ;
    destroyObject ( (*i)->getName() ,true ) ;
  }
}


Controller::~Controller() 
{
  delete _scheduler ;

  // destruction of data structures related to event handling
  delete _systemEventsList[ 0 ] ;
  delete _systemEventsList[ 1 ] ;
  delete _objectsNeedingActivationList[ 0 ] ;
  delete _objectsNeedingActivationList[ 1 ] ;

  purgeMemoryFromOldEvents ( _date + _stepPeriod ) ;

  // destruction of pending registrations
  for( map< Name, SignalDispatcher * >::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
  }
  delete _objectHandle ;
}


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

  while ( i != subTree->getSons()->end() )
  {
    OMASSERT( *i != NULL ) ;
    OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createControlledObjects Creating \""<< (*i)->getName() << "\"" ) ;
    //create the object
    createReferenceObject ( *i ) ;

    //create the subTree of that object
    createControlledObjects ( *i ) ;

    OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createControlledObjects Created \""<< (*i)->getName() << "\"" ) ;
    ++i ;
  }
}



void Controller::computeScheduling(bool fromOriginal)
{
  OMMESSAGE( "Controller::computeScheduling at date " << _date ) ;

  std::list<ObjectDescriptor * > objectDescriptorList ;
  int freq;

  _simulationTree.getDescendants( &objectDescriptorList );

  list<ObjectDescriptor * >::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 ) 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller needs a frequency: assigning 1" ) ;
      _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
        ReferenceObjectHandle * 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 ValuedEvent<Frequency> (SystemEventIdentifier::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 ;
  }

  OMASSERT( _stepFrequency != 0 ) ;

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

    _simulationTree.setFrequency( _stepFrequency ) ;

    fireSignal(SystemEventIdentifier::MaskControllerFrequencyChange) ;
  }

  _stepPeriod = int(1000./_stepFrequency);


  _nbStepsByCycle = _stepFrequency/getCycleFrequency() ;

  if ( _scheduler != NULL ) delete _scheduler ;

  _scheduler = createScheduler() ;

}


Scheduler * Controller::createScheduler () 
{

  return new FrameScheduler ( _nbStepsByCycle ) ;

}



void Controller::scheduleControlledObjects() 
{
  NameToPointerMap<ReferenceObjectHandle>::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 Controller::scheduleObject(ReferenceObjectHandle* ref) {

  OMASSERT(_scheduler != NULL) ;

  int objectFrequency = ref->getSimulatedObject().getObjectDescriptor().getFrequency() ;

#ifndef NDEBUG
  int adaptedFrequency = computeAdequateFrequency ( objectFrequency ) ;
  OMASSERT( (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() == ReferenceObjectHandle::running ) 
    {
      _scheduler->schedule ( ref ) ;
    }   
  }
}



Frequency Controller::computeAdequateFrequency(const Frequency & suggestedFrequency) 
{
  Frequency result = 0 ;
  if ( suggestedFrequency != 0 )
  {
    list <Frequency> 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<Frequency>::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--)
        Frequency lowerEstimate = *frequencyIterator ;
        -- frequencyIterator ;
        Frequency higherEstimate = *frequencyIterator ;

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



void Controller::init() 
{

  NameToPointerMap<ReferenceObjectHandle>::iterator pTab;

  computeScheduling(true) ;

  ostringstream warningMessage ;
  OMMESSAGE( "Controller::init :"<< endl 
    << "controler's cycle frequency : " << getCycleFrequency() <<" Hz"<< endl 
    << "controler's step frequency : " << _stepFrequency <<" Hz"<< endl
    << "stepPeriod " << _stepPeriod << endl
    ) ;

  createControlledObjects ( &_simulationTree ) ;

  scheduleControlledObjects() ;

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

  NameToPointerMap<InputNT>::iterator i;

  //pretend init order was sent just before initialsimulationDate
  _date = Controller::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 Controller::run()
{
  ReferenceObjectHandle * objectHandle = dynamic_cast<ReferenceObjectHandle *> ( _objectHandle ) ;
  OMASSERT ( objectHandle != NULL ) ;
  *_computeStatePointer = ReferenceObjectHandle::running ;
  while(*_computeStatePointer == ReferenceObjectHandle::running) 
  {
    runControllersStep (objectHandle) ;
  }//while
}


void Controller::runControllersStep(ReferenceObjectHandle * objectHandle)
{
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::runControllersStep" ) ;
  OMASSERT ( objectHandle != NULL );
  _forcedCompute = true ;

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

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

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



Date Controller::getPurgeDate()
{
  return _date - _stepPeriod ;
}


void Controller::purgeMemoryFromOldEvents ( const Date & dateOfOldestKept )
{
  // purge old events with no known receiver
  map<Name, list <Event *> >::iterator pendingEventsMapIterator = _pendingEventsList.begin() ;
  while ( pendingEventsMapIterator != _pendingEventsList.end() )
  {
    list<Event *>::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 <Date, ObjectHandle *> examinedObjectHandle ;
  while ( disposableElements )
  {
    examinedObjectHandle = _deletedObjectHandles.front() ;
    if ( examinedObjectHandle.first < dateOfOldestKept )
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::purgeMemoryFromOldEvents: deleting \""
        << examinedObjectHandle.second->getSimulatedObject().getName() << "\"" ) ;
      if ( &examinedObjectHandle.second->getSimulatedObject() != this )
        deleteObjectHandle ( examinedObjectHandle.second ) ;
      _deletedObjectHandles.pop_front() ;
      disposableElements = !_deletedObjectHandles.empty() ;
    }
    else 
    {
      disposableElements = false ;
    }
  }
}

void Controller::advanceSimulatedDate() 
{

  _numberOfSimulatedSteps++;  

  _date = _date + _stepPeriod;  

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

void Controller::computeNextSimulationStep () 
{
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::computeNextSimulationStep calling reactToControlledObjectsSystemEvents " ) ;
  reactToControlledObjectsSystemEvents () ;
  OMTRACEID( OMK_DEBUG_OMK_EXEC, "done " ) ;
  _scheduler->runStep( (_numberOfSimulatedSteps - 1) % _nbStepsByCycle ) ;

  processEventsOfSuspendedObjects () ;

  OMTRACEID( OMK_DEBUG_OMK_EXEC,  "Controller::computeNextSimulationStep done" ) ;
}


void 
Controller::createObject(const ObjectDescriptor & newObjectDescription, const Name & fathersName )
{
  CreateObjectEvent creationEvent( SystemEventIdentifier::MaskNewObject,
    getSimulatedDate(),
    getName(),
    getName(),
    CreateObjectType( CreateObjectPrm( newObjectDescription, fathersName ) ) );
  sendEvent (creationEvent) ;
}

void 
Controller::createLocalObject(const ObjectDescriptor & newLObjectDescription, const Name & fathersLName )
{
  //  cout<<"je suis createObject, fathersName est :"<<fathersName<<endl;
  CreateObjectEvent creationEvent( SystemEventIdentifier::MaskNewLocalObject,
    getSimulatedDate(),
    getName(),
    getName(),
    CreateObjectType( CreateObjectPrm( newLObjectDescription, fathersLName ) ) );
  sendEvent( creationEvent ) ;


}
//----------------------------------
void Controller::migrateObjectToProcess ( Name &objectName, Name &processName ) 
{
  // sendValuedEvent( objectName, 
  //               "SystemEventIdentifier::MaskMetamorphoseMirToRef",
  //               MigrationObjectType( MigrationObjectPrm( objectName, processName ) ) ) ;

  MigrationObjectEvent migrationEvent( SystemEventIdentifier::MaskMetamorphoseMirToRef,
    getSimulatedDate(),
    getName(),
    getName(),
    MigrationObjectType( MigrationObjectPrm( objectName, processName ) ) );
  sendEvent (migrationEvent) ;


}
//----------------------------------
vector<Name> Controller::getReferentielList()
{
  _publicReferentielObjectsVector.clear () ;
  for ( NameToPointerMap<ReferenceObjectHandle>::iterator i = _referenceObjectsMap.begin(); i!= _referenceObjectsMap.end(); i++ )
  {
    _publicReferentielObjectsVector.push_back( i->first) ;
  }

  return  _publicReferentielObjectsVector;
}
void
Controller::destroyObject(const Name & name, bool recursively )  // name of the object to destroy
{
  ObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed ( name ) ;

  if( objectDescriptor != NULL )
  {
    if ( recursively ) 
    {
      for ( ObjectDescriptor::SonsContainerType::iterator i = objectDescriptor->getSons().begin() ;
        i !=  objectDescriptor->getSons().end() ;
        ++i )
      {
        OMASSERT ( (*i) != NULL ) ;
        destroyObject ( (*i)->getName() ,true ) ;
      }
    }
    sendEvent(name, SystemEventIdentifier::MaskStop);
    sendEvent(name, SystemEventIdentifier::MaskDelete);
  }
  else 
  {
    OMERROR("Controller::destroyObject \"" << name << "\" not found" ) ;
  }
}



void Controller::changeObjectsFather (ObjectDescriptor * object, ObjectDescriptor * newFather)
{
  OMASSERT ( object != NULL ) ;
  OMASSERT ( newFather != NULL ) ;
  object->setFathersDescription( newFather ) ;
}



void Controller::changeObjectsFather (const Name & name, const Name & newFather)
{
  ObjectDescriptor * object = _simulationTree.findDescendantNamed ( name ) ;
  if ( object != NULL )
  {
    ObjectDescriptor * father = _simulationTree.findDescendantNamed ( newFather ) ;
    if (father != NULL) 
    {
      object->setFathersDescription( father ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::changeObjectsFather new father (\""<<newFather
        <<"\") for object \""<<name<<"\" doesn't exist" ) ;
    }
  }
  else
  {
    OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::changeObjectsFather object \""<<name<<"\" doesn't exist" ) ;
  }
}



bool Controller::addToPendingRegistrations(const EventIdentifier & sig, 
                                              const Name & producer,
                                              const EventIdentifier & eventId,
                                              const Name & registrant)
{
#ifdef _OMK_MUTEX_
  _mutexPendingDataStructures.protect() ;
#endif
  map<Name, SignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ;
  if ( i == _pendingRegistrationRequests.end() )
  {
    i = _pendingRegistrationRequests.insert ( pair <Name,SignalDispatcher *> (producer,
      new SignalDispatcher(*this) ) ).first ;
  }

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

#ifdef _OMK_MUTEX_
  _mutexPendingDataStructures.unprotect() ;
#endif

  return true ;
}

bool Controller::removeFromPendingRegistrations ( const EventIdentifier & sig,
                                                    const Name & producer,
                                                    const Name & registrant)
{
  bool result ;
#ifdef _OMK_MUTEX_
  _mutexPendingDataStructures.protect() ;
#endif
  map<Name, SignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ;
  if ( i == _pendingRegistrationRequests.end() )
  {
    result = false ;
  }
  else 
  {
    result = i->second->cancelRegistrationForSignal ( sig, registrant ) ;
  }

#ifdef _OMK_MUTEX_
  _mutexPendingDataStructures.unprotect() ;
#endif

  return result ;
}



void Controller::addToPendingEvents (Event * event) 
{
  if (event != NULL)
  {
    OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::addToPendingEvents : Adding the following event to pending events of yet unexisting object: " << event->receiver << "\": "<< endl << *event  ) ;
#ifdef _OMK_MUTEX_
    _mutexPendingDataStructures.protect() ;
#endif
    map<Name, list <Event *> >::iterator pendingEventsMapIterator = _pendingEventsList.find( event->receiver ) ;
    if ( pendingEventsMapIterator != _pendingEventsList.end() )
    {
      pendingEventsMapIterator->second.push_back(event) ;
    }
    else
    {
      _pendingEventsList.insert (pair<Name, list<Event *> > (event->receiver, list<Event *>(1,event) ) ) ;
    }
#ifdef _OMK_MUTEX_
    _mutexPendingDataStructures.unprotect() ;
#endif
  }
}


void Controller::sendInitialEventsTo( ReferenceObjectHandle & objectHandle, const Date & dateOfMaskStart )
{ 
  if( &objectHandle.getSimulatedObject() != this )
  {
    OMTRACEID( OMK_DEBUG_OMK_EXEC, "Sending init event to \""
               << objectHandle.getSimulatedObject().getObjectDescriptor().getName()
               << "\"" ) ; 
    Event *startEvent = new Event(
      SystemEventIdentifier::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(),SystemEventIdentifier::MaskSuspend ) ;
    }

    //send any pending events 
    /* no mutex protection needed, because this is only called during
       controller's system event processing
    */
    map< Name, list< Event * > >::iterator pendingEvents =
      _pendingEventsList.find( objectHandle.getSimulatedObject().getObjectDescriptor().getName() ) ;
    if( pendingEvents != _pendingEventsList.end() )
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC,
                 "Found pending events for \""
                 << objectHandle.getSimulatedObject().getObjectDescriptor().getName()
                 << "\"" ) ;
      for( list< Event * >::iterator pendingEventsListIterator =
             pendingEvents->second.begin() ;
           pendingEventsListIterator != pendingEvents->second.end() ;
           ++pendingEventsListIterator )
      {
        OMTRACEID( OMK_DEBUG_OMK_EXEC, "sent" << std::endl
                   << **pendingEventsListIterator << std::endl 
                   << "to \""
                   << objectHandle.getSimulatedObject().getObjectDescriptor().getName()
                   << "\"" ) ;
        objectHandle.getSimulatedObject().sendEvent( *pendingEventsListIterator ) ;
      }
      _pendingEventsList.erase( pendingEvents ) ;
    }
  }
}



ObjectHandle *
Controller::removeObjectFromDataStructures(const Name & nom) {
  ReferenceObjectHandle * 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 Controller::deleteObjectHandle ( ObjectHandle * objectHandle )
{

  ObjectDescriptor * objectDescriptor  = const_cast<ObjectDescriptor *>(& 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 ) 
  {
    OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::deleteObject: deleting object descriptor of object \"" << objectDescriptor->getName() << "\"" ) ;
    OMTRACEID( "Deleting", "Controller::deleteObject: deleting object descriptor of object \"" << objectDescriptor->getName() << "\"" ) ;
    delete objectDescriptor;
  }
}

void 
Controller::deleteObject( ObjectDescriptor * objectDescriptor )
{
  OMTRACEID( OMK_DEBUG_OMK_EXEC,  "Controller::deleteObject \"" << objectDescriptor->getName() << "\"" ) ;


  if (objectDescriptor != &getObjectDescriptor() )
    //shouldn't delete oneself !
  {   
    OMASSERT ( objectDescriptor != NULL) ;

    // remove from the kernel's data structures
    ObjectHandle * 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) ) ;
    }
  }
}

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

SimulatedObject * Controller::createDescribedObject(const ObjectDescriptor * description ) 
{
  SimulatedObject * obj = description->createDescribedObject() ;

  return obj;
}


//--------------------------------------------------------
void Controller::processNewObjectDeclaration ( ObjectDescriptor & declaration, const Date & declarationDate )
{
  ReferenceObjectHandle * objectHandle = createReferenceObject (  & declaration ) ;
  OMASSERT ( 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 ) ;
}


ReferenceObjectHandle *
Controller::createReferenceObject (const ObjectDescriptor * objectDescription)

{
  OMASSERT (objectDescription != NULL );
  OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createReferenceObject " ) ;
  ReferenceObjectHandle * result = NULL ;

  SimulatedObject * createdObject = createDescribedObject ( objectDescription ) ;

  if (createdObject != NULL) 
  {
    result = createReferenceObjectHandle (*createdObject);

    _referenceObjectsMap.addObjectWithIndex (objectDescription->getName(), result);

  }
  else
  {
    OMERROR( "Controller::createReferenceObject unable to create" << endl << *objectDescription ) ;
  }
  OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createReferenceObject ended" ) ;
  return result;
}

SimulatedObject *
Controller::getPointerToDuplicatedObjectNamed( const Name& name ) 
{
  std::string errorMSg = "Controller::getPointerToDuplicatedObjectNamed ";
  // The object is a referential object or we need to make of it a referential object
  SimulatedObject * result = getPointerToSimulatedObjectNamed( name );
  if( !result ) 
  {
    ReferenceObjectHandle * ref = _referenceObjectsMap.getObjectOfIndex( name );
    if( !ref ) 
    {
      errorMSg += "\n No object " ;
      errorMSg += name.getCString() ;
      errorMSg += " in processus" ;
      Controller::error( errorMSg.c_str() );
    }   
  }
  else if ( result->getObjectDescriptor().getDistribution() == ObjectDescriptor::DUPLICATED_OBJECT ) 
  {
    errorMSg += ": Pointer to object : " ;
    errorMSg += name.getCString() ;
    errorMSg += " cannot be obtained : It is not a duplicated object" ;
    Controller::error( errorMSg.c_str() );
  }
  return result;
}

SimulatedObject *
Controller::getPointerToSimulatedObjectNamed (const Name & nom) 
{
  SimulatedObject * resul = NULL ;  
  //Two cases: object is already a referential or it is needed to make it a referential
  ReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex(nom);
  if (refe==NULL) 
  {
    if ( nom == getName() ) 
    {
      resul = this ;
    }
    else 
    {
      //the object might have just been deleted : look for it in _deletedObjectHandles
      list <pair <Date, ObjectHandle *> >::iterator i = _deletedObjectHandles.begin() ;
      while ( i != _deletedObjectHandles.end() )
      {
        if (i->second->getSimulatedObject().getName() == nom )
        {
          resul = & i->second->getSimulatedObject() ;
          i = _deletedObjectHandles.end() ;
        }
        else
        {
          ++i ;
        }
      }
    }
  }
  else 
  {
    resul=&refe->getSimulatedObject();  
  }
  return resul;
}

const ObjectDescriptor & Controller::getObjectDescriptorOfObject(const Name & objectName) 
{
  // Benoit Chanclou 2006-04-03 avoid to two calls to findDescendantNamed (search in a list)
  const ObjectDescriptor * p_objDescriptor = _simulationTree.findDescendantNamed( objectName ) ;
  if ( p_objDescriptor )
  {
    return *p_objDescriptor ;
  }
  else 
  {
    //the object might have just been deleted : look for it in _deletedObjectHandles
    list <pair <Date, ObjectHandle *> >::iterator i = _deletedObjectHandles.begin() ;
    while ( i != _deletedObjectHandles.end() )
    {
      if ( i->second->getSimulatedObject().getName() == objectName )
      {
        return i->second->getSimulatedObject().getObjectDescriptor() ;
      }
      ++i ;
    }
    UserException e( "UnknownObject :" ) ; 
    e << objectName ;
    throw e ;
  }
}



//**********************************************
// aspects frequentiels
const Date & 
Controller::getSimulatedDate () const 
{
  return _date;
}

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

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


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



int Controller::lcm (const int a, const int b) {
  return (a * b / gcd (a, b)) ;
}

int Controller::gcd (const int a, const int b) {
  // int res = a ;
  //  if (b != 0) {
  //     res = gcd (b, a % b) ;
  //  }
  if ( b == 0 )
  {
    if ( a == 0 )
    {
      return 1 ;
    }
    return a ;
  }
  if ( a < b )
  {
    return gcd( b, a ) ;
  }
  return gcd( b, a % b ) ;
}

void Controller::showDateAndStepNumber( bool show )
{
  _showDateAndStepNumber = show ;
}

void Controller::error( const char * Errormess )
{
  throw UserException( Errormess ) ;
}

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

void Controller::actOnSystemEvent( Event * 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() )
  {
#ifdef _OMK_MUTEX_
    _mutexSystemEventsList.protect() ;
#endif
    Event::insertInList( _systemEventsList[ _currentWritableSystemEventsList ],
                         event->clone() ) ;
#ifdef _OMK_MUTEX_
    _mutexSystemEventsList.unprotect() ;
#endif
  }
  else if( this != & getController() )
  {
    //the controller is being controlled : send a copy of the event to the
    // controllers controller
    getController().actOnSystemEvent( event ) ;
  }
}

bool Controller::processEvent( Event * event )
{
  const EventIdentifier & eventId ( event->eventId ) ;
  if (eventId == SystemEventIdentifier::MaskRestart) 
  {
    if (*_computeStatePointer == ReferenceObjectHandle::stopped)
    {
      *_computeStatePointer = ReferenceObjectHandle::initial ;
      //implementation very difficult, because the original simulation tree has been modified
      init() ;
      OMASSERT (false) ; 
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "Controller::processEvent should be stopped before restarted" );
    }
  }
  else if ( eventId ==  SystemEventIdentifier::MaskResume ) 
  {
    *_computeStatePointer = ReferenceObjectHandle::running;
  } 
  else if ( eventId == SystemEventIdentifier::MaskSuspend ) 
  {
    if (*_computeStatePointer != ReferenceObjectHandle::suspended )
    {
      // moving in suspended mode
      // stop computations, even forced
      _forcedCompute = false ;
      *_computeStatePointer = ReferenceObjectHandle::suspended ;
    }
  } 
  else if ( eventId == SystemEventIdentifier::MaskStop ) 
  {
    if (*_computeStatePointer != ReferenceObjectHandle::stopped )
    {
      *_computeStatePointer=ReferenceObjectHandle::stopped ;

      finish() ;
    }

  } 
  else if ( eventId == SystemEventIdentifier::MaskStart ) 
  {

    *_computeStatePointer=ReferenceObjectHandle::running;
    //this produces incorrect behaviour from the point of view of an object controlling the controller
    //if(_date==Controller::initialSimulationDate) advanceSimulatedDate();

  } 
  else if (eventId == SystemEventIdentifier::MaskDelete ) 
  {
    *_computeStatePointer=ReferenceObjectHandle::destroyed;
  } 
  else if ( eventId == SystemEventIdentifier::MaskNewObject ) 
  {
    CreateObjectEvent * creationEvent = dynamic_cast< CreateObjectEvent* >( event ) ;

    OMASSERT (creationEvent != NULL ) ;

    // add the described object in the simulation tree : this is a declaration
    ObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed( creationEvent->value.getValue().first.getName() );
    if ( objectDescriptor == NULL )
    {
      ObjectDescriptor * newObjectDescriptor = new ObjectDescriptor(creationEvent->value.getValue().first) ;
      ObjectDescriptor * fathersDescription = _simulationTree.findDescendantNamed ( creationEvent->value.getValue().second ) ;
      if (fathersDescription == NULL)
      {
        fathersDescription = & _simulationTree ;
        OMTRACEID( OMK_DEBUG_OMK_EXEC, "Attached new object named \"" << newObjectDescriptor->getName() 
          << "\" to \"" << getName()
          << "\" because object \""<<creationEvent->value.getValue().second<<"\" is unknown" );
      }
      changeObjectsFather (newObjectDescriptor, fathersDescription) ;

      //create the described object
      processNewObjectDeclaration ( *newObjectDescriptor, event->date ) ;

      // notify other objects that an object has been created
      fireValuedSignal(SystemEventIdentifier::MaskObjectCreated,creationEvent->value.getValue().first.getName() ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "WARNING: an object of name \"" << creationEvent->value.getValue().first.getName()
        << "\" already exists" ) ;
    }
  }
  else if ( eventId == SystemEventIdentifier::MaskRecomputeScheduling)
  {
    computeScheduling( true ) ;

    scheduleControlledObjects() ;
  }
  else 
  {
    OMTRACEID( OMK_DEBUG_OMK_EXEC, "WARNING:Controller::ProcessEvent unable to process system event " ) ;
  } 
  return true ;
}



void Controller::processStartEventOf(ReferenceObjectHandle * objectHandle) 
{

  if(objectHandle->getComputingState() == ReferenceObjectHandle::initial) 
  {
    setComputingState (objectHandle, ReferenceObjectHandle::running ) ;
    noActivationNeededFor ( objectHandle );
    OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::processStartEventOf Init of \"" << objectHandle->getSimulatedObject().getName() << "\"" ) ;
    objectHandle->init() ;
    OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::processStartEventOf end of init of \"" << objectHandle->getSimulatedObject().getName() << "\"" ) ;

    _scheduler->schedule( objectHandle );

  }
}

void Controller::processStartEventAfterMorphose(ReferenceObjectHandle * objectHandle) 
{

  if(objectHandle->getComputingState() == ReferenceObjectHandle::initial) 
  {
    setComputingState (objectHandle, ReferenceObjectHandle::running ) ;
    noActivationNeededFor ( objectHandle );

    objectHandle->initAfterMorphose() ;

    _scheduler->schedule( objectHandle );
  }
}
void Controller::processDeleteEventOf(ReferenceObjectHandle * objectHandle) 
{
  OMTRACEID( OMK_DEBUG_OMK_EXEC, " Controller::processDeleteEventOf \""<<objectHandle->getSimulatedObject().getName()<< "\"" ) ;
  if(objectHandle->getComputingState() == ReferenceObjectHandle::stopped) 
  {
    fireValuedSignal( SystemEventIdentifier::MaskObjectDestroyed, objectHandle->getSimulatedObject().getObjectDescriptor().getName() ) ;
    setComputingState ( objectHandle, ReferenceObjectHandle::destroyed );
    deleteObject(const_cast<ObjectDescriptor *>(&objectHandle->getSimulatedObject().getObjectDescriptor()) );
  }         
}

void Controller::reactToControlledObjectsSystemEvents()
{
  switchSystemEventList() ;
  list< Event * > & myEventList = *_systemEventsList [ 1 - _currentWritableSystemEventsList ] ;
  list< Event * >::iterator i = myEventList.begin() ;
  while ( i != myEventList.end() )
  {
    SimulatedObject *receiverObject = getPointerToSimulatedObjectNamed( (*i)->receiver ) ;
    Event *currentEvent = (*i) ;

    if( receiverObject == 0 ) 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC,
                 "WARNING : object \"" << currentEvent ->receiver.getCString() 
                 <<"\", who has received event" << endl
                 << *currentEvent << endl
                 <<" doesn't exist (anymore)" ) ;
    }
    else
    {
      ReferenceObjectHandle *receiverReferential = dynamic_cast< ReferenceObjectHandle * >( receiverObject->getObjectHandle() );
      OMASSERT( receiverReferential != 0 ) ;
      OMTRACEID( OMK_DEBUG_OMK_EVENT, *currentEvent << endl << " received by \"" <<receiverObject->getName() << "\"" ) ;
      if( currentEvent->eventId == SystemEventIdentifier::MaskStart ) 
      {
        processStartEventOf ( receiverReferential );
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskStop )
      {
        OMTRACEID( OMK_DEBUG_OMK_EVENT, "\"" << currentEvent->receiver <<"\" will be stopped " ) ;
        if( receiverReferential->getComputingState() == ReferenceObjectHandle::running ||
            receiverReferential->getComputingState() == ReferenceObjectHandle::suspended ) 
        {
          setComputingState( receiverReferential, ReferenceObjectHandle::stopped );
          receiverReferential->processEvents() ;
          receiverObject -> finish() ;
          _scheduler->unschedule( receiverReferential ); 
        }
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskSuspend )
      {
        OMTRACEID( OMK_DEBUG_OMK_EVENT, "\"" << currentEvent->receiver <<"\" will be suspended" ) ;
        if( receiverReferential->getComputingState() == ReferenceObjectHandle::running )
        {
          setComputingState( receiverReferential, ReferenceObjectHandle::suspended ) ;
          // MaskSuspend will be treated at the end of the time step + with present events
          hasEventsToProcess( receiverReferential ) ;
          _scheduler->unschedule( receiverReferential );
        }
        else
        {
          OMASSERT( receiverReferential->getComputingState() == ReferenceObjectHandle::suspended ) ;
        }
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskResume ) 
      {
        OMTRACEID( OMK_DEBUG_OMK_EVENT, "\"" << currentEvent->receiver <<"\" will resume execution" ) ;
        if( receiverReferential->getComputingState() == ReferenceObjectHandle::suspended ) 
        {
          setComputingState( receiverReferential, ReferenceObjectHandle::running );
          // treating event is useless because coming computes will do that
          noActivationNeededFor( receiverReferential ) ;
          _scheduler->schedule( static_cast< ReferenceObjectHandle * >( receiverObject->getObjectHandle() ) );
        }
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskDelete ) 
      {
        processDeleteEventOf( receiverReferential ) ;
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskRestart )
      {
        OMTRACEID( OMK_DEBUG_OMK_EVENT, "\"" << currentEvent->receiver <<"\" will be restarted" ) ;
        if( receiverReferential->getComputingState() == ReferenceObjectHandle::stopped )
        {
          setComputingState( receiverReferential, ReferenceObjectHandle::running ) ;
          // treating event is useless because coming computes will do that
          noActivationNeededFor( receiverReferential );

          receiverObject->init() ;
          // we know it is a referential
          _scheduler->schedule( receiverReferential ) ;
        }
      }
      else if( currentEvent->eventId == SystemEventIdentifier::MaskChangeObjectFrequency )
      {
        ValuedEvent< Frequency > *realEvent = dynamic_cast< ValuedEvent< Frequency > * >( currentEvent ) ;
        OMASSERT( realEvent != 0 ) ;
        ObjectDescriptor *objectDescription = _simulationTree.findDescendantNamed( realEvent->receiver ) ;
        if( objectDescription != 0 )
        {
          objectDescription->setFrequency( realEvent->value ) ;
          if( realEvent->value == computeAdequateFrequency ( realEvent->value ) )
          {
            ReferenceObjectHandle *referenceObjectHandle = _referenceObjectsMap.getObjectOfIndex( realEvent->receiver ) ;
            if ( referenceObjectHandle != 0 )
            {
              _scheduler->unschedule( referenceObjectHandle ) ;
              _scheduler->removeFromScheduable( referenceObjectHandle ) ;
              scheduleObject( _referenceObjectsMap.getObjectOfIndex( realEvent->receiver ) ) ;
            }
          }
          else 
          {
            computeScheduling( false ) ; //false necessary because otherwise no change would happen
            scheduleControlledObjects() ;
          }
        }
        else
        {
          OMTRACEID( OMK_DEBUG_OMK_EXEC,
                     "Controller received MaskChangeObjectFrequency for \"" << realEvent->receiver << "\" which is unknown " ) ;
        }
      }
    }
    list< Event * >::iterator toErase = i ;
    i++ ;
    Event *eventToDelete = *toErase ;
    myEventList.erase( toErase ) ;
    delete eventToDelete ;
  }
}

void Controller::noActivationNeededFor (ReferenceObjectHandle * refObjet)
{
  _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->remove( refObjet );
  refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = false ;
  OMASSERT ( refObjet->_isInObjectNeedingActivationList[ 1 - _currentListOfObjectsNeedingActivation ] == false );
}

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

  //the controller shouldn't try and schedule itself if it isn't controlled
  if (refObjet != _objectHandle)
  {

    if (!refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ]) 
    {
      OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::hasEventsToProcess of \"" << refObjet->getSimulatedObject().getName() 
        << "\" at date "<< _date + _stepPeriod ) ;
      _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->push_back ( refObjet );
      refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = true ;
    } 
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::hasEventsToProcess of \"" << refObjet->getSimulatedObject().getName() 
        << "\" at date "<< _date + _stepPeriod << " not necessary " ) ;
    }
  }
  else if ( & getController() != this )
  {
    getController().hasEventsToProcess( refObjet ) ;
  }
}

void Controller::postponeEventProcessing( ReferenceObjectHandle * refObjet )
{
  _listOfObjectsWithPostPonedEvents.push_back(refObjet) ;
}

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



int Controller::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 Controller::broadcastEventsForSignal (Event & event, const EventIdentifier & sigId) 
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::broadcastEventsForSignal \"" << sigId << "\"" ) ;
  _controledObjectsSignalsDispatcher.sendEventsForSignal( event , sigId ) ;
}


bool Controller::receiveRegistrationForSignal(const EventIdentifier & sig,
                                                 const Name & registrant, 
                                                 const EventIdentifier & eventId)
{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::receiveRegistrationForSignal \"" << sig
    << "\" by \"" << registrant
    << "\" for \"" << eventId << "\"" ) ;
  return _controledObjectsSignalsDispatcher.registerForSignal(sig , registrant , eventId) ;
}


bool Controller::receiveCancellationForSignal ( const EventIdentifier & sigId , const Name & registrant ) 
{
  return _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (sigId , registrant) ;
}




ReferenceObjectHandle * Controller::newOMKReferenceObjectHandle(SimulatedObject & object, 
                                                                      Controller & controller,
                                                                      SignalDispatcher * signalDispatcher)
{
  return new ReferenceObjectHandle(object, controller, signalDispatcher) ;
}



ReferenceObjectHandle * Controller::createReferenceObjectHandle(SimulatedObject & obj) 
{
  /* no mutex protection needed, because this member function is only called by the controller during system event processing */
  OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createReferenceObjectHandle" ) ;
  ReferenceObjectHandle * result ;
  map<Name, SignalDispatcher *>::iterator i = _pendingRegistrationRequests.find( obj.getName() ) ;
  if ( i == _pendingRegistrationRequests.end() )
  {
    result = newOMKReferenceObjectHandle(obj,*this, new SignalDispatcher (*this) );
  }
  else 
  {
    result = newOMKReferenceObjectHandle(obj,*this, i->second) ;
    _pendingRegistrationRequests.erase ( i ) ;
  }
  OMTRACEID( OMK_DEBUG_OMK_OBJ, "Controller::createReferenceObjectHandle ended" ) ;
  return result ;
}


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


MultipleConfigurationParameter * Controller::getSchedulingParametersOfObject(ObjectDescriptor & objectDescription ) 
{
  return objectDescription.getSchedulingParameters () ;
}

void Controller::setProcessOfDescriptor ( ObjectDescriptor & objectDescription, const Name & newProcessName ) 
{
  objectDescription.setProcess ( newProcessName ) ;
}

---