OMKSimulatedObject.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 OMKSimulatedObjectHEADER
#define OMKSimulatedObjectHEADER
#include "OMKTracer.h"
#include "OMKSimpleTypeT.h"
//include ancestor classes
#include "OMKFlowable.h"

//include member class
#include "OMKNameToPointerMap.h"

//include definition of OMK::Type::PolatorNT::defaultPrecisionLevel
#include "OMKPolatorNT.h"
#include "OBTPrototypeFactory.h"

#include <iostream> 
#include <list> 


namespace OMK 
{
template <typename Type> class Output ;
template <typename Type> class InputAlias ;
template <typename Type> class OutputAlias ;
template <typename Type> class Input ;
template <typename Type> class AbstractInput ;
template <typename Type> class SensitiveInput ;
template <typename Type> class SensitiveNotifyingInput ;
template <typename Type> class ControlParameter ;
template <typename Type> class SensitiveInputAlias ;
template <typename Type> class SensitiveNotifyingInputAlias ;
template <typename Type> class ValuedEvent ;
class ObjectDescriptor ;
class ConfigurationParameterDescriptor ;
class Controller ;
class InputNT ;
class OutputNT ;
class Event ;
class ObjectHandle ;
class Name ;
class EventListener ;
class EventIdentifier ;
class OMK_API SimulatedObject : public Flowable
{

public:

   SimulatedObject ( Controller & ctrl, const ObjectDescriptor & objectDescription );
   
   virtual ~SimulatedObject() ;


   template< typename Type > 
   std::list< const ObjectDescriptor * > * listSonsOfType ( ) ;


   template< typename Type > 
   std::list< const ObjectDescriptor * > * listBrothersOfType (  ) ;


   template< typename Type > 
   std::list< const ObjectDescriptor * > * listDescendantsOfType ( ) ;

   
   virtual bool isAncestor ( const Name & name );

   virtual SimulatedObject * getFather () const ; 
   
   virtual const ObjectDescriptor & getFathersDescriptor () const ;





   virtual const Name & getName () const;
   
   virtual Controller & getController () const;
   
   ObjectHandle * getObjectHandle () const ; 
   
   void setObjectHandle ( ObjectHandle * objectHandle) ;

   const ObjectDescriptor & getObjectDescriptor () const ;
   
   
   virtual const NameToPointerMap < InputNT > & getInputTable () const ; 
   
   
   virtual const NameToPointerMap < OutputNT > & getOutputTable () const ; 
   
   
   virtual const NameToPointerMap < OutputNT > & getControlParameterTable () const ; 
   

   virtual const std::list < EventListener * > & getEventListeners () const ;
   

   virtual InputNT * getPointerToInputNamed ( const Name & inputName ) const;
   
   
   virtual OutputNT * getPointerToOutputNamed ( const Name & outputName) const;
   
   
   virtual OutputNT * getPointerToControlParameterNamed ( const Name & parameterName ) const ;


   virtual const ConfigurationParameterDescriptor * getConfigurationParameters () const ;
   



   

   // added by Jean-Marie Houssay 2005-03-29 
   virtual void postConstruction() ;

   virtual void init() ;

   virtual void emigrate() ;
   virtual void immigrate(Event * event) ;
   virtual void compute ();


   virtual void finish ();

   
   virtual void extract (std::istream & in = std::cin) ;
   
   
   virtual void insertInStream (std::ostream & out = std::cout) const;
   

   virtual void unpack (IncomingSynchronisationMessage &) ;
   
   virtual void unpackAllValues (IncomingSynchronisationMessage &) ;
   
   virtual void pack (OutgoingSynchronisationMessage &) const ;

   virtual void packAllValues (OutgoingSynchronisationMessage &) const ;



   virtual void prepareEventProcessing ( std::list <Event *> & ) ;


   virtual bool processEvent (Event *) ;


   virtual void eventsProcessed ( std::list <Event *> & ) ;


   virtual bool processEventsASAP () const ;


   virtual void addEventListener( EventListener & ) ;

   void registerEventListenerForEvent( EventListener & eventListener, 
                                                                     const EventIdentifier & eventId ) ;

   void unregisterEventListener( EventListener & eventListener ) ;

   
   
   
   void fireSignal(const EventIdentifier & sig);


   template <typename UserType> 
   void fireValuedSignal( const EventIdentifier & sig, const UserType & value );


   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      const Name & producer );
   
 
   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      const Name & producer,
                                      const EventIdentifier & eventId );


   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      SimulatedObject * producer );


   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      SimulatedObject & producer );


   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      SimulatedObject * producer,
                                      const EventIdentifier & eventId );



   virtual bool registerForSignalBy ( const EventIdentifier & sig , 
                                      SimulatedObject & producer,
                                      const EventIdentifier & eventId );



   virtual bool registerForSignal ( const EventIdentifier & sig );

   virtual bool registerForSignal ( const EventIdentifier & sig ,
                                    const EventIdentifier & eventId );

   virtual bool cancelRegistrationForSignalBy ( const EventIdentifier & sig , const Name & producer );


   virtual bool cancelRegistrationForSignalBy ( const EventIdentifier & sig , SimulatedObject * producer );



   virtual bool cancelRegistrationForSignalBy ( const EventIdentifier & sig , SimulatedObject & producer );



   virtual bool cancelRegistrationForSignal ( const EventIdentifier & sig );

   template <typename Type> Input<Type> & addInput( const Name & inputName,
                                                      bool makeConnectable = false,
                                                      int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> SensitiveInput<Type> & addSensitiveInput (const Name & inputName,
                                                                        bool makeConnectable = false,
                                                                        int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> SensitiveNotifyingInput<Type> & addSensitiveNotifyingInput( const Name & inputName,
                                                                                          bool makeConnectable = false,
                                                                                          int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   void deleteInput( const Name & inputName) ;


   template <typename Type>  Output<Type> & addOutput( const Name & outputName,
                                                         OMK::Type::PolatorNT * polator = 0 ) ;

   
   template <typename Type> ControlParameter<Type> & addControlParameter( const Name & controlParameterName,
                                                                            OMK::Type::PolatorNT * polator = 0 ) ;


   template <typename Type> 
   InputAlias<Type> & addInputAlias (const Name & aliasName,
                                       const Name & aliasedObjectName,
                                       const Name & aliasedInputName,
                                       int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> 
   SensitiveInputAlias<Type> & addSensitiveInputAlias( const Name & aliasName,
                                                         const Name & aliasedObjectName,
                                                         const Name & aliasedInputName,
                                                         int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> SensitiveNotifyingInputAlias<Type> & 
   addSensitiveNotifyingInputAlias( const Name & aliasName,
                                    const Name & aliasedObjectName,
                                    const Name & aliasedInputName,
                                    int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;
   

   template <typename Type> OutputAlias<Type> & addOutputAlias( const Name & aliasName,
                                                              const Name & aliasedObjectName,
                                                              const Name & aliasedOutputName,
                                                              OMK::Type::PolatorNT * interp = 0 ) ;
  
  
  
   
   virtual const Date & getSimulatedDate () const ;
   
   float getPeriod( ) const ;
   


   void sendEvent (const Name & receiver , const EventIdentifier & eventId) ;
   

   void sendEvent ( SimulatedObject * receiver , const EventIdentifier & eventId) ;

   
   void sendEvent ( SimulatedObject & receiver , const EventIdentifier & eventId) ;

   
   template <typename UserType> 
   void sendValuedEvent (const Name & receiver , const EventIdentifier & eventId, const UserType & userInfo) ;
   

   template <typename UserType> 
   void sendValuedEvent ( SimulatedObject * receiver , const EventIdentifier & eventId , const UserType & userInfo) ;
   

   template <typename UserType> 
   void sendValuedEvent ( SimulatedObject & receiver , const EventIdentifier & eventId , const UserType & userInfo) ;


   void sendEvent ( const Event & event ) ;


   void sendEvent ( Event * event ) ;


protected:

   Controller & _controller;
   
   const ObjectDescriptor & _objectDescriptor ;
      
   friend class InputNT ;
   NameToPointerMap<InputNT> _inputTable ; 
   
   NameToPointerMap<OutputNT> _outputTable ; 
   
   NameToPointerMap<OutputNT> _controlParameterTable ; 
   
   std::list <EventListener *> _listOfEventListeners ;

   ObjectHandle * _objectHandle ;
   
}; // SimulatedObject




#define DECLARE_OBJECT_FACTORY( ObjectClass ) \
public: \
 \
  friend class OMK::SimulatedObjectCreatorT< ObjectClass > ; \
 \
  static OMK::Name OMK_CLASS_ID ;                                    \
 \
  static const bool REGISTERED_IN_OBJECT_FACTORY ; \
protected: \
 \
   ObjectClass( OMK::Controller& ctrl, const OMK::ObjectDescriptor& objectDescriptor ) ; \
public: \
  virtual ~ObjectClass() 

#define REGISTER_OBJECT_FACTORY( ObjectClass, Id )\
  /* Factory */ \
  OMK::Name ObjectClass::OMK_CLASS_ID( Id ) ;                             \
  const bool ObjectClass::REGISTERED_IN_OBJECT_FACTORY( OMK::SimulatedObjectFactory::getInstance().registerCreator< OMK::SimulatedObjectCreatorT< ObjectClass > >( Id ) )

} // namespace OMK

//-------------------------------------------------------------------------
#include "OMKObjectDescriptor.h"

namespace OMK
{
//-----------------------------------------------------------------------------
class SimulatedObjectCreator
{
public:
  virtual ~SimulatedObjectCreator(){}
  virtual SimulatedObject* operator()( Controller & ctrl, const ObjectDescriptor & objectDescription ) const 
  {
    OMERROR( "Creator is not registered for \"" << objectDescription.getName() << "\" class \"" << objectDescription.getClass() << "\"" ) ;
    throw Exception( "Creator is not registered" ) ;
    return 0 ;
  }
} ;

//-----------------------------------------------------------------------------
template <class T>
class SimulatedObjectCreatorT : public SimulatedObjectCreator
{
public:

  typedef T object_to_create ;
  virtual ~SimulatedObjectCreatorT(){}
  SimulatedObject* operator()( Controller & ctrl, const ObjectDescriptor & objectDescription ) const
  {
    SimulatedObject* object = new T( ctrl, objectDescription ) ;
    if( object ) object->postConstruction() ;
    return object ;
  }
} ;

//-----------------------------------------------------------------------------
typedef OBT::Singleton< OBT::PrototypeFactory< OMK::Name, SimulatedObjectCreator > > SimulatedObjectFactory ;

} // namespace OMK

template class OMK_API OBT::PrototypeFactory< OMK::Name, OMK::SimulatedObjectCreator > ;
template class OMK_API OBT::Singleton< OBT::PrototypeFactory< OMK::Name, OMK::SimulatedObjectCreator > > ;

#endif

---