---

PsController.h

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#ifndef PsControllerHEADER
#define PsControllerHEADER


#include <Psn.h>
#include <PsNameToPointerMap.h>

class PsnDoubleList;

class PsName;
#include <PsSimulatedObject.h>
class PsObjectDescriptor;
class PsDuplicatedObject;
#include <PsnReferenceObjectHandle.h>
class PsnMirrorObjectHandle;
class PsnProcess;
template <typename Type> class PsAbstractInput;
class PsnScheduler ;
class PsnSemaphore ;
class PsMultipleConfigurationParameter ;
#include <PsKernelObjectAbstractFactory.h>
#include "PsnSignalDispatcher.h"

class PsController : public PsSimulatedObject
{
public:
   PsController(PsObjectDescriptor & simulationTree,
                const PsDate & initialDate);


   virtual ~PsController();

   /* Init
    * send MaskStart to all initial objects 
    */
   virtual void init();

   virtual void run();

   template <typename Type> list<const PsObjectDescriptor *> * listDescendantsOfType(const PsName & objectName)
   {
      const PsObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ;
      if ( objectDescriptor != NULL )
         {
            return objectDescriptor->template listDescendantsOfType<Type> () ; 
         }
      else
         {
            return new list<const PsObjectDescriptor *>() ;
         }
   }

   template <typename Type> list<const PsObjectDescriptor * > * listBrothersOfType (const PsName objectName)
   {
      const PsObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ;
      if ( objectDescriptor != NULL )
         {
            objectDescriptor = objectDescriptor->getFathersDescriptor() ;
            if ( objectDescriptor != NULL )
               {
                  return objectDescriptor->template listBrothersOfType<Type> () ; 
               }
            else
               {
                  return new list<const PsObjectDescriptor *>() ;
               }
         }
      else
         {
            return new list<const PsObjectDescriptor *>() ;
         }
   }

protected:   
   virtual void computeNextSimulationStep();

   virtual void scheduleObject(PsnReferenceObjectHandle * ref);

public:
   virtual PsFrequency computeAdequateFrequency(const PsFrequency & suggestedFrequency);

   virtual void runControllersStep(PsnReferenceObjectHandle * objectHandle);

   virtual void compute();

   virtual void finish() ;
protected:
   PsMultipleConfigurationParameter * getSchedulingParametersOfObject(PsObjectDescriptor &) ;


   PsSimulatedObject * createDescribedObject(const PsObjectDescriptor * description);

   virtual void setProcessOfDescriptor ( PsObjectDescriptor & objectDescription, const PsName & newProcessName ) ;
public:
   static void error (const char * mess) ;


   static PsDate initialSimulationDate ;


   void showDateAndStepNumber(bool show = true);


   virtual const PsDate & getSimulatedDate () const ;


   virtual int getCycleFrequency() const ;


   virtual int getCyclePeriod() const ;

   virtual void createObject(const PsObjectDescriptor & newObjectDescription, const PsName & fathersName);

   
   virtual void destroyObject(const PsName & name, bool recursively);


   virtual void changeObjectsFather(const PsName & name , const PsName & newFather) ;


   virtual void changeObjectsFather(PsObjectDescriptor * object, PsObjectDescriptor * newFather) ;

protected:                                         
   virtual void computeScheduling (bool fromOriginal) ;


   virtual void sendInitialEventsTo ( PsnReferenceObjectHandle & objectHandle, const PsDate & dateOfMaskStart) ;


   virtual void deleteObject(PsObjectDescriptor * objectDescription);
   

   virtual PsnObjectHandle * removeObjectFromDataStructures(const PsName &);


public:
 
   virtual PsDuplicatedObject * getPointerToDuplicatedObjectNamed (const PsName & name);


   virtual PsSimulatedObject * getPointerToSimulatedObjectNamed (const PsName & name);

protected:
   friend class PsInputNT;
   friend class PsSimulatedObject;

   virtual void processNewObjectDeclaration ( PsObjectDescriptor & declaration, const PsDate & declarationDate ) ;

   virtual PsnReferenceObjectHandle * createReferenceObject (const PsObjectDescriptor * idObjet);
      
public:   
  virtual const PsObjectDescriptor & getObjectDescriptorOfObject(const PsName & objectName) ;


  // calculate least common multiplier
  static int lcm (const int a, const int b) ;


  // calculate greatest common divisor
  static int gcd (const int a, const int b) ;


protected:
   virtual PsnScheduler * createScheduler() ;
   
  virtual void scheduleControlledObjects();


  virtual void advanceSimulatedDate();


  virtual void createControlledObjects(const PsObjectDescriptor * subTree);
   
   
   PsNameToPointerMap<PsnReferenceObjectHandle> _referenceObjectsMap ;

   
   PsObjectDescriptor & _simulationTree;
   

   unsigned long int _numberOfSimulatedSteps;
   
   virtual void setCycleFrequency(int newFrequency) ;
   
   PsFrequency _stepFrequency;
      
   int _cycleFrequency; 

   int _cyclePeriod ;

   int _nbStepsByCycle;

   int _stepPeriod;


   PsDate _date;
      

   bool _showDateAndStepNumber;
   

   PsnReferenceObjectHandle::SimulatedObjectComputingState * _computeStatePointer ;
      

public: 
   virtual void actOnSystemEvent ( PsEvent * event ) ;

   
   virtual void reactToControlledObjectsSystemEvents();


   virtual void processStartEventOf(PsnReferenceObjectHandle * objectHandle);


   virtual void processDeleteEventOf(PsnReferenceObjectHandle * objectHandle);


   virtual void hasEventsToProcess(PsnReferenceObjectHandle * referenceObjectHandle);


   virtual void postponeEventProcessing ( PsnReferenceObjectHandle * referenceObjectHandle );

   
   virtual void noActivationNeededFor ( PsnReferenceObjectHandle * referenceObjectHandle ) ;


   virtual void addToPendingEvents( PsEvent * ) ;


   virtual bool addToPendingRegistrations(const PsEventIdentifier & sig, 
                                          const PsName & producer,
                                          const PsEventIdentifier & eventId,
                                          const PsName & registrant) ;


   virtual bool removeFromPendingRegistrations ( const PsEventIdentifier & sig,
                                                 const PsName & producer,
                                                 const PsName & registrant ) ;

   virtual bool processEvent(PsEvent *);


   virtual void processEventsOfSuspendedObjects();


   virtual void broadcastEventsForSignal (PsEvent & event, const PsEventIdentifier & sigId);


   virtual bool receiveRegistrationForSignal(const PsEventIdentifier & sigId, 
                                  const PsName & registrant, 
                                  const PsEventIdentifier & eventId);


   virtual bool receiveCancellationForSignal ( const PsEventIdentifier & sigId , 
                                              const PsName & registrant ) ;
protected:
   PsnSignalDispatcher _controledObjectsSignalsDispatcher ;

   virtual void setComputingState(PsnReferenceObjectHandle * , PsnReferenceObjectHandle::SimulatedObjectComputingState ) const ;
     
protected:
   bool _forcedCompute ;

   PsnScheduler * _scheduler ;

   list<PsnReferenceObjectHandle *> * _objectsNeedingActivationList [2]; 

   int _currentListOfObjectsNeedingActivation ;

   virtual void switchSystemEventList() ;

   list <PsEvent *> *  _systemEventsList [ 2 ] ;

   unsigned int _currentWritableSystemEventsList ;

   list <PsnReferenceObjectHandle * > _listOfObjectsWithPostPonedEvents ;

   PsnMutexLock _mutexSystemEventsList ;

   map <PsName, list<PsEvent *> > _pendingEventsList ;

   PsnMutexLock _mutexPendingDataStructures ;
 
   map <PsName, PsnSignalDispatcher *> _pendingRegistrationRequests ;

   virtual void purgeMemoryFromOldEvents ( const PsDate & dateOfOldestKept ) ;

   virtual PsDate getPurgeDate() ; 


   list <pair <PsDate, PsnObjectHandle *> > _deletedObjectHandles ;

protected:
   //PsnReferenceObjectHandle * _objectHandle ;

  virtual int getOutputHistorySize(void) ;


   virtual PsnReferenceObjectHandle * createReferenceObjectHandle(PsSimulatedObject & obj);

   virtual PsnReferenceObjectHandle * newPsnReferenceObjectHandle(PsSimulatedObject & object, 
                                                                  PsController & controller,
                                                                  PsnSignalDispatcher * signalDispatcher);

   virtual void deleteObjectHandle ( PsnObjectHandle * objectHandle ) ;

public:
   static bool setKernelObjectFactory ( PsKernelObjectAbstractFactory * aFactory ) ; 

   static PsKernelObjectAbstractFactory * getKernelObjectFactory () ;


   template <typename Type>
   PsInput<Type> * createInput(const PsName & name, 
                               PsSimulatedObject & owner,
                               bool makeConnectable,
                               int requestedPrecisionLevel) 
   {
      return getKernelObjectFactory ()->template createInput<Type> (name,owner,makeConnectable,requestedPrecisionLevel);
   }


   template <typename Type>
   PsSensitiveInput<Type> * createSensitiveInput( const PsName & name, 
                                                  PsSimulatedObject & owner,
                                                  bool makeConnectable,
                                                  int requestedPrecisionLevel) 
   {
      return getKernelObjectFactory ()->template createSensitiveInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);
   }


   template <typename Type>
   PsSensitiveNotifyingInput<Type> * createSensitiveNotifyingInput( const PsName & name, 
                                                                    PsSimulatedObject & owner,
                                                                    bool makeConnectable,
                                                                    int requestedPrecisionLevel) 
   {
      return getKernelObjectFactory ()->template createSensitiveNotifyingInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);
   }


  template <typename Type>
  PsOutput<Type> * createOutput(const PsName & name, 
                                PsSimulatedObject & owner,
                                PsPolatorNT * polator) 
   {
      return getKernelObjectFactory ()->template createOutput<Type>(name,owner,getOutputHistorySize(),polator);
   }


   template <typename Type>
   PsControlParameter<Type> * createControlParameter( const PsName & name, 
                                                      PsSimulatedObject & owner,
                                                      PsPolatorNT * polator) 
   {
      return getKernelObjectFactory ()->template createControlParameter<Type>(name,owner,getOutputHistorySize(),polator);
   }


  template <typename Type>
  PsInputAlias<Type> * createInputAlias(const PsName & name, 
                                        PsSimulatedObject & owner,
                                        PsAbstractInput<Type> * input,
                                        int requestedPrecisionLevel)
   {   
      return getKernelObjectFactory ()->template createInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
   }


   template <typename Type>
   PsSensitiveInputAlias<Type> * createSensitiveInputAlias(const PsName & name, 
                                                           PsSimulatedObject & owner,
                                                           PsAbstractInput<Type> * input,
                                                           int requestedPrecisionLevel){   
      return getKernelObjectFactory ()->template createSensitiveInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
   }


   template <typename Type>
   PsSensitiveNotifyingInputAlias<Type> * createSensitiveNotifyingInputAlias(const PsName & name, 
                                                                             PsSimulatedObject & owner,
                                                                             PsAbstractInput<Type> * input,
                                                                             int requestedPrecisionLevel)
   {   
      return getKernelObjectFactory ()->template createSensitiveNotifyingInputAlias<Type>(name,owner,input,requestedPrecisionLevel);
   }

   template <typename Type>
   PsOutputAlias<Type> * createOutputAlias(const PsName & name, 
                                           PsSimulatedObject & owner,
                                           PsOutput<Type> * output,
                                           PsPolatorNT * polator)
   {   
      return getKernelObjectFactory ()->template createOutputAlias<Type>(name,owner,output,getOutputHistorySize(),polator);
   }
  
private:
   static PsKernelObjectAbstractFactory * kernelObjectFactory ;

public:
   enum WarningLevels { NoWarnings,
                        SomeWarnings,
                        AllWarnings,
                        ExceptionOnWarnings,
                        FatalWarnings};
   
   static WarningLevels warningLevel ;

   static void warning (const string & warningMessage, WarningLevels warningLevel ) ;

}; // PsController
#endif

---