00001 /* 00002 * This file is part of openMask (c) INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software 00003 * 00004 * The Software has been developped within the Siames Project. 00005 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights 00006 * 00007 * The Software has been registered with the Agence pour la Protection des 00008 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200 00009 * 00010 * This file may be distributed under the terms of the Q Public License 00011 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file 00012 * LICENSE.QPL included in the packaging of this file. 00013 * 00014 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 00015 * for the software may use this file in accordance with that specific license 00016 * 00017 */ 00018 #ifndef ControllerHEADER 00019 #define ControllerHEADER 00020 00021 #include "OMKBaseType.h" 00022 #include "OMKSignalDispatcher.h" 00023 #include "OMKSimulatedObject.h" 00024 #include "OMKReferenceObjectHandle.h" 00025 #include "OMKValuedEvent.h" 00026 00027 #ifdef _OMK_MUTEX_ 00028 # include "OMKMutexLock.h" 00029 #endif 00030 00031 //--------------------------------------------------------------------- 00032 namespace OMK 00033 { 00034 class Process; 00035 template <typename T> class AbstractInput; 00036 class ObjectDescriptor ; 00037 class MultipleConfigurationParameter ; 00038 class KernelObjectAbstractFactory ; 00039 class DoubleList; 00040 class Scheduler ; 00041 class Name; 00042 00043 //--------------------------------------------------------------------- 00053 class OMK_API Controller : public SimulatedObject 00054 { 00055 public: 00060 Controller(ObjectDescriptor & simulationTree, 00061 const Date & initialDate); 00062 00065 virtual ~Controller(); 00066 00067 /* init 00068 * send MaskStart to all initial objects 00069 */ 00070 virtual void init(); 00071 00075 virtual void run(); 00076 00081 template <typename Type> std::list<const ObjectDescriptor *> * listDescendantsOfType(const Name & objectName) ; 00082 00087 template <typename Type> std::list<const ObjectDescriptor * > * listBrothersOfType (const Name objectName) ; 00088 00089 protected: 00091 virtual void computeNextSimulationStep(); 00092 00096 virtual void scheduleObject(ReferenceObjectHandle * ref); 00097 00098 public: 00099 00102 void processStartEventAfterMorphose(ReferenceObjectHandle * objectHandle) ; 00104 // typedef vector<Name> publicMirrorList; 00105 virtual void createLocalObject( const ObjectDescriptor & newLObjectDescription, 00106 const Name & fathersLName ) ; 00107 virtual int getMirrorsNbre() { return 1;}; 00108 virtual bool isAMirror (const Name & name) { return false ;}; 00109 virtual std::vector<Name> getMirrorList () {return std::vector<Name>() ;}; 00110 virtual std::vector<Name> getIsolatedMirrorList() {return std::vector<Name>() ;}; 00111 virtual std::vector<Name> getNonIsolatedMirrorList() {return std::vector<Name>() ;}; 00112 virtual bool testIfTroubleOccured() {return false; } ; 00113 virtual void createNewSite ( const Date & ) {} ; 00114 typedef std::pair< Name,Name > MigrationObjectPrm ; 00115 DECLARE_TYPE_EVENT( MigrationObjectPrm, MigrationObject ) ; 00116 void migrateObjectToProcess ( Name &nomObjet, Name &nomProcess) ; 00117 virtual std::list<Name> getDisconnectedProcessusList () { return std::list<Name> () ;}; 00118 virtual std::map<Name, int> getDisconnectedProcessusMap () { return std::map<Name, int> () ;}; 00119 00125 virtual Frequency computeAdequateFrequency(const Frequency & suggestedFrequency); 00126 00133 virtual void runControllersStep(ReferenceObjectHandle * objectHandle); 00134 00137 virtual void compute(); 00138 00141 virtual void finish() ; 00142 00143 protected: 00147 MultipleConfigurationParameter * getSchedulingParametersOfObject(ObjectDescriptor &) ; 00148 00155 SimulatedObject * createDescribedObject(const ObjectDescriptor * description); 00156 00159 virtual void setProcessOfDescriptor ( ObjectDescriptor & objectDescription, const Name & newProcessName ) ; 00160 00161 public: 00165 static void error (const char * mess) ; 00166 00168 static Date initialSimulationDate ; 00169 00173 void showDateAndStepNumber(bool show = true); 00174 00176 virtual const Date & getSimulatedDate () const ; 00177 00179 virtual int getCycleFrequency() const ; 00180 00182 virtual int getCyclePeriod() const ; 00183 00185 typedef std::pair< ObjectDescriptor,Name > CreateObjectPrm ; 00186 DECLARE_TYPE_EVENT( CreateObjectPrm, CreateObject ) ; 00187 00194 virtual void createObject(const ObjectDescriptor & newObjectDescription, const Name & fathersName); 00195 00203 virtual void destroyObject(const Name & name, bool recursively); 00204 00210 virtual void changeObjectsFather(const Name & name , const Name & newFather) ; 00211 00217 virtual void changeObjectsFather(ObjectDescriptor * object, ObjectDescriptor * newFather) ; 00218 00219 protected: 00228 virtual void computeScheduling(bool fromOriginal) ; 00229 00232 virtual void sendInitialEventsTo(ReferenceObjectHandle & objectHandle, const Date & dateOfMaskStart) ; 00233 00240 virtual void deleteObject(ObjectDescriptor * objectDescription); 00241 00246 virtual ObjectHandle * removeObjectFromDataStructures(const Name &); 00247 00248 public: 00253 virtual SimulatedObject * getPointerToDuplicatedObjectNamed(const Name & name); 00254 00261 virtual SimulatedObject * getPointerToSimulatedObjectNamed(const Name & name); 00262 00263 protected: 00264 friend class InputNT; 00265 friend class OMK::SimulatedObject; 00266 00270 virtual void processNewObjectDeclaration ( ObjectDescriptor & declaration, const Date & declarationDate ) ; 00271 00275 virtual ReferenceObjectHandle * createReferenceObject (const ObjectDescriptor * idObjet); 00276 00277 public: 00283 virtual const ObjectDescriptor & getObjectDescriptorOfObject(const Name & objectName) ; 00284 00285 // calculate least common multiplier 00286 static int lcm (const int a, const int b) ; 00287 00288 // calculate greatest common divisor 00289 static int gcd (const int a, const int b) ; 00290 00292 std::vector<Name> _publicReferentielObjectsVector ; 00293 virtual std::vector<Name> getReferentielList(); 00294 00295 protected: 00298 virtual Scheduler * createScheduler() ; 00299 00303 virtual void scheduleControlledObjects(); 00304 00306 virtual void advanceSimulatedDate(); 00307 00311 virtual void createControlledObjects(const ObjectDescriptor * subTree); 00312 00315 NameToPointerMap<ReferenceObjectHandle> _referenceObjectsMap ; 00316 00320 ObjectDescriptor & _simulationTree; 00321 00323 unsigned long int _numberOfSimulatedSteps; 00324 00325 virtual void setCycleFrequency(int newFrequency) ; 00326 00328 Frequency _stepFrequency; 00329 00331 int _cycleFrequency; 00332 00334 int _cyclePeriod ; 00335 00338 int _nbStepsByCycle; 00339 00343 int _stepPeriod; 00344 00346 Date _date; 00347 00349 bool _showDateAndStepNumber; 00350 00352 ReferenceObjectHandle::SimulatedObjectComputingState * _computeStatePointer ; 00353 00354 public: 00356 virtual void actOnSystemEvent ( Event * event ) ; 00357 00359 virtual void reactToControlledObjectsSystemEvents(); 00360 00362 virtual void processStartEventOf(ReferenceObjectHandle * objectHandle); 00363 00365 virtual void processDeleteEventOf(ReferenceObjectHandle * objectHandle); 00366 00370 virtual void hasEventsToProcess(ReferenceObjectHandle * referenceObjectHandle); 00371 00374 virtual void postponeEventProcessing ( ReferenceObjectHandle * referenceObjectHandle ); 00375 00379 virtual void noActivationNeededFor ( ReferenceObjectHandle * referenceObjectHandle ) ; 00380 00383 virtual void addToPendingEvents( Event * ) ; 00384 00393 virtual bool addToPendingRegistrations(const EventIdentifier & sig, 00394 const Name & producer, 00395 const EventIdentifier & eventId, 00396 const Name & registrant) ; 00397 00405 virtual bool removeFromPendingRegistrations(const EventIdentifier & sig, 00406 const Name & producer, 00407 const Name & registrant); 00408 00410 virtual bool processEvent(Event *); 00411 00413 virtual void processEventsOfSuspendedObjects(); 00414 00419 virtual void broadcastEventsForSignal (Event & event, const EventIdentifier & sigId); 00420 00426 virtual bool receiveRegistrationForSignal(const EventIdentifier & sigId, 00427 const Name & registrant, 00428 const EventIdentifier & eventId); 00429 00434 virtual bool receiveCancellationForSignal(const EventIdentifier & sigId, 00435 const Name & registrant ) ; 00436 00437 protected: 00439 SignalDispatcher _controledObjectsSignalsDispatcher ; 00440 00442 virtual void setComputingState(ReferenceObjectHandle *, ReferenceObjectHandle::SimulatedObjectComputingState) const ; 00443 00444 protected: 00446 bool _forcedCompute ; 00447 00449 Scheduler * _scheduler ; 00450 00454 std::list<ReferenceObjectHandle *> *_objectsNeedingActivationList[ 2 ]; 00455 00457 int _currentListOfObjectsNeedingActivation ; 00458 00460 virtual void switchSystemEventList() ; 00461 00463 std::list <Event *> *_systemEventsList[ 2 ] ; 00464 00466 unsigned int _currentWritableSystemEventsList ; 00467 00469 std::list <ReferenceObjectHandle * > _listOfObjectsWithPostPonedEvents ; 00470 00471 #ifdef _OMK_MUTEX_ 00472 00473 OMKMutexLock _mutexSystemEventsList ; 00474 #endif 00475 00476 std::map <Name, std::list<Event *> > _pendingEventsList ; 00477 00478 #ifdef _OMK_MUTEX_ 00479 00480 OMKMutexLock _mutexPendingDataStructures ; 00481 #endif 00482 00484 std::map <Name, SignalDispatcher *> _pendingRegistrationRequests ; 00485 00487 virtual void purgeMemoryFromOldEvents ( const Date & dateOfOldestKept ) ; 00488 00490 virtual Date getPurgeDate() ; 00491 00496 std::list <std::pair <Date, ObjectHandle *> > _deletedObjectHandles ; 00497 00498 protected: 00500 //ReferenceObjectHandle * _objectHandle ; 00501 00505 virtual int getOutputHistorySize(void) ; 00506 00511 virtual ReferenceObjectHandle * createReferenceObjectHandle(SimulatedObject & obj); 00512 00519 virtual ReferenceObjectHandle * newOMKReferenceObjectHandle(SimulatedObject & object, 00520 Controller & controller, 00521 SignalDispatcher * signalDispatcher); 00522 00524 virtual void deleteObjectHandle ( ObjectHandle * objectHandle ) ; 00525 00526 public: 00532 static bool setKernelObjectFactory(KernelObjectAbstractFactory * aFactory); 00533 00535 static KernelObjectAbstractFactory * getKernelObjectFactory () ; 00536 00537 00545 template <typename Type> 00546 Input<Type> * createInput(const Name & name, 00547 SimulatedObject & owner, 00548 bool makeConnectable, 00549 int requestedPrecisionLevel) ; 00550 00558 template <typename Type> 00559 SensitiveInput<Type> * createSensitiveInput( const Name & name, 00560 SimulatedObject & owner, 00561 bool makeConnectable, 00562 int requestedPrecisionLevel) ; 00563 00571 template <typename Type> 00572 SensitiveNotifyingInput<Type> * createSensitiveNotifyingInput(const Name & name, 00573 SimulatedObject & owner, 00574 bool makeConnectable, 00575 int requestedPrecisionLevel); 00576 00584 template <typename Type> 00585 Output<Type> * createOutput(const Name & name, 00586 SimulatedObject & owner, 00587 OMK::Type::PolatorNT * polator) ; 00588 00595 template <typename Type> 00596 ControlParameter<Type> * createControlParameter(const Name & name, 00597 SimulatedObject & owner, 00598 OMK::Type::PolatorNT * polator); 00599 00608 template <typename Type> 00609 InputAlias<Type> * createInputAlias(const Name & name, 00610 SimulatedObject & owner, 00611 AbstractInput<Type> * input, 00612 int requestedPrecisionLevel); 00613 00622 template <typename Type> 00623 SensitiveInputAlias<Type> * createSensitiveInputAlias(const Name & name, 00624 SimulatedObject & owner, 00625 AbstractInput<Type> * input, 00626 int requestedPrecisionLevel); 00627 00636 template <typename Type> 00637 SensitiveNotifyingInputAlias<Type> * createSensitiveNotifyingInputAlias(const Name & name, 00638 SimulatedObject & owner, 00639 AbstractInput<Type> * input, 00640 int requestedPrecisionLevel); 00641 00650 template <typename Type> 00651 OutputAlias<Type> * createOutputAlias(const Name & name, 00652 SimulatedObject & owner, 00653 Output<Type> * output, 00654 OMK::Type::PolatorNT * polator); 00655 00656 private: 00658 static KernelObjectAbstractFactory * kernelObjectFactory ; 00659 00660 }; // Controller 00661 00662 } // namespace OMK 00663 00664 00665 #include <OMKObjectDescriptor.h> 00666 #include <OMKKernelObjectAbstractFactory.h> 00667 00668 namespace OMK 00669 { 00674 template <typename Type> 00675 inline std::list<const ObjectDescriptor *> * 00676 Controller::listDescendantsOfType(const Name & objectName) 00677 { 00678 const ObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ; 00679 if ( objectDescriptor != NULL ) 00680 { 00681 return objectDescriptor->template listDescendantsOfType<Type> () ; 00682 } 00683 else 00684 { 00685 return new std::list<const ObjectDescriptor *>() ; 00686 } 00687 } 00688 00693 template <typename Type> 00694 inline std::list<const ObjectDescriptor * > * 00695 Controller::listBrothersOfType (const Name objectName) 00696 { 00697 const ObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ; 00698 if ( objectDescriptor != NULL ) 00699 { 00700 objectDescriptor = objectDescriptor->getFathersObjectDescriptor() ; 00701 if ( objectDescriptor != NULL ) 00702 { 00703 return objectDescriptor->template listBrothersOfType<Type> () ; 00704 } 00705 else 00706 { 00707 return new std::list<const ObjectDescriptor *>() ; 00708 } 00709 } 00710 else 00711 { 00712 return new std::list<const ObjectDescriptor *>() ; 00713 } 00714 } 00715 00723 template <typename Type> 00724 inline Input<Type> * 00725 Controller::createInput(const Name & name, 00726 SimulatedObject & owner, 00727 bool makeConnectable, 00728 int requestedPrecisionLevel) 00729 { 00730 return getKernelObjectFactory ()->template createInput<Type> (name,owner,makeConnectable,requestedPrecisionLevel); 00731 } 00732 00740 template <typename Type> 00741 inline SensitiveInput<Type> * 00742 Controller::createSensitiveInput(const Name & name, 00743 SimulatedObject & owner, 00744 bool makeConnectable, 00745 int requestedPrecisionLevel) 00746 { 00747 return getKernelObjectFactory ()->template createSensitiveInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel); 00748 } 00749 00757 template <typename Type> 00758 inline SensitiveNotifyingInput<Type> * Controller::createSensitiveNotifyingInput(const Name & name, 00759 SimulatedObject & owner, 00760 bool makeConnectable, 00761 int requestedPrecisionLevel) 00762 { 00763 return getKernelObjectFactory ()->template createSensitiveNotifyingInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel); 00764 } 00765 00773 template <typename Type> 00774 inline Output<Type> * 00775 Controller::createOutput(const Name & name, 00776 SimulatedObject & owner, 00777 OMK::Type::PolatorNT * polator) 00778 { 00779 return getKernelObjectFactory ()->template createOutput<Type>(name,owner,getOutputHistorySize(),polator); 00780 } 00781 00788 template <typename Type> 00789 inline ControlParameter<Type> * 00790 Controller::createControlParameter(const Name & name, 00791 SimulatedObject & owner, 00792 OMK::Type::PolatorNT * polator) 00793 { 00794 return getKernelObjectFactory ()->template createControlParameter<Type>(name,owner,getOutputHistorySize(),polator); 00795 } 00796 00805 template <typename Type> 00806 inline InputAlias<Type> * 00807 Controller::createInputAlias(const Name & name, 00808 SimulatedObject & owner, 00809 AbstractInput<Type> * input, 00810 int requestedPrecisionLevel) 00811 { 00812 return getKernelObjectFactory ()->template createInputAlias<Type>(name,owner,input,requestedPrecisionLevel); 00813 } 00814 00823 template <typename Type> 00824 inline SensitiveInputAlias<Type> * 00825 Controller::createSensitiveInputAlias(const Name & name, 00826 SimulatedObject & owner, 00827 AbstractInput<Type> * input, 00828 int requestedPrecisionLevel) 00829 { 00830 return getKernelObjectFactory ()->template createSensitiveInputAlias<Type>(name,owner,input,requestedPrecisionLevel); 00831 } 00832 00841 template <typename Type> 00842 inline SensitiveNotifyingInputAlias<Type> * 00843 Controller::createSensitiveNotifyingInputAlias(const Name & name, 00844 SimulatedObject & owner, 00845 AbstractInput<Type> * input, 00846 int requestedPrecisionLevel) 00847 { 00848 return getKernelObjectFactory ()->template createSensitiveNotifyingInputAlias<Type>(name,owner,input,requestedPrecisionLevel); 00849 } 00850 00859 template <typename Type> 00860 inline OutputAlias<Type> * 00861 Controller::createOutputAlias(const Name & name, 00862 SimulatedObject & owner, 00863 Output<Type> * output, 00864 OMK::Type::PolatorNT * polator) 00865 { 00866 return getKernelObjectFactory ()->template createOutputAlias<Type>(name,owner,output,getOutputHistorySize(),polator); 00867 } 00868 00869 } // namespace OMK 00870 00871 #include "OMKSimulatedObject.inl" 00872 00873 #endif
| Documentation generated on Mon Jun 9 11:45:56 2008 |
Generated with doxygen by Dimitri van Heesch , 1997-2007 |