OMK::Controller Class Reference

Defining what a controller is. More...

#include <OMKController.h>

Inheritance diagram for OMK::Controller:

[legend]Collaboration diagram for OMK::Controller:

[legend]List of all members.

Public Types
typedef std::pair< Name, Name >	MigrationObjectPrm
typedef std::pair< ObjectDescriptor, Name >	CreateObjectPrm
	parameters to create object
Public Member Functions
	Controller (ObjectDescriptor &simulationTree, const Date &initialDate)
	constructor for a classic controller
virtual	~Controller ()
	destructor
virtual void	init ()
	initialise the object.
virtual void	run ()
	run Start the controller on a infinite loop which will be broken if system events are sent to the controller
template<typename Type>
std::list< const ObjectDescriptor * > *	listDescendantsOfType (const Name &objectName)
	List the descendants of an object that are of a certain type.
template<typename Type>
std::list< const ObjectDescriptor * > *	listBrothersOfType (const Name objectName)
	list brothers of objectName in the simulation tree of that are of type t
void	processStartEventAfterMorphose (ReferenceObjectHandle *objectHandle)
	CHADI.
virtual void	createLocalObject (const ObjectDescriptor &newLObjectDescription, const Name &fathersLName)
	create a local object
virtual int	getMirrorsNbre ()
virtual bool	isAMirror (const Name &name)
virtual std::vector< Name >	getMirrorList ()
virtual std::vector< Name >	getIsolatedMirrorList ()
virtual std::vector< Name >	getNonIsolatedMirrorList ()
virtual bool	testIfTroubleOccured ()
virtual void	createNewSite (const Date &)
	DECLARE_TYPE_EVENT (MigrationObjectPrm, MigrationObject)
void	migrateObjectToProcess (Name &nomObjet, Name &nomProcess)
virtual std::list< Name >	getDisconnectedProcessusList ()
virtual std::map< Name, int >	getDisconnectedProcessusMap ()
virtual Frequency	computeAdequateFrequency (const Frequency &suggestedFrequency)
	compute an adequate Frequency for an object dynamically created Should be used to adapt the desired frequency when an simulated object is dynamically created so that the creation doesn't cause recomputation of the scheduling.
virtual void	runControllersStep (ReferenceObjectHandle *objectHandle)
	run a controllers simulation step.
virtual void	compute ()
	computes a new simulation step for all controlled objects, if the controller is in the running state, otherwise jsut react to system events sent to controlled objects
virtual void	finish ()
	finish the simulation.
void	showDateAndStepNumber (bool show=true)
	ask the controller to print (or not) to sdterr (cerr) the simulation date and the step number
virtual const Date &	getSimulatedDate () const
	Returns a reference to an allways accurate simulation date, in ms.
virtual int	getCycleFrequency () const
	get the simulation cycle frequency
virtual int	getCyclePeriod () const
	get the simulation cycle period, in simulated time (in ms)
	DECLARE_TYPE_EVENT (CreateObjectPrm, CreateObject)
virtual void	createObject (const ObjectDescriptor &newObjectDescription, const Name &fathersName)
	creation of an object unknown of in the simulation tree.
virtual void	destroyObject (const Name &name, bool recursively)
	destroy a simulated object.
virtual void	changeObjectsFather (const Name &name, const Name &newFather)
	change the father of an object in the simulation tree.
virtual void	changeObjectsFather (ObjectDescriptor *object, ObjectDescriptor *newFather)
	change the father of an object in the simulation tree.
virtual SimulatedObject *	getPointerToDuplicatedObjectNamed (const Name &name)
	get a pointer to a simulated object
virtual SimulatedObject *	getPointerToSimulatedObjectNamed (const Name &name)
	get a pointer to a simulated object After return from this method, it's possible to query any method of the simulated object that doesn't depend on the evolution of that object, as the object returned can have been created specially by the call.
virtual const ObjectDescriptor &	getObjectDescriptorOfObject (const Name &objectName)
	get the object descriptor of a given simulated object
virtual std::vector< Name >	getReferentielList ()
virtual void	actOnSystemEvent (Event *event)
	called when a reference object receives a system event
virtual void	reactToControlledObjectsSystemEvents ()
	process system events received by controlled objects
virtual void	processStartEventOf (ReferenceObjectHandle *objectHandle)
	process MaskStart systemEvent for the object with handle
virtual void	processDeleteEventOf (ReferenceObjectHandle *objectHandle)
	process MaskDelete systemEvent for object obj
virtual void	hasEventsToProcess (ReferenceObjectHandle *referenceObjectHandle)
	add the object handled by referenceObjectHandle to the list of objects having events to process and therefore that need activation (and therefore possibly activated at the current simulation step).
virtual void	postponeEventProcessing (ReferenceObjectHandle *referenceObjectHandle)
	add the object described by referenceObjectHandle to the list of object with events to process at the next simulation step.
virtual void	noActivationNeededFor (ReferenceObjectHandle *referenceObjectHandle)
	remove object designated by referenceObjectHandle from the list of object needing activation by the controler because they have events pending.
virtual void	addToPendingEvents (Event *)
	add the event to the list of pending events.
virtual bool	addToPendingRegistrations (const EventIdentifier &sig, const Name &producer, const EventIdentifier &eventId, const Name &registrant)
	addToPendingRegistrations.
virtual bool	removeFromPendingRegistrations (const EventIdentifier &sig, const Name &producer, const Name &registrant)
	removeFromPendingRegistrations.
virtual bool	processEvent (Event *)
	process events sent to the controller
virtual void	processEventsOfSuspendedObjects ()
	call processEvent for suspended objects having received events
virtual void	broadcastEventsForSignal (Event &event, const EventIdentifier &sigId)
	broadcast events corresponding to a fired signal
virtual bool	receiveRegistrationForSignal (const EventIdentifier &sigId, const Name &registrant, const EventIdentifier &eventId)
	register an object for a signal
virtual bool	receiveCancellationForSignal (const EventIdentifier &sigId, const Name &registrant)
	cancel the registration of an object for a signal
template<typename Type>
Input< Type > *	createInput (const Name &name, SimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create an input
template<typename Type>
SensitiveInput< Type > *	createSensitiveInput (const Name &name, SimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create a sensitive input
template<typename Type>
SensitiveNotifyingInput< Type > *	createSensitiveNotifyingInput (const Name &name, SimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create a sensitive notifying input
template<typename Type>
Output< Type > *	createOutput (const Name &name, SimulatedObject &owner, OMK::Type::PolatorNT *polator)
	create an ouput
template<typename Type>
ControlParameter< Type > *	createControlParameter (const Name &name, SimulatedObject &owner, OMK::Type::PolatorNT *polator)
	create a control parameter
template<typename Type>
InputAlias< Type > *	createInputAlias (const Name &name, SimulatedObject &owner, AbstractInput< Type > *input, int requestedPrecisionLevel)
	create an input alias
template<typename Type>
SensitiveInputAlias< Type > *	createSensitiveInputAlias (const Name &name, SimulatedObject &owner, AbstractInput< Type > *input, int requestedPrecisionLevel)
	create a sensitive input alias
template<typename Type>
SensitiveNotifyingInputAlias< Type > *	createSensitiveNotifyingInputAlias (const Name &name, SimulatedObject &owner, AbstractInput< Type > *input, int requestedPrecisionLevel)
	create a sensitive notifying input alias
template<typename Type>
OutputAlias< Type > *	createOutputAlias (const Name &name, SimulatedObject &owner, Output< Type > *output, OMK::Type::PolatorNT *polator)
	create an ouput alias
Static Public Member Functions
static void	error (const char *mess)
	included for ascendant compatibility : raises a OMKUserException with the message passed as parameter
static int	lcm (const int a, const int b)
static int	gcd (const int a, const int b)
static bool	setKernelObjectFactory (KernelObjectAbstractFactory *aFactory)
	set the kernelObjectfactory for the controller of this adressing space is only effective once for each adress space to be called before creation of the controller to be effective return : change effective
static KernelObjectAbstractFactory *	getKernelObjectFactory ()
	get the active kernelObjectFactory
Public Attributes
std::vector< Name >	_publicReferentielObjectsVector
	CHADI.
Static Public Attributes
static Date	initialSimulationDate
	date at which simulation was initialised
Protected Member Functions
virtual void	computeNextSimulationStep ()
	compute the next simulation step
virtual void	scheduleObject (ReferenceObjectHandle *ref)
	add a simulated object to the appropriate execution frames, without flagging it as executable
MultipleConfigurationParameter *	getSchedulingParametersOfObject (ObjectDescriptor &)
	get a modifiable version of the scheduling parameters of an object.
SimulatedObject *	createDescribedObject (const ObjectDescriptor *description)
	createDescribedObject.
virtual void	setProcessOfDescriptor (ObjectDescriptor &objectDescription, const Name &newProcessName)
virtual void	computeScheduling (bool fromOriginal)
	compute the scheduling data strucures.
virtual void	sendInitialEventsTo (ReferenceObjectHandle &objectHandle, const Date &dateOfMaskStart)
	Send MaskStart to any created objects, and send any pending events which where stored (none by default) because send to an object before it was created.
virtual void	deleteObject (ObjectDescriptor *objectDescription)
	delete an object.
virtual ObjectHandle *	removeObjectFromDataStructures (const Name &)
	remove any reference to a simulated object from all the controller's data structures
virtual void	processNewObjectDeclaration (ObjectDescriptor &declaration, const Date &declarationDate)
	processNewObjectDeclaration Once an object has been added to the simulation tree, this is called for creation and scheduling
virtual ReferenceObjectHandle *	createReferenceObject (const ObjectDescriptor *idObjet)
	createReferenceObject.
virtual Scheduler *	createScheduler ()
	create the scheduler that is in charge of effective scheduling of the controlled objects
virtual void	scheduleControlledObjects ()
	scheduleControlledObjects schedule all controlled reference objects
virtual void	advanceSimulatedDate ()
	increment date and numberOfSimulatedSteps
virtual void	createControlledObjects (const ObjectDescriptor *subTree)
	createControlledObjects Create a reference object for all objects of a simulation tree
virtual void	setCycleFrequency (int newFrequency)
virtual void	setComputingState (ReferenceObjectHandle *, ReferenceObjectHandle::SimulatedObjectComputingState) const
	change the computing state of a reference object handle
virtual void	switchSystemEventList ()
	switch buffer of List Of Objects Needing Activation
virtual void	purgeMemoryFromOldEvents (const Date &dateOfOldestKept)
	the method used to purge the data structures from all outdated kepts events.
virtual Date	getPurgeDate ()
	get the date of the oldest event not purged by purgeMemoryFromOldEvents
virtual int	getOutputHistorySize (void)
	get the minimum history length pertinant for this controller The value returned is the value of the environement variable MaskHISTORYLENGTH, or a default value calculated so that get(-4 dt) return an exact value if it has been produced
virtual ReferenceObjectHandle *	createReferenceObjectHandle (SimulatedObject &obj)
	create a reference object handler appropriate for this controller
virtual ReferenceObjectHandle *	newOMKReferenceObjectHandle (SimulatedObject &object, Controller &controller, SignalDispatcher *signalDispatcher)
	The controller is an abstract factory for reference object handles.
virtual void	deleteObjectHandle (ObjectHandle *objectHandle)
	as the controller is an abstract factory for object handlers, is should also be an abstract destroyer
Protected Attributes
NameToPointerMap< ReferenceObjectHandle >	_referenceObjectsMap
	data structure containing references to the ReferenceObjectHandlers
ObjectDescriptor &	_simulationTree
	the simulation tree this controller is root of This has to be a reference to a allready constructed simulation tree, because the root descriptor of that tree is used a parameter of the ancestors constructor wich keeps a reference of that descriptor.
unsigned long int	_numberOfSimulatedSteps
	number of simulated steps up to now
Frequency	_stepFrequency
	frequency of a simulation step
int	_cycleFrequency
	the frequency at wich activation patterns repeat themselves
int	_cyclePeriod
	duration in simulated time of a simualtion cycle
int	_nbStepsByCycle
	number of simulation step by cycle : we have _cycleFrequency * stepFrequency = _nbStepsByCycle
int	_stepPeriod
	_stepPeriod.
Date	_date
	simulated date
bool	_showDateAndStepNumber
	flag indicating if the date and simulation step number are printed
ReferenceObjectHandle::SimulatedObjectComputingState *	_computeStatePointer
	a pointer for easy access to th computationnel state of the controller : if the controller is controlling itsekg, this computationnal state should be : running
SignalDispatcher	_controledObjectsSignalsDispatcher
	signal dispatcher for objects interested in a signal whatever it's producer
bool	_forcedCompute
	to enable computations even in suspendedState, when the controller is controlled
Scheduler *	_scheduler
	the scheduler
std::list< ReferenceObjectHandle * > *	_objectsNeedingActivationList [2]
	double buffered list of controlled object needing activation because they have received events Protect usage with _mutexForListEvt ;
int	_currentListOfObjectsNeedingActivation
	1 - _currentListOfObjectsNeedingActivation is used to store new object needing activation
std::list< Event * > *	_systemEventsList [2]
	double buffered system event list
unsigned int	_currentWritableSystemEventsList
	_systemEventsList[_currentWritableSystemEventsList] is used to store system events sent to controlled objects
std::list< ReferenceObjectHandle * >	_listOfObjectsWithPostPonedEvents
	list of objects with postponed events
std::map< Name, std::list< Event * > >	_pendingEventsList
	list of pending events (events sent to unknown objects)
std::map< Name, SignalDispatcher * >	_pendingRegistrationRequests
	map of pending registration requests
std::list< std::pair< Date, ObjectHandle * > >	_deletedObjectHandles
	the list of recently deleted object handles.
Static Private Attributes
static KernelObjectAbstractFactory *	kernelObjectFactory
	the kernel object factory used to create attribute of controlled object
Friends
class	InputNT
class	OMK::SimulatedObject

---

Detailed Description

Defining what a controller is.

A controller is in charge of simulating time and activating objects whose evolution is time related.

Author:

David Margery

Version:

• 2.1 redone event managing
• 2.0 (by siames ): inherited for SimulatedObject

Definition at line 53 of file OMKController.h.

---

Member Typedef Documentation

typedef std::pair< Name,Name > OMK::Controller::MigrationObjectPrm

Definition at line 113 of file OMKController.h.

typedef std::pair< ObjectDescriptor,Name > OMK::Controller::CreateObjectPrm

parameters to create object

Definition at line 185 of file OMKController.h.

---

Constructor & Destructor Documentation

Controller::Controller	(	ObjectDescriptor &	simulationTree,
		const Date &	initialDate
	)

constructor for a classic controller

Parameters:

	initialObjects	the simulation tree describing the initial simulated objects to create. The root element of that tree is considered as describing the controller, and therfore it's class is ignored
	initialDate	the date at wich the simualtion is going to start

Definition at line 67 of file OMKController.cpp.

References _computeStatePointer, _currentListOfObjectsNeedingActivation, _currentWritableSystemEventsList, OMK::ObjectDescriptor::_destroySimulatedObject, OMK::SimulatedObject::_objectHandle, _objectsNeedingActivationList, OMK::ObjectDescriptor::_pointerToSimulatedObject, _simulationTree, _systemEventsList, OMK::Type::PolatorNT::Constant, OMK::Type::PolatorNT::ConstantContinuous, createReferenceObjectHandle(), OMK::Type::PolatorNT::Cubic, OMK::Type::PolatorNT::CubicContinuous, OMK::Type::PolatorNT::defaultPrecisionLevel, OMK::ParametersAccessor::get(), OMK::ConfigurationParameterDescriptor::getAssociatedString(), OMK::SimulatedObject::getConfigurationParameters(), OMK::ConfigurationParameterDescriptor::getSubDescriptorByName(), OMK::ReferenceObjectHandle::initial, initialSimulationDate, OMK::Type::PolatorNT::Linear, OMK::Type::PolatorNT::LinearContinuous, OMASSERT, OMERROR, OMK_DEBUG_ERROR, OMK_DEBUG_FATAL_ERROR, OMK_DEBUG_MESSAGE, OMK_DEBUG_WARNING, OMK::Type::PolatorNT::Quadratic, and OMK::Type::PolatorNT::QuadraticContinuous.

: 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 ;
}

Controller::~Controller

(

)

[virtual]

destructor

Definition at line 177 of file OMKController.cpp.

References _date, OMK::SimulatedObject::_objectHandle, _objectsNeedingActivationList, _pendingRegistrationRequests, _scheduler, _stepPeriod, _systemEventsList, and purgeMemoryFromOldEvents().

{
  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 ;
}

---

Member Function Documentation

void Controller::init

(

)

[virtual]

initialise the object.

Use this member function for any initilisation than can only be done when all the simulated objects have been created. In particular, plugging the input of the objects should be done here. By default, this member function calls the initialisation of the associated computational object.

Reimplemented from OMK::SimulatedObject.

Reimplemented in OMK::PvmController.

Definition at line 476 of file OMKController.cpp.

References _date, _referenceObjectsMap, _simulationTree, _stepFrequency, _stepPeriod, advanceSimulatedDate(), computeScheduling(), createControlledObjects(), getCycleFrequency(), OMK::SimulatedObject::getName(), OMK::SimulatedObject::getObjectHandle(), initialSimulationDate, OMMESSAGE, scheduleControlledObjects(), and sendInitialEventsTo().

Referenced by OMK::PvmController::init(), and processEvent().

{

  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

(

)

[virtual]

run Start the controller on a infinite loop which will be broken if system events are sent to the controller

Reimplemented in OMK::PvmController.

Definition at line 516 of file OMKController.cpp.

References _computeStatePointer, OMK::SimulatedObject::_objectHandle, OMASSERT, runControllersStep(), and OMK::ReferenceObjectHandle::running.

Referenced by OMK::PvmController::run().

{
  ReferenceObjectHandle * objectHandle = dynamic_cast<ReferenceObjectHandle *> ( _objectHandle ) ;
  OMASSERT ( objectHandle != NULL ) ;
  *_computeStatePointer = ReferenceObjectHandle::running ;
  while(*_computeStatePointer == ReferenceObjectHandle::running) 
  {
    runControllersStep (objectHandle) ;
  }//while
}

template<typename Type>

std::list< const ObjectDescriptor * > * OMK::Controller::listDescendantsOfType

(

const Name &

objectName

)

[inline]

List the descendants of an object that are of a certain type.

Parameters:

objectName

: the ancestor object

Returns:

a list of the descendants of objectName that are of the type of the template parameter. The resulting list should be destroyed after usage

Definition at line 676 of file OMKController.h.

References OMK::ObjectDescriptor::findDescendantNamed(), and OMK::SimulatedObject::getObjectDescriptor().

{
  const ObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ;
  if ( objectDescriptor != NULL )
    {
      return objectDescriptor->template listDescendantsOfType<Type> () ; 
    }
  else
    {
      return new std::list<const ObjectDescriptor *>() ;
    }
}

template<typename Type>

std::list< const ObjectDescriptor * > * OMK::Controller::listBrothersOfType

(

const Name

objectName

)

[inline]

list brothers of objectName in the simulation tree of that are of type t

Parameters:

objectName

: name of the brother

Returns:

a list of the brothers of objectName that are of the type of the template parameter. The resulting list should be destroyed after usage

Definition at line 695 of file OMKController.h.

References OMK::ObjectDescriptor::findDescendantNamed(), OMK::ObjectDescriptor::getFathersObjectDescriptor(), and OMK::SimulatedObject::getObjectDescriptor().

{
  const ObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ;
  if ( objectDescriptor != NULL )
    {
      objectDescriptor = objectDescriptor->getFathersObjectDescriptor() ;
      if ( objectDescriptor != NULL )
        {
          return objectDescriptor->template listBrothersOfType<Type> () ; 
        }
      else
        {
          return new std::list<const ObjectDescriptor *>() ;
        }
    }
  else
    {
      return new std::list<const ObjectDescriptor *>() ;
    }
}

void Controller::computeNextSimulationStep

(

)

[protected, virtual]

compute the next simulation step

Reimplemented in OMK::PvmController.

Definition at line 627 of file OMKController.cpp.

References _numberOfSimulatedSteps, _scheduler, OMK_DEBUG_OMK_EXEC, OMTRACEID, processEventsOfSuspendedObjects(), reactToControlledObjectsSystemEvents(), and OMK::Scheduler::runStep().

Referenced by compute(), and OMK::PvmController::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::scheduleObject

(

ReferenceObjectHandle *

ref

)

[protected, virtual]

add a simulated object to the appropriate execution frames, without flagging it as executable

Parameters:

ref

the object handle of the simulated object

Definition at line 387 of file OMKController.cpp.

Referenced by OMK::DistributedController::getPointerToSimulatedObjectNamed(), OMK::DistributedController::processEvent(), processNewObjectDeclaration(), reactToControlledObjectsSystemEvents(), and scheduleControlledObjects().

  {
    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 ) ;
    }   
  }
}

void Controller::processStartEventAfterMorphose

(

ReferenceObjectHandle *

objectHandle

)

CHADI.

Definition at line 1305 of file OMKController.cpp.

References _scheduler, OMK::ReferenceObjectHandle::getComputingState(), OMK::ReferenceObjectHandle::initial, noActivationNeededFor(), OMK::ReferenceObjectHandle::running, OMK::Scheduler::schedule(), and setComputingState().

Referenced by OMK::DistributedController::processEvent().

{

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

    objectHandle->initAfterMorphose() ;

    _scheduler->schedule( objectHandle );
  }
}

void Controller::createLocalObject	(	const ObjectDescriptor &	newLObjectDescription,
		const Name &	fathersLName
	)			[virtual]

create a local object

Reimplemented in OMK::DistributedController.

Definition at line 653 of file OMKController.cpp.

References OMK::SimulatedObject::getName(), getSimulatedDate(), OMK::SystemEventIdentifier::MaskNewLocalObject, and OMK::SimulatedObject::sendEvent().

Referenced by OMK::DistributedController::createLocalObject().

{
  //  cout<<"je suis createObject, fathersName est :"<<fathersName<<endl;
  CreateObjectEvent creationEvent( SystemEventIdentifier::MaskNewLocalObject,
    getSimulatedDate(),
    getName(),
    getName(),
    CreateObjectType( CreateObjectPrm( newLObjectDescription, fathersLName ) ) );
  sendEvent( creationEvent ) ;


}
//----------------------------------

virtual int OMK::Controller::getMirrorsNbre

(

)

[inline, virtual]

Reimplemented in OMK::DistributedController.

Definition at line 107 of file OMKController.h.

{ return 1;};

virtual bool OMK::Controller::isAMirror

(

const Name &

name

)

[inline, virtual]

Reimplemented in OMK::DistributedController.

Definition at line 108 of file OMKController.h.

{ return false ;};

virtual std::vector<Name> OMK::Controller::getMirrorList

(

)

[inline, virtual]

Reimplemented in OMK::DistributedController.

Definition at line 109 of file OMKController.h.

{return std::vector<Name>() ;};

virtual std::vector<Name> OMK::Controller::getIsolatedMirrorList

(

)

[inline, virtual]

Reimplemented in OMK::DistributedController, and OMK::PvmController.

Definition at line 110 of file OMKController.h.

{return std::vector<Name>() ;};

virtual std::vector<Name> OMK::Controller::getNonIsolatedMirrorList

(

)

[inline, virtual]

Reimplemented in OMK::DistributedController, and OMK::PvmController.

Definition at line 111 of file OMKController.h.

{return std::vector<Name>() ;};

virtual bool OMK::Controller::testIfTroubleOccured

(

)

[inline, virtual]

Reimplemented in OMK::DistributedController, and OMK::PvmController.

Definition at line 112 of file OMKController.h.

{return false; } ;

virtual void OMK::Controller::createNewSite

(

const Date &

)

[inline, virtual]

Reimplemented in OMK::DistributedController, and OMK::PvmController.

Definition at line 113 of file OMKController.h.

{} ;

OMK::Controller::DECLARE_TYPE_EVENT	(	MigrationObjectPrm	,
		MigrationObject
	)

void Controller::migrateObjectToProcess	(	Name &	nomObjet,
		Name &	nomProcess
	)

Definition at line 666 of file OMKController.cpp.

References OMK::SimulatedObject::getName(), getSimulatedDate(), OMK::SystemEventIdentifier::MaskMetamorphoseMirToRef, and OMK::SimulatedObject::sendEvent().

{
  // sendValuedEvent( objectName, 
  //               "SystemEventIdentifier::MaskMetamorphoseMirToRef",
  //               MigrationObjectType( MigrationObjectPrm( objectName, processName ) ) ) ;

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


}
//----------------------------------

virtual std::list<Name> OMK::Controller::getDisconnectedProcessusList

(

)

[inline, virtual]

Reimplemented in OMK::PvmController.

Definition at line 117 of file OMKController.h.

{ return std::list<Name> () ;};

virtual std::map<Name, int> OMK::Controller::getDisconnectedProcessusMap

(

)

[inline, virtual]

Reimplemented in OMK::PvmController.

Definition at line 118 of file OMKController.h.

{ return std::map<Name, int> () ;};

Frequency Controller::computeAdequateFrequency

(

const Frequency &

suggestedFrequency

)

[virtual]

compute an adequate Frequency for an object dynamically created Should be used to adapt the desired frequency when an simulated object is dynamically created so that the creation doesn't cause recomputation of the scheduling.

the result is the closest frequency to suggestedFrequency that can be inserted into the scheduler without changing the scheduling data structures. If two frequencies are at the same distance to correct frequencies, the higher frequency will be chosen. note : this member function should be delegated to the scheduler

Definition at line 418 of file OMKController.cpp.

References _stepFrequency, and getCycleFrequency().

Referenced by OMK::DistributedController::getPointerToSimulatedObjectNamed(), processNewObjectDeclaration(), and reactToControlledObjectsSystemEvents().

{
  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::runControllersStep

(

ReferenceObjectHandle *

objectHandle

)

[virtual]

run a controllers simulation step.

To be used by the code controlling the simulation loop (generally run or the interface

• call compute of the objecthandle : therefore
• receive and process all events sent to the controller
• call compute
• increment the simulation date

Definition at line 528 of file OMKController.cpp.

References _computeStatePointer, _forcedCompute, OMK::ReferenceObjectHandle::compute(), OMASSERT, OMK_DEBUG_OMK_EXEC, OMTRACEID, OMK::ReferenceObjectHandle::processEvents(), and OMK::ReferenceObjectHandle::running.

Referenced by run().

{
  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

(

)

[virtual]

computes a new simulation step for all controlled objects, if the controller is in the running state, otherwise jsut react to system events sent to controlled objects

Reimplemented from OMK::SimulatedObject.

Definition at line 546 of file OMKController.cpp.

References advanceSimulatedDate(), computeNextSimulationStep(), getPurgeDate(), and purgeMemoryFromOldEvents().

{
  computeNextSimulationStep();
  purgeMemoryFromOldEvents ( getPurgeDate() ) ;
  advanceSimulatedDate();
}

void Controller::finish

(

)

[virtual]

finish the simulation.

called when MaskStop is received by the controller

Reimplemented from OMK::SimulatedObject.

Reimplemented in OMK::PvmController.

Definition at line 163 of file OMKController.cpp.

References _simulationTree, destroyObject(), OMK::ObjectDescriptor::getSons(), OMASSERT, OMK_DEBUG_OMK_EXEC, and OMTRACEID.

Referenced by OMK::PvmController::finish(), processEvent(), and reactToControlledObjectsSystemEvents().

{
  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 ) ;
  }
}

MultipleConfigurationParameter * Controller::getSchedulingParametersOfObject

(

ObjectDescriptor &

)

[protected]

get a modifiable version of the scheduling parameters of an object.

Defined here for use by derived controllers

Definition at line 1608 of file OMKController.cpp.

References OMK::ObjectDescriptor::getSchedulingParameters().

Referenced by OMK::PvmController::PvmController().

{
  return objectDescription.getSchedulingParameters () ;
}

SimulatedObject * Controller::createDescribedObject

(

const ObjectDescriptor *

description

)

[protected]

createDescribedObject.

Create a simulated object coresponding to the descriptor given as parameter, and update the descriptor accordingly object created are

• to be associated to an objectHandle
• the have deletion responsability transfered to that objectHanle

Definition at line 952 of file OMKController.cpp.

References OMK::ObjectDescriptor::createDescribedObject().

Referenced by OMK::DistributedController::createDuplicatedObject(), OMK::DistributedController::createMirrorObject(), createReferenceObject(), and OMK::DistributedController::getPointerToSimulatedObjectNamed().

{
  SimulatedObject * obj = description->createDescribedObject() ;

  return obj;
}

void Controller::setProcessOfDescriptor	(	ObjectDescriptor &	objectDescription,
		const Name &	newProcessName
	)			[protected, virtual]

Definition at line 1613 of file OMKController.cpp.

References OMK::ObjectDescriptor::setProcess().

Referenced by OMK::PvmController::PvmController().

{
  objectDescription.setProcess ( newProcessName ) ;
}
}

void Controller::error

(

const char *

mess

)

[static]

included for ascendant compatibility : raises a OMKUserException with the message passed as parameter

Parameters:

errorMessage

the message associated to the user exception

Definition at line 1154 of file OMKController.cpp.

Referenced by OMK::SimulatedObject::addInputAlias(), OMK::PvmSvm::addNewWorkstation(), OMK::SimulatedObject::addOutputAlias(), OMK::SimulatedObject::addSensitiveInputAlias(), OMK::SimulatedObject::addSensitiveNotifyingInputAlias(), OMK::KernelObjectAbstractFactory::createControlParameter(), OMK::KernelObjectAbstractFactory::createInput(), OMK::KernelObjectAbstractFactory::createInputAlias(), OMK::KernelObjectAbstractFactory::createOutput(), OMK::KernelObjectAbstractFactory::createOutputAlias(), OMK::KernelObjectAbstractFactory::createSensitiveInput(), OMK::KernelObjectAbstractFactory::createSensitiveInputAlias(), OMK::KernelObjectAbstractFactory::createSensitiveNotifyingInput(), OMK::KernelObjectAbstractFactory::createSensitiveNotifyingInputAlias(), getPointerToDuplicatedObjectNamed(), OMK::ReferenceObjectHandle::insertInStream(), OMK::PvmReferenceObjectHandle::insertInStream(), OMK::PvmController::parseSynchronisationMessage(), and OMK::PvmSvm::spawnProcess().

{
  throw UserException( Errormess ) ;
}

void Controller::showDateAndStepNumber

(

bool

show = true

)

ask the controller to print (or not) to sdterr (cerr) the simulation date and the step number

Parameters:

show

if true information will be printed

Definition at line 1149 of file OMKController.cpp.

References _showDateAndStepNumber.

{
  _showDateAndStepNumber = show ;
}

const Date & Controller::getSimulatedDate

(

)

const [virtual]

Returns a reference to an allways accurate simulation date, in ms.

Reimplemented from OMK::SimulatedObject.

Definition at line 1101 of file OMKController.cpp.

References _date.

Referenced by OMK::ReferenceObjectHandle::compute(), OMK::HumanoRecorder::computeParameters(), createLocalObject(), createObject(), OMK::SimulatedObject::getSimulatedDate(), OMK::Output< T >::localGet(), migrateObjectToProcess(), OMK::PvmController::parseSynchronisationMessage(), OMK::DistributedController::processEvent(), OMK::ReferenceObjectHandle::processEvents(), OMK::Svm::relaxedSynchroniseReceiveAndProcessMessages(), OMK::SimulatedObject::sendEvent(), OMK::PvmMirrorObjectHandle::sendRequestToReferenceObject(), OMK::SimulatedObject::sendValuedEvent(), OMK::Output< T >::suggest(), OMK::Svm::synchroniseReceiveAndProcessMessages(), OMK::PvmMirrorObjectHandle::unpack(), and OMK::PvmController::~PvmController().

{
  return _date;
}

int Controller::getCycleFrequency

(

)

const [virtual]

get the simulation cycle frequency

Definition at line 1112 of file OMKController.cpp.

References _cycleFrequency.

Referenced by computeAdequateFrequency(), computeScheduling(), and init().

{
  return _cycleFrequency ;
}

int Controller::getCyclePeriod

(

)

const [virtual]

get the simulation cycle period, in simulated time (in ms)

Definition at line 1118 of file OMKController.cpp.

References _cyclePeriod.

Referenced by OMK::PvmMirrorObjectHandle::unpack().

{
  return _cyclePeriod ;
}

OMK::Controller::DECLARE_TYPE_EVENT	(	CreateObjectPrm	,
		CreateObject
	)

void Controller::createObject	(	const ObjectDescriptor &	newObjectDescription,
		const Name &	fathersName
	)			[virtual]

creation of an object unknown of in the simulation tree.

this sends an appropriate valued event to the controller, which is interpreted at the next simulation step this interpretation will add the object in the simulation tree, and create it. The object will be inserted in the scheduling data structures with the specified frequency, wich could imply a call to computeScheduling (false) (

See also:

computeScheduling). To avoid this, the frequency specified can be adapted to the actual run-time data structure using computeAdequateFrequency (

computeAdequateFrequency)

Parameters:

	fathersName	the name of the father of the object in the simulation tree
	newObjectDescription	a description of the object to create

Reimplemented in OMK::DistributedController.

Definition at line 641 of file OMKController.cpp.

References OMK::SimulatedObject::getName(), getSimulatedDate(), OMK::SystemEventIdentifier::MaskNewObject, and OMK::SimulatedObject::sendEvent().

Referenced by OMK::DistributedController::createObject().

{
  CreateObjectEvent creationEvent( SystemEventIdentifier::MaskNewObject,
    getSimulatedDate(),
    getName(),
    getName(),
    CreateObjectType( CreateObjectPrm( newObjectDescription, fathersName ) ) );
  sendEvent (creationEvent) ;
}

void Controller::destroyObject	(	const Name &	name,
		bool	recursively
	)			[virtual]

destroy a simulated object.

Delete any data structure related to the specified object, including its description in the simulation tree. Sends MaskStop then MaskDelete to the object, and optionnaly recursively to the sons of the object effective destruction takes place at the next simulation step

Parameters:

	name	: the name of the object to destroy
	recursive	: destroy recursively the sons in the simulation of the specified object

Definition at line 696 of file OMKController.cpp.

References _simulationTree, OMK::ObjectDescriptor::findDescendantNamed(), OMK::ObjectDescriptor::getSons(), OMK::SystemEventIdentifier::MaskDelete, OMK::SystemEventIdentifier::MaskStop, OMASSERT, OMERROR, and OMK::SimulatedObject::sendEvent().

Referenced by finish().

{
  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	(	const Name &	name,
		const Name &	newFather
	)			[virtual]

change the father of an object in the simulation tree.

Effective change at the next simulation step, but doesn't affect the scheduling data structures

Parameters:

	name	: the object which is changing father
	newfather	: the new father of the object

Definition at line 732 of file OMKController.cpp.

References _simulationTree, OMK::ObjectDescriptor::findDescendantNamed(), OMK_DEBUG_OMK_EXEC, OMTRACEID, and OMK::ObjectDescriptor::setFathersDescription().

Referenced by OMK::DistributedController::processEvent(), and processEvent().

{
  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" ) ;
  }
}

void Controller::changeObjectsFather	(	ObjectDescriptor *	object,
		ObjectDescriptor *	newFather
	)			[virtual]

change the father of an object in the simulation tree.

Effective change at the next simulation step, but doesn't affect the scheduling data structures

Parameters:

	object	: the object which is changing father
	newfather	: the new father of the object

Definition at line 723 of file OMKController.cpp.

References OMASSERT, and OMK::ObjectDescriptor::setFathersDescription().

{
  OMASSERT ( object != NULL ) ;
  OMASSERT ( newFather != NULL ) ;
  object->setFathersDescription( newFather ) ;
}

void Controller::computeScheduling

(

bool

fromOriginal

)

[protected, virtual]

compute the scheduling data strucures.

Parameters:

fromOriginal

boolean indiscating if the scheduling has to be computed from the original scheduling information or from the current scheduling information This member function is called when the controller creates its data structures at creation an object with an inadequate frequency is created the new frequency of an object is incompatible with the current scheduling data structures at users demand (send MaskRecomputeScheduling to the controller), to recompute the data structures using the originaly specified frequencies (those existing in the object descriptors, and which could have changed since, or because objects have been deleted or moved inside the simulation tree causing the current data structures to be inefficient or inaccurate

Definition at line 226 of file OMKController.cpp.

References _date, _nbStepsByCycle, _referenceObjectsMap, _scheduler, _simulationTree, _stepFrequency, _stepPeriod, createScheduler(), OMK::SimulatedObject::fireSignal(), gcd(), getCycleFrequency(), OMK::ObjectDescriptor::getDescendants(), OMK::ObjectDescriptor::getFrequency(), OMK::SimulatedObject::getName(), OMK::ObjectDescriptor::getOriginalFrequency(), OMK::SystemEventIdentifier::MaskChangeObjectFrequency, OMK::SystemEventIdentifier::MaskControllerFrequencyChange, OMASSERT, OMK_DEBUG_OMK_EXEC, OMMESSAGE, OMTRACEID, OMK::ReferenceObjectHandle::receiveEvent(), setCycleFrequency(), and OMK::ObjectDescriptor::setFrequency().

Referenced by OMK::DistributedController::getPointerToSimulatedObjectNamed(), init(), processEvent(), processNewObjectDeclaration(), and reactToControlledObjectsSystemEvents().

{
  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() ;

}

void Controller::sendInitialEventsTo	(	ReferenceObjectHandle &	objectHandle,
		const Date &	dateOfMaskStart
	)			[protected, virtual]

Send MaskStart to any created objects, and send any pending events which where stored (none by default) because send to an object before it was created.

Definition at line 831 of file OMKController.cpp.

References _pendingEventsList, OMK::ObjectDescriptor::getFrequency(), OMK::SimulatedObject::getName(), OMK::ObjectDescriptor::getName(), OMK::SimulatedObject::getObjectDescriptor(), OMK::ObjectHandle::getSimulatedObject(), OMK::SystemEventIdentifier::MaskStart, OMK::SystemEventIdentifier::MaskSuspend, OMK_DEBUG_OMK_EXEC, OMTRACEID, and OMK::SimulatedObject::sendEvent().

Referenced by OMK::DistributedController::getPointerToSimulatedObjectNamed(), init(), and processNewObjectDeclaration().

{ 
  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 ) ;
    }
  }
}

void Controller::deleteObject

(

ObjectDescriptor *

objectDescription

)

[protected, virtual]

delete an object.

This member function performs destruction when MaskDelete is received for that object by doing the following

• removes all reference to that object from the controller's data structures
• deletes the object handle, thus delete the simulated object
• deletes the object descriptor

Reimplemented in OMK::DistributedController.

Definition at line 923 of file OMKController.cpp.

References _date, _deletedObjectHandles, OMK::ObjectDescriptor::getFathersObjectDescriptor(), OMK::ObjectDescriptor::getName(), OMK::SimulatedObject::getObjectDescriptor(), OMASSERT, OMK_DEBUG_OMK_EXEC, OMTRACEID, removeObjectFromDataStructures(), and OMK::ObjectDescriptor::removeSon().

Referenced by OMK::DistributedController::deleteObject(), and processDeleteEventOf().

{
  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) ) ;
    }
  }
}

ObjectHandle * Controller::removeObjectFromDataStructures

(

const Name &

)

[protected, virtual]

remove any reference to a simulated object from all the controller's data structures

Returns:

an ObjectHandle that is the last object referencing the simulated object does not act on the simualtion tree

Reimplemented in OMK::PvmController.

Definition at line 883 of file OMKController.cpp.

References _objectsNeedingActivationList.

Referenced by deleteObject(), and OMK::PvmController::removeObjectFromDataStructures().

  {
    _objectsNeedingActivationList[i]->remove( referentiel );
  }

  _listOfObjectsWithPostPonedEvents.remove ( referentiel ) ;

  _referenceObjectsMap.erase(nom);

  _scheduler->unschedule( referentiel ) ;

  _scheduler->removeFromScheduable( referentiel ) ;

  return referentiel;
}

SimulatedObject * Controller::getPointerToDuplicatedObjectNamed

(

const Name &

name

)

[virtual]

get a pointer to a simulated object

Parameters:

name

the name of the object

Returns:

a pointer to a simulated object corresponding to the description given in the simulation tree, NULL if object isn't described

Definition at line 1007 of file OMKController.cpp.

References _referenceObjectsMap, OMK::ObjectDescriptor::DUPLICATED_OBJECT, error(), OMK::Name::getCString(), OMK::ObjectDescriptor::getDistribution(), OMK::SimulatedObject::getObjectDescriptor(), and getPointerToSimulatedObjectNamed().

{
  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 &

name

)

[virtual]

get a pointer to a simulated object After return from this method, it's possible to query any method of the simulated object that doesn't depend on the evolution of that object, as the object returned can have been created specially by the call.

of course, querying the interface of that object (outputs control parameters and event listeners should yield a correct result after a least one simulation step

Parameters:

name

the name of the object

Returns:

a pointer to a simulated object corresponding to the description given in the simulation tree, NULL if object isn't described

Reimplemented in OMK::DistributedController.

Definition at line 1034 of file OMKController.cpp.

References _deletedObjectHandles, _referenceObjectsMap, OMK::SimulatedObject::getName(), and OMK::ObjectHandle::getSimulatedObject().

Referenced by OMK::SimulatedObject::addInputAlias(), OMK::SimulatedObject::addOutputAlias(), OMK::SimulatedObject::addSensitiveInputAlias(), OMK::SimulatedObject::addSensitiveNotifyingInputAlias(), OMK::SimulatedObject::cancelRegistrationForSignalBy(), OMK::OutputNT::connect(), OMK::Input< T >::connect(), OMK::Input< T >::connectToControlParameter(), OMK::SimulatedObject::getFather(), getPointerToDuplicatedObjectNamed(), OMK::EventSignalEmitterUtil::loadParametersUtil(), reactToControlledObjectsSystemEvents(), OMK::Vis::VisBase::registerEventPlug(), OMK::SimulatedObject::registerForSignalBy(), OMK::SimulatedObject::sendEvent(), OMK::SignalDispatcher::sendEventsForSignal(), and OMK::SimulatedObject::sendValuedEvent().

{
  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;
}

void Controller::processNewObjectDeclaration	(	ObjectDescriptor &	declaration,
		const Date &	declarationDate
	)			[protected, virtual]

processNewObjectDeclaration Once an object has been added to the simulation tree, this is called for creation and scheduling

Reimplemented in OMK::DistributedController.

Definition at line 961 of file OMKController.cpp.

References computeAdequateFrequency(), computeScheduling(), createReferenceObject(), OMK::ObjectDescriptor::getFrequency(), OMASSERT, scheduleControlledObjects(), scheduleObject(), and sendInitialEventsTo().

Referenced by processEvent(), and OMK::DistributedController::processNewObjectDeclaration().

{
  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 *

idObjet

)

[protected, virtual]

createReferenceObject.

Effective creation of a reference object

Definition at line 982 of file OMKController.cpp.

References _referenceObjectsMap, createDescribedObject(), createReferenceObjectHandle(), OMK::ObjectDescriptor::getName(), OMASSERT, OMERROR, OMK_DEBUG_OMK_OBJ, and OMTRACEID.

Referenced by OMK::DistributedController::createControlledObjects(), createControlledObjects(), and processNewObjectDeclaration().

{
  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;
}

const ObjectDescriptor & Controller::getObjectDescriptorOfObject

(

const Name &

objectName

)

[virtual]

get the object descriptor of a given simulated object

Parameters:

objectName

the name of the given object

Returns:

the ObjectDescriptor corresponding to that object throw a UserException if a descriptor corresponding to name doesn't exist

Reimplemented in OMK::DistributedController.

Definition at line 1070 of file OMKController.cpp.

References _deletedObjectHandles, _simulationTree, and OMK::ObjectDescriptor::findDescendantNamed().

Referenced by OMK::ParametersAccessor::getAndCheckObject().

{
  // 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 ;
  }
}

int Controller::lcm	(	const int	a,
		const int	b
	)			[static]

Definition at line 1125 of file OMKController.cpp.

Referenced by OMK::Process::Process(), and OMK::PvmController::PvmController().

int Controller::gcd	(	const int	a,
		const int	b
	)			[static]

Definition at line 1129 of file OMKController.cpp.

Referenced by computeScheduling().

                  {
  //     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 ) ;
}

vector< Name > Controller::getReferentielList

(

)

[virtual]

Definition at line 682 of file OMKController.cpp.

References _publicReferentielObjectsVector, and _referenceObjectsMap.

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

  return  _publicReferentielObjectsVector;
}

Scheduler * Controller::createScheduler

(

)

[protected, virtual]

create the scheduler that is in charge of effective scheduling of the controlled objects

Definition at line 361 of file OMKController.cpp.

References _nbStepsByCycle.

Referenced by computeScheduling().

{

  return new FrameScheduler ( _nbStepsByCycle ) ;

}

void Controller::scheduleControlledObjects

(

)

[protected, virtual]

scheduleControlledObjects schedule all controlled reference objects

Definition at line 370 of file OMKController.cpp.

References _referenceObjectsMap, OMK::SimulatedObject::getObjectHandle(), and scheduleObject().

Referenced by OMK::DistributedController::getPointerToSimulatedObjectNamed(), init(), processEvent(), processNewObjectDeclaration(), and reactToControlledObjectsSystemEvents().

{
  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::advanceSimulatedDate

(

)

[protected, virtual]

increment date and numberOfSimulatedSteps

Reimplemented in OMK::PvmController.

Definition at line 613 of file OMKController.cpp.

References _date, _numberOfSimulatedSteps, _showDateAndStepNumber, _stepPeriod, and OMMESSAGE.

Referenced by OMK::PvmController::advanceSimulatedDate(), compute(), and init().

{

  _numberOfSimulatedSteps++;  

  _date = _date + _stepPeriod;  

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

void Controller::createControlledObjects

(

const ObjectDescriptor *

subTree

)

[protected, virtual]

createControlledObjects Create a reference object for all objects of a simulation tree

Reimplemented in OMK::DistributedController.

Definition at line 202 of file OMKController.cpp.

References createReferenceObject(), OMK::ObjectDescriptor::getSons(), OMASSERT, OMK_DEBUG_OMK_OBJ, and OMTRACEID.

Referenced by init().

{
  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::setCycleFrequency

(

int

newFrequency

)

[protected, virtual]

Definition at line 1106 of file OMKController.cpp.

References _cycleFrequency, and _cyclePeriod.

Referenced by computeScheduling().

{
  _cycleFrequency = newFreq ;
  _cyclePeriod = 1000/newFreq ; 
}

void Controller::actOnSystemEvent

(

Event *

event

)

[virtual]

called when a reference object receives a system event

Definition at line 1164 of file OMKController.cpp.

References _currentWritableSystemEventsList, _systemEventsList, actOnSystemEvent(), OMK::Event::clone(), OMK::SimulatedObject::getController(), OMK::SimulatedObject::getName(), OMK::Event::insertInList(), and OMK::Event::receiver.

Referenced by actOnSystemEvent(), and OMK::ReferenceObjectHandle::receiveEvent().

{
  // 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 ) ;
  }
}

void Controller::reactToControlledObjectsSystemEvents

(

)

[virtual]

process system events received by controlled objects

Definition at line 1332 of file OMKController.cpp.

References _currentWritableSystemEventsList, _referenceObjectsMap, _scheduler, _simulationTree, _systemEventsList, computeAdequateFrequency(), computeScheduling(), OMK::Event::eventId, OMK::ObjectDescriptor::findDescendantNamed(), finish(), OMK::ReferenceObjectHandle::getComputingState(), getPointerToSimulatedObjectNamed(), hasEventsToProcess(), OMK::SystemEventIdentifier::MaskChangeObjectFrequency, OMK::SystemEventIdentifier::MaskDelete, OMK::SystemEventIdentifier::MaskRestart, OMK::SystemEventIdentifier::MaskResume, OMK::SystemEventIdentifier::MaskStart, OMK::SystemEventIdentifier::MaskStop, OMK::SystemEventIdentifier::MaskSuspend, noActivationNeededFor(), OMASSERT, OMK_DEBUG_OMK_EVENT, OMK_DEBUG_OMK_EXEC, OMTRACEID, processDeleteEventOf(), OMK::ReferenceObjectHandle::processEvents(), processStartEventOf(), OMK::Event::receiver, OMK::Scheduler::removeFromScheduable(), OMK::ReferenceObjectHandle::running, OMK::Scheduler::schedule(), scheduleControlledObjects(), scheduleObject(), setComputingState(), OMK::ObjectDescriptor::setFrequency(), OMK::ReferenceObjectHandle::stopped, OMK::ReferenceObjectHandle::suspended, switchSystemEventList(), OMK::Scheduler::unschedule(), and OMK::ValuedEvent< UserType >::value.

Referenced by computeNextSimulationStep().

{
  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::processStartEventOf

(

ReferenceObjectHandle *

objectHandle

)

[virtual]

process MaskStart systemEvent for the object with handle

Reimplemented in OMK::DistributedController.

Definition at line 1288 of file OMKController.cpp.

References _scheduler, OMK::ReferenceObjectHandle::getComputingState(), OMK::ReferenceObjectHandle::initial, noActivationNeededFor(), OMK_DEBUG_OMK_EVENT, OMTRACEID, OMK::ReferenceObjectHandle::running, OMK::Scheduler::schedule(), and setComputingState().

Referenced by OMK::DistributedController::processStartEventOf(), and reactToControlledObjectsSystemEvents().

{

  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::processDeleteEventOf

(

ReferenceObjectHandle *

objectHandle

)

[virtual]

process MaskDelete systemEvent for object obj

Definition at line 1321 of file OMKController.cpp.

References deleteObject(), OMK::ReferenceObjectHandle::destroyed, OMK::SimulatedObject::fireValuedSignal(), OMK::ReferenceObjectHandle::getComputingState(), OMK::ObjectDescriptor::getName(), OMK::SimulatedObject::getName(), OMK::SimulatedObject::getObjectDescriptor(), OMK::ObjectHandle::getSimulatedObject(), OMK::SystemEventIdentifier::MaskObjectDestroyed, OMK_DEBUG_OMK_EXEC, OMTRACEID, setComputingState(), and OMK::ReferenceObjectHandle::stopped.

Referenced by reactToControlledObjectsSystemEvents().

{
  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::hasEventsToProcess

(

ReferenceObjectHandle *

referenceObjectHandle

)

[virtual]

add the object handled by referenceObjectHandle to the list of objects having events to process and therefore that need activation (and therefore possibly activated at the current simulation step).

Behaviour is unspecified if the referenceObject is in running state

Parameters:

referenceObjectHandle

objectHandle added

Definition at line 1461 of file OMKController.cpp.

References _currentListOfObjectsNeedingActivation, _date, OMK::ReferenceObjectHandle::_isInObjectNeedingActivationList, OMK::SimulatedObject::_objectHandle, _objectsNeedingActivationList, _stepPeriod, OMK::SimulatedObject::getController(), OMK::SimulatedObject::getName(), OMK::ObjectHandle::getSimulatedObject(), hasEventsToProcess(), OMASSERT, OMK_DEBUG_OMK_EVENT, and OMTRACEID.

Referenced by hasEventsToProcess(), processEventsOfSuspendedObjects(), reactToControlledObjectsSystemEvents(), and OMK::ReferenceObjectHandle::receiveEvent().

{
  // 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 *

referenceObjectHandle

)

[virtual]

add the object described by referenceObjectHandle to the list of object with events to process at the next simulation step.

Definition at line 1489 of file OMKController.cpp.

References _listOfObjectsWithPostPonedEvents.

Referenced by OMK::ReferenceObjectHandle::processEvents().

{
  _listOfObjectsWithPostPonedEvents.push_back(refObjet) ;
}

void Controller::noActivationNeededFor

(

ReferenceObjectHandle *

referenceObjectHandle

)

[virtual]

remove object designated by referenceObjectHandle from the list of object needing activation by the controler because they have events pending.

removal should occur if the reference object is becomming active

Parameters:

referenceObjectHandle

: reference handle of object wich doesn't need acivation any more.

Definition at line 1454 of file OMKController.cpp.

References _currentListOfObjectsNeedingActivation, OMK::ReferenceObjectHandle::_isInObjectNeedingActivationList, _objectsNeedingActivationList, and OMASSERT.

Referenced by processStartEventAfterMorphose(), processStartEventOf(), and reactToControlledObjectsSystemEvents().

{
  _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->remove( refObjet );
  refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = false ;
  OMASSERT ( refObjet->_isInObjectNeedingActivationList[ 1 - _currentListOfObjectsNeedingActivation ] == false );
}

void Controller::addToPendingEvents

(

Event *

)

[virtual]

add the event to the list of pending events.

Responsability for memory occupied by the event is transfered to the controller.

Definition at line 807 of file OMKController.cpp.

References _pendingEventsList, OMK_DEBUG_OMK_EXEC, OMTRACEID, and OMK::Event::receiver.

Referenced by OMK::SimulatedObject::sendEvent(), and OMK::SimulatedObject::sendValuedEvent().

{
  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
  }
}

bool Controller::addToPendingRegistrations	(	const EventIdentifier &	sig,
		const Name &	producer,
		const EventIdentifier &	eventId,
		const Name &	registrant
	)			[virtual]

addToPendingRegistrations.

Add a registration request for an object not created yet

Parameters:

	sig	the signal to register for
	producer	the object producing the signal
	eventId	the event to send if producer fires signal
	registrant	the object registering for sig

Returns:

registration succeeded

Definition at line 756 of file OMKController.cpp.

References _pendingRegistrationRequests.

Referenced by OMK::SimulatedObject::registerForSignalBy().

{
#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
	)			[virtual]

removeFromPendingRegistrations.

Remove a pending registration

Parameters:

	sig	the signal to cancel registration for
	producer	the object producing the signal
	registrant	the object cancelling registration for sig

Returns:

cancellation succeeded

Definition at line 780 of file OMKController.cpp.

References _pendingRegistrationRequests.

Referenced by OMK::SimulatedObject::cancelRegistrationForSignalBy().

{
  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 ;
}

bool Controller::processEvent

(

Event *

)

[virtual]

process events sent to the controller

Reimplemented from OMK::SimulatedObject.

Reimplemented in OMK::DistributedController.

Definition at line 1187 of file OMKController.cpp.

References _computeStatePointer, _forcedCompute, _simulationTree, changeObjectsFather(), computeScheduling(), OMK::Event::date, OMK::ReferenceObjectHandle::destroyed, OMK::Event::eventId, OMK::ObjectDescriptor::findDescendantNamed(), finish(), OMK::SimulatedObject::fireValuedSignal(), OMK::SimulatedObject::getName(), OMK::ObjectDescriptor::getName(), init(), OMK::ReferenceObjectHandle::initial, OMK::SystemEventIdentifier::MaskDelete, OMK::SystemEventIdentifier::MaskNewObject, OMK::SystemEventIdentifier::MaskObjectCreated, OMK::SystemEventIdentifier::MaskRecomputeScheduling, OMK::SystemEventIdentifier::MaskRestart, OMK::SystemEventIdentifier::MaskResume, OMK::SystemEventIdentifier::MaskStart, OMK::SystemEventIdentifier::MaskStop, OMK::SystemEventIdentifier::MaskSuspend, OMASSERT, OMK_DEBUG_OMK_EXEC, OMTRACEID, processNewObjectDeclaration(), OMK::ReferenceObjectHandle::running, scheduleControlledObjects(), OMK::ReferenceObjectHandle::stopped, and OMK::ReferenceObjectHandle::suspended.

Referenced by OMK::DistributedController::processEvent().

{
  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::processEventsOfSuspendedObjects

(

)

[virtual]

call processEvent for suspended objects having received events

Definition at line 1494 of file OMKController.cpp.

References _currentListOfObjectsNeedingActivation, _date, OMK::ReferenceObjectHandle::_isInObjectNeedingActivationList, _listOfObjectsWithPostPonedEvents, _objectsNeedingActivationList, hasEventsToProcess(), OMK_DEBUG_OMK_EVENT, OMTRACEID, and OMK::ReferenceObjectHandle::processEvents().

Referenced by computeNextSimulationStep().

{   
  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 ) ;
}

void Controller::broadcastEventsForSignal	(	Event &	event,
		const EventIdentifier &	sigId
	)			[virtual]

broadcast events corresponding to a fired signal

Parameters:

	sigId	the signal fired
	event	the event prototype to send to registered objects

Reimplemented in OMK::DistributedController.

Definition at line 1546 of file OMKController.cpp.

References _controledObjectsSignalsDispatcher, OMK_DEBUG_OMK_EVENT, OMTRACEID, and OMK::SignalDispatcher::sendEventsForSignal().

Referenced by OMK::DistributedController::broadcastEventsForSignal(), OMK::SimulatedObject::fireSignal(), OMK::SimulatedObject::fireValuedSignal(), and OMK::ReferenceObjectHandle::sendEventsForSignal().

{
  OMTRACEID( OMK_DEBUG_OMK_EVENT, "Controller::broadcastEventsForSignal \"" << sigId << "\"" ) ;
  _controledObjectsSignalsDispatcher.sendEventsForSignal( event , sigId ) ;
}

bool Controller::receiveRegistrationForSignal	(	const EventIdentifier &	sigId,
		const Name &	registrant,
		const EventIdentifier &	eventId
	)			[virtual]

register an object for a signal

Parameters:

	sigId	the signal to react to
	registrant	the simulated object registering to signal sigId
	eventId	the eventId to send to registrant when sigId is emitted

Reimplemented in OMK::DistributedController.

Definition at line 1553 of file OMKController.cpp.

References _controledObjectsSignalsDispatcher, OMK_DEBUG_OMK_EVENT, OMTRACEID, and OMK::SignalDispatcher::registerForSignal().

Referenced by OMK::SimulatedObject::registerForSignal().

{
  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
	)			[virtual]

cancel the registration of an object for a signal

Parameters:

	sigId	the signal for wich there is a cancellation
	registrant	the object cancelling registration

Reimplemented in OMK::DistributedController.

Definition at line 1564 of file OMKController.cpp.

References _controledObjectsSignalsDispatcher, and OMK::SignalDispatcher::cancelRegistrationForSignal().

Referenced by OMK::SimulatedObject::cancelRegistrationForSignal().

{
  return _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (sigId , registrant) ;
}

void Controller::setComputingState	(	ReferenceObjectHandle *	,
		ReferenceObjectHandle::SimulatedObjectComputingState
	)			const [protected, virtual]

change the computing state of a reference object handle

Definition at line 1601 of file OMKController.cpp.

References OMK::ReferenceObjectHandle::_computingState.

Referenced by processDeleteEventOf(), processStartEventAfterMorphose(), OMK::DistributedController::processStartEventOf(), processStartEventOf(), and reactToControlledObjectsSystemEvents().

{
  handle->_computingState = state ;
}

void Controller::switchSystemEventList

(

)

[protected, virtual]

switch buffer of List Of Objects Needing Activation

Definition at line 1159 of file OMKController.cpp.

References _currentWritableSystemEventsList.

Referenced by reactToControlledObjectsSystemEvents().

{
  _currentWritableSystemEventsList = 1 - _currentWritableSystemEventsList ;
}

void Controller::purgeMemoryFromOldEvents

(

const Date &

dateOfOldestKept

)

[protected, virtual]

the method used to purge the data structures from all outdated kepts events.

For example, an event sent to an uncreated object would be purged if no object claims the event

Reimplemented in OMK::DistributedController.

Definition at line 561 of file OMKController.cpp.

References _deletedObjectHandles, _pendingEventsList, deleteObjectHandle(), OMK_DEBUG_OMK_EXEC, and OMTRACEID.

Referenced by compute(), OMK::DistributedController::purgeMemoryFromOldEvents(), and ~Controller().

{
  // 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 ;
    }
  }
}

Date Controller::getPurgeDate

(

)

[protected, virtual]

get the date of the oldest event not purged by purgeMemoryFromOldEvents

Reimplemented in OMK::PvmController.

Definition at line 555 of file OMKController.cpp.

References _date, and _stepPeriod.

Referenced by compute(), and OMK::PvmController::getPurgeDate().

{
  return _date - _stepPeriod ;
}

int Controller::getOutputHistorySize

(

void

)

[protected, virtual]

get the minimum history length pertinant for this controller The value returned is the value of the environement variable MaskHISTORYLENGTH, or a default value calculated so that get(-4 dt) return an exact value if it has been produced

Reimplemented in OMK::PvmController.

Definition at line 1527 of file OMKController.cpp.

Referenced by createControlParameter(), createOutput(), createOutputAlias(), and OMK::PvmController::getOutputHistorySize().

  {
    result = _nbStepsByCycle*4+1 ;
  }
  else 
  {
    result = atoi (environementValue) ;
  }
  return result ;
}  

ReferenceObjectHandle * Controller::createReferenceObjectHandle

(

SimulatedObject &

obj

)

[protected, virtual]

create a reference object handler appropriate for this controller

Parameters:

obj

the object to handle the reference object created

Definition at line 1581 of file OMKController.cpp.

References _pendingRegistrationRequests, OMK::SimulatedObject::getName(), newOMKReferenceObjectHandle(), OMK_DEBUG_OMK_OBJ, and OMTRACEID.

Referenced by Controller(), createReferenceObject(), and OMK::DistributedController::processEvent().

{
  /* 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 ;
}

ReferenceObjectHandle * Controller::newOMKReferenceObjectHandle	(	SimulatedObject &	object,
		Controller &	controller,
		SignalDispatcher *	signalDispatcher
	)			[protected, virtual]

The controller is an abstract factory for reference object handles.

Parameters:

	obj	the object to handle
	controller	the controller of that object
	the	signal dispatche used by that object the reference object created

Reimplemented in OMK::PvmController.

Definition at line 1572 of file OMKController.cpp.

Referenced by createReferenceObjectHandle().

{
  return new ReferenceObjectHandle(object, controller, signalDispatcher) ;
}

void Controller::deleteObjectHandle

(

ObjectHandle *

objectHandle

)

[protected, virtual]

as the controller is an abstract factory for object handlers, is should also be an abstract destroyer

Definition at line 905 of file OMKController.cpp.

References OMK::ObjectDescriptor::_pointerToSimulatedObject, OMK::ObjectDescriptor::getName(), OMK::SimulatedObject::getObjectDescriptor(), OMK::ObjectHandle::getSimulatedObject(), OMK_DEBUG_OMK_EXEC, and OMTRACEID.

Referenced by OMK::DistributedController::processEvent(), and purgeMemoryFromOldEvents().

{

  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;
  }
}

bool Controller::setKernelObjectFactory

(

KernelObjectAbstractFactory *

aFactory

)

[static]

set the kernelObjectfactory for the controller of this adressing space is only effective once for each adress space to be called before creation of the controller to be effective return : change effective

Definition at line 42 of file OMKController.cpp.

References kernelObjectFactory.

{
  if ( kernelObjectFactory != NULL ) 
  {
    kernelObjectFactory = aFactory ;
    return true ;
  }
  else 
  {
    return false ;
  }
}

KernelObjectAbstractFactory * Controller::getKernelObjectFactory

(

)

[static]

get the active kernelObjectFactory

Definition at line 55 of file OMKController.cpp.

References kernelObjectFactory.

Referenced by createControlParameter(), createInput(), createInputAlias(), createOutput(), createOutputAlias(), createSensitiveInput(), createSensitiveInputAlias(), createSensitiveNotifyingInput(), and createSensitiveNotifyingInputAlias().

{
  if ( kernelObjectFactory == NULL ) 
  {
    kernelObjectFactory = new KernelObjectClassicFactory () ;
  }

  return kernelObjectFactory ;
}

template<typename Type>

Input< Type > * OMK::Controller::createInput	(	const Name &	name,
		SimulatedObject &	owner,
		bool	makeConnectable,
		int	requestedPrecisionLevel
	)			[inline]

create an input

Parameters:

	t	the type of input created
	name	the name of the input created
	owner	the owner of the input
	requestedPrecisionLevel	the polation level that willl be used by that input

Returns:

the requested input

Definition at line 725 of file OMKController.h.

References getKernelObjectFactory().

{
  return getKernelObjectFactory ()->template createInput<Type> (name,owner,makeConnectable,requestedPrecisionLevel);
}

template<typename Type>

SensitiveInput< Type > * OMK::Controller::createSensitiveInput	(	const Name &	name,
		SimulatedObject &	owner,
		bool	makeConnectable,
		int	requestedPrecisionLevel
	)			[inline]

create a sensitive input

Parameters:

	t	the type of sensitive input created
	name	the name of the sensitive input created
	owner	the owner of the sensitive input
	requestedPrecisionLevel	the polation level that willl be used by that input

Returns:

the requested sensitive input

Definition at line 742 of file OMKController.h.

References getKernelObjectFactory().

{
  return getKernelObjectFactory ()->template createSensitiveInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);
}

template<typename Type>

SensitiveNotifyingInput< Type > * OMK::Controller::createSensitiveNotifyingInput	(	const Name &	name,
		SimulatedObject &	owner,
		bool	makeConnectable,
		int	requestedPrecisionLevel
	)			[inline]

create a sensitive notifying input

Parameters:

	t	the type of sensitive notifying input created
	name	the name of the sensitive notifying input created
	owner	the owner of the sensitive notifying input
	requestedPrecisionLevel	the polation level that willl be used by that sensitive notifying input

Returns:

the requested sensitive notifying input

Definition at line 758 of file OMKController.h.

References getKernelObjectFactory().

{
  return getKernelObjectFactory ()->template createSensitiveNotifyingInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);
}

template<typename Type>

Output< Type > * OMK::Controller::createOutput	(	const Name &	name,
		SimulatedObject &	owner,
		OMK::Type::PolatorNT *	polator
	)			[inline]

create an ouput

Parameters:

	t	the type of the output created
	name	the name of the output created
	owner	the owner of the output
	polator	the associated polator

Returns:

the requested output

Definition at line 775 of file OMKController.h.

References getKernelObjectFactory(), and getOutputHistorySize().

{
  return getKernelObjectFactory ()->template createOutput<Type>(name,owner,getOutputHistorySize(),polator);
}

template<typename Type>

ControlParameter< Type > * OMK::Controller::createControlParameter	(	const Name &	name,
		SimulatedObject &	owner,
		OMK::Type::PolatorNT *	polator
	)			[inline]

create a control parameter

Parameters:

	t	the type of the control parameter created
	name	the name of the control parameter created
	owner	the owner of the control parameter

Returns:

the requested control parameter

Definition at line 790 of file OMKController.h.

References getKernelObjectFactory(), and getOutputHistorySize().

{
  return getKernelObjectFactory ()->template createControlParameter<Type>(name,owner,getOutputHistorySize(),polator);
}

template<typename Type>

InputAlias< Type > * OMK::Controller::createInputAlias	(	const Name &	name,
		SimulatedObject &	owner,
		AbstractInput< Type > *	input,
		int	requestedPrecisionLevel
	)			[inline]

create an input alias

Parameters:

	t	the type of input alias created
	name	the name of the input alias created
	owner	the owner of the input alias
	input	the aliased input
	requestedPrecisionLevel	the polation level that willl be used by that input alias

Returns:

the requested input

Definition at line 807 of file OMKController.h.

References getKernelObjectFactory().

{   
  return getKernelObjectFactory ()->template createInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
}

template<typename Type>

SensitiveInputAlias< Type > * OMK::Controller::createSensitiveInputAlias	(	const Name &	name,
		SimulatedObject &	owner,
		AbstractInput< Type > *	input,
		int	requestedPrecisionLevel
	)			[inline]

create a sensitive input alias

Parameters:

	t	the type of sensitive input alias created
	name	the name of the sensitive input alias created
	owner	the owner of the sensitive input alias
	input	the aliased input
	requestedPrecisionLevel	the polation level that willl be used by that sensitive input alias

Returns:

the requested sensitive input

Definition at line 825 of file OMKController.h.

References getKernelObjectFactory().

{
  return getKernelObjectFactory ()->template createSensitiveInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
}

template<typename Type>

SensitiveNotifyingInputAlias< Type > * OMK::Controller::createSensitiveNotifyingInputAlias	(	const Name &	name,
		SimulatedObject &	owner,
		AbstractInput< Type > *	input,
		int	requestedPrecisionLevel
	)			[inline]

create a sensitive notifying input alias

Parameters:

	t	the type of sensitive notifying input alias created
	name	the name of the sensitive notifying input alias created
	owner	the owner of the sensitive notifying input alias
	input	the aliased input
	requestedPrecisionLevel	the polation level that willl be used by that sensitive notifying input alias

Returns:

the requested sensitive notifying input

Definition at line 843 of file OMKController.h.

References getKernelObjectFactory().

{   
  return getKernelObjectFactory ()->template createSensitiveNotifyingInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
}

template<typename Type>

OutputAlias< Type > * OMK::Controller::createOutputAlias	(	const Name &	name,
		SimulatedObject &	owner,
		Output< Type > *	output,
		OMK::Type::PolatorNT *	polator
	)			[inline]

create an ouput alias

Parameters:

	t	the type of the output alias created
	name	the name of the output alias created
	owner	the owner of the output alias
	output	the aliased output
	polator	the associated polator

Returns:

the requested output alias

Definition at line 861 of file OMKController.h.

References getKernelObjectFactory(), and getOutputHistorySize().

{
  return getKernelObjectFactory ()->template createOutputAlias<Type>(name,owner,output,getOutputHistorySize(),polator);
}

---

Friends And Related Function Documentation

friend class InputNT [friend]

Reimplemented from OMK::SimulatedObject.

Definition at line 264 of file OMKController.h.

friend class OMK::SimulatedObject [friend]

Definition at line 265 of file OMKController.h.

---

Member Data Documentation

Date Controller::initialSimulationDate [static]

date at which simulation was initialised

Definition at line 168 of file OMKController.h.

Referenced by OMK::PvmController::advanceSimulatedDate(), Controller(), init(), OMK::SimulatedObject::insertInStream(), OMK::SimulatedObject::pack(), and OMK::ReferenceObjectHandle::ReferenceObjectHandle().

std::vector<Name> OMK::Controller::_publicReferentielObjectsVector

CHADI.

Definition at line 292 of file OMKController.h.

Referenced by getReferentielList().

NameToPointerMap<ReferenceObjectHandle> OMK::Controller::_referenceObjectsMap [protected]

data structure containing references to the ReferenceObjectHandlers

Definition at line 315 of file OMKController.h.

Referenced by OMK::PvmController::computeNextSimulationStep(), computeScheduling(), OMK::DistributedController::createDuplicatedObject(), createReferenceObject(), OMK::DistributedController::dispatchEvent(), getPointerToDuplicatedObjectNamed(), OMK::DistributedController::getPointerToSimulatedObjectNamed(), getPointerToSimulatedObjectNamed(), getReferentielList(), init(), OMK::PvmController::parseSynchronisationMessage(), OMK::DistributedController::processEvent(), reactToControlledObjectsSystemEvents(), OMK::PvmController::removeObjectFromDataStructures(), OMK::PvmController::run(), scheduleControlledObjects(), and OMK::PvmController::sendInitialValuesToMirror().

ObjectDescriptor& OMK::Controller::_simulationTree [protected]

the simulation tree this controller is root of This has to be a reference to a allready constructed simulation tree, because the root descriptor of that tree is used a parameter of the ancestors constructor wich keeps a reference of that descriptor.

Therefore, problems will arise if _simulationTree is a copy

Definition at line 320 of file OMKController.h.

Referenced by changeObjectsFather(), computeScheduling(), Controller(), destroyObject(), finish(), OMK::DistributedController::getObjectDescriptorOfObject(), getObjectDescriptorOfObject(), OMK::DistributedController::getPointerToSimulatedObjectNamed(), init(), OMK::DistributedController::processEvent(), processEvent(), OMK::PvmController::PvmController(), and reactToControlledObjectsSystemEvents().

unsigned long int OMK::Controller::_numberOfSimulatedSteps [protected]

number of simulated steps up to now

Definition at line 323 of file OMKController.h.

Referenced by advanceSimulatedDate(), and computeNextSimulationStep().

Frequency OMK::Controller::_stepFrequency [protected]

frequency of a simulation step

Definition at line 328 of file OMKController.h.

Referenced by computeAdequateFrequency(), computeScheduling(), and init().

int OMK::Controller::_cycleFrequency [protected]

the frequency at wich activation patterns repeat themselves

Definition at line 331 of file OMKController.h.

Referenced by getCycleFrequency(), and setCycleFrequency().

int OMK::Controller::_cyclePeriod [protected]

duration in simulated time of a simualtion cycle

Definition at line 334 of file OMKController.h.

Referenced by getCyclePeriod(), and setCycleFrequency().

int OMK::Controller::_nbStepsByCycle [protected]

number of simulation step by cycle : we have _cycleFrequency * stepFrequency = _nbStepsByCycle

Definition at line 338 of file OMKController.h.

Referenced by computeScheduling(), and createScheduler().

int OMK::Controller::_stepPeriod [protected]

_stepPeriod.

Duration in simulated time of a simulated step

Definition at line 343 of file OMKController.h.

Referenced by advanceSimulatedDate(), computeScheduling(), OMK::PvmController::getOutputHistorySize(), getPurgeDate(), hasEventsToProcess(), init(), OMK::PvmController::run(), ~Controller(), and OMK::DistributedController::~DistributedController().

Date OMK::Controller::_date [protected]

simulated date

Definition at line 346 of file OMKController.h.

Referenced by OMK::PvmController::advanceSimulatedDate(), advanceSimulatedDate(), OMK::DistributedController::broadcastEventsForSignal(), computeScheduling(), OMK::DistributedController::deleteObject(), deleteObject(), OMK::DistributedController::getPointerToSimulatedObjectNamed(), getPurgeDate(), getSimulatedDate(), hasEventsToProcess(), OMK::PvmController::init(), init(), OMK::PvmController::makeSynchronisationMessage(), processEventsOfSuspendedObjects(), OMK::DistributedController::receiveCancellationForSignal(), OMK::DistributedController::receiveRegistrationForSignal(), OMK::PvmController::run(), OMK::PvmController::sendInitialValuesToMirror(), ~Controller(), and OMK::DistributedController::~DistributedController().

bool OMK::Controller::_showDateAndStepNumber [protected]

flag indicating if the date and simulation step number are printed

Definition at line 349 of file OMKController.h.

Referenced by advanceSimulatedDate(), and showDateAndStepNumber().

ReferenceObjectHandle::SimulatedObjectComputingState* OMK::Controller::_computeStatePointer [protected]

a pointer for easy access to th computationnel state of the controller : if the controller is controlling itsekg, this computationnal state should be : running

Definition at line 352 of file OMKController.h.

Referenced by Controller(), processEvent(), OMK::PvmController::PvmController(), run(), and runControllersStep().

SignalDispatcher OMK::Controller::_controledObjectsSignalsDispatcher [protected]

signal dispatcher for objects interested in a signal whatever it's producer

Definition at line 439 of file OMKController.h.

Referenced by broadcastEventsForSignal(), OMK::DistributedController::processEvent(), receiveCancellationForSignal(), and receiveRegistrationForSignal().

bool OMK::Controller::_forcedCompute [protected]

to enable computations even in suspendedState, when the controller is controlled

Definition at line 446 of file OMKController.h.

Referenced by processEvent(), and runControllersStep().

Scheduler* OMK::Controller::_scheduler [protected]

the scheduler

Definition at line 449 of file OMKController.h.

Referenced by computeNextSimulationStep(), computeScheduling(), OMK::DistributedController::processEvent(), processStartEventAfterMorphose(), processStartEventOf(), reactToControlledObjectsSystemEvents(), and ~Controller().

std::list<ReferenceObjectHandle *>* OMK::Controller::_objectsNeedingActivationList[2] [protected]

double buffered list of controlled object needing activation because they have received events Protect usage with _mutexForListEvt ;

Definition at line 454 of file OMKController.h.

Referenced by Controller(), hasEventsToProcess(), noActivationNeededFor(), processEventsOfSuspendedObjects(), removeObjectFromDataStructures(), and ~Controller().

int OMK::Controller::_currentListOfObjectsNeedingActivation [protected]

1 - _currentListOfObjectsNeedingActivation is used to store new object needing activation

Definition at line 457 of file OMKController.h.

Referenced by Controller(), hasEventsToProcess(), noActivationNeededFor(), and processEventsOfSuspendedObjects().

std::list<Event *>* OMK::Controller::_systemEventsList[2] [protected]

double buffered system event list

Definition at line 463 of file OMKController.h.

Referenced by actOnSystemEvent(), Controller(), reactToControlledObjectsSystemEvents(), and ~Controller().

unsigned int OMK::Controller::_currentWritableSystemEventsList [protected]

_systemEventsList[_currentWritableSystemEventsList] is used to store system events sent to controlled objects

Definition at line 466 of file OMKController.h.

Referenced by actOnSystemEvent(), Controller(), reactToControlledObjectsSystemEvents(), and switchSystemEventList().

std::list<ReferenceObjectHandle * > OMK::Controller::_listOfObjectsWithPostPonedEvents [protected]

list of objects with postponed events

Definition at line 469 of file OMKController.h.

Referenced by postponeEventProcessing(), and processEventsOfSuspendedObjects().

std::map<Name, std::list<Event *> > OMK::Controller::_pendingEventsList [protected]

list of pending events (events sent to unknown objects)

Definition at line 476 of file OMKController.h.

Referenced by addToPendingEvents(), OMK::DistributedController::processNewObjectDeclaration(), purgeMemoryFromOldEvents(), and sendInitialEventsTo().

std::map<Name, SignalDispatcher *> OMK::Controller::_pendingRegistrationRequests [protected]

map of pending registration requests

Definition at line 484 of file OMKController.h.

Referenced by addToPendingRegistrations(), createReferenceObjectHandle(), removeFromPendingRegistrations(), and ~Controller().

std::list<std::pair <Date, ObjectHandle *> > OMK::Controller::_deletedObjectHandles [protected]

the list of recently deleted object handles.

Deleted objects pass through purge because

• objects reacting to MaskObjectDestroyed might attempt to access the objects
• they should pass through purge in a distributed context

Definition at line 496 of file OMKController.h.

Referenced by deleteObject(), getObjectDescriptorOfObject(), getPointerToSimulatedObjectNamed(), purgeMemoryFromOldEvents(), and OMK::PvmController::sendInitialValuesToMirror().

KernelObjectAbstractFactory * Controller::kernelObjectFactory [static, private]

the kernel object factory used to create attribute of controlled object

Definition at line 658 of file OMKController.h.

Referenced by getKernelObjectFactory(), and setKernelObjectFactory().

---