---

PsSimulatedObject.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 PsSimulatedObjectHEADER
#define PsSimulatedObjectHEADER

//include ancestor classes
#include "PsFlowable.h"

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

//include PsList, cause declaration is guarded by pre-processing directives
#include "PsList.h" 

//include definition of PsPolatorNT::defaultPrecisionLevel
#include "PsPolatorNT.h"


#include <iostream> 
class PsObjectDescriptor ;

class PsEvent ;
template <typename Type> class PsValuedEvent ;
class PsEventIdentifier ;
class PsEventListener ;

class PsName ;
class PsnObjectHandle ;
class PsController ;

class PsInputNT ;
class PsOutputNT ;
class PsPolatorNT ;
template <typename Type> class PsInput ;
template <typename Type> class PsAbstractInput ;
template <typename Type> class PsSensitiveInput ;
template <typename Type> class PsSensitiveNotifyingInput ;
template <typename Type> class PsOutput ;
template <typename Type> class PsControlParameter ;
template <typename Type> class PsInputAlias ;
template <typename Type> class PsSensitiveInputAlias ;
template <typename Type> class PsSensitiveNotifyingInputAlias ;
template <typename Type> class PsOutputAlias ;

class PsSimulatedObjectCreator ;
class PsConfigurationParameterDescriptor ;

#include "PsSimpleSimulatedObjectCreator.h"

class PsSimulatedObject : public PsFlowable
{

public:

   PsSimulatedObject ( PsController & ctrl, const PsObjectDescriptor & objectDescription );
   
   virtual ~PsSimulatedObject() ;


   template <typename Type> list<const PsObjectDescriptor *> * listSonsOfType ( ) ;


   template <typename Type> list<const PsObjectDescriptor *> * listBrothersOfType (  ) ;


   template <typename Type> list<const PsObjectDescriptor *> * listDescendantsOfType ( ) ;

   
   virtual bool isAncestor ( const PsName & name );

   virtual PsSimulatedObject * getFather () const ; 
   
   virtual const PsObjectDescriptor & getFathersDescriptor () const ;





   virtual const PsName & getName () const;
   
   virtual PsController & getController () const;
   
   PsnObjectHandle * getObjectHandle () const ; 
   
   void setObjectHandle ( PsnObjectHandle * objectHandle) ;

   const PsObjectDescriptor & getObjectDescriptor () const ;
   
   
   virtual const PsNameToPointerMap < PsInputNT > & getInputTable () const ; 
   
   
   virtual const PsNameToPointerMap < PsOutputNT > & getOutputTable () const ; 
   
   
   virtual const PsNameToPointerMap < PsOutputNT > & getControlParameterTable () const ; 
   

   virtual const list < PsEventListener * > & getEventListeners () const ;
   

   virtual PsInputNT * getPointerToInputNamed ( const PsName & inputName ) const;
   
   
   virtual PsOutputNT * getPointerToOutputNamed ( const PsName & outputName) const;
   
   
   virtual PsOutputNT * getPointerToControlParameterNamed ( const PsName & parameterName ) const ;


   virtual const PsConfigurationParameterDescriptor * getConfigurationParameters () const ;
   



   

   virtual void init() ;
   

   virtual void compute ();


   virtual void finish ();

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

   virtual void unpack (PsIncomingSynchronisationMessage &) ;
   
   virtual void unpackAllValues (PsIncomingSynchronisationMessage &) ;
   
   virtual void pack (PsOutgoingSynchronisationMessage &) const ;

   virtual void packAllValues (PsOutgoingSynchronisationMessage &) const ;



   virtual void prepareEventProcessing ( list <PsEvent *> & ) ;


   virtual bool processEvent (PsEvent *) ;


   virtual void eventsProcessed ( list <PsEvent *> & ) ;


   virtual bool processEventsASAP () const ;


   virtual void addEventListener ( PsEventListener & ) ;


   void registerEventListenerForEvent ( PsEventListener & eventListener, 
                                        const PsEventIdentifier & eventId ) ;


   
   
   
   void fireSignal(const PsEventIdentifier & sig);


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


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


   virtual bool registerForSignalBy ( const PsEventIdentifier & sig , 
                                      PsSimulatedObject * producer );


   virtual bool registerForSignalBy ( const PsEventIdentifier & sig , 
                                      PsSimulatedObject & producer );


   virtual bool registerForSignalBy ( const PsEventIdentifier & sig , 
                                      PsSimulatedObject * producer,
                                      const PsEventIdentifier & eventId );



   virtual bool registerForSignalBy ( const PsEventIdentifier & sig , 
                                      PsSimulatedObject & producer,
                                      const PsEventIdentifier & eventId );



   virtual bool registerForSignal ( const PsEventIdentifier & sig );

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

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


   virtual bool cancelRegistrationForSignalBy ( const PsEventIdentifier & sig , PsSimulatedObject * producer );



   virtual bool cancelRegistrationForSignalBy ( const PsEventIdentifier & sig , PsSimulatedObject & producer );



   virtual bool cancelRegistrationForSignal ( const PsEventIdentifier & sig );

   template <typename Type> PsInput<Type> & addInput( const PsName & inputName,
                                                      bool makeConnectable = false,
                                                      int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> PsSensitiveInput<Type> & addSensitiveInput (const PsName & inputName,
                                                                        bool makeConnectable = false,
                                                                        int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> PsSensitiveNotifyingInput<Type> & addSensitiveNotifyingInput( const PsName & inputName,
                                                                                          bool makeConnectable = false,
                                                                                          int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;


   void deleteInput( const PsName & inputName) ;


   template <typename Type>  PsOutput<Type> & addOutput( const PsName & outputName,
                                                         PsPolatorNT * polator = 0 ) ;

   
   template <typename Type> PsControlParameter<Type> & addControlParameter( const PsName & controlParameterName,
                                                                            PsPolatorNT * polator = 0 ) ;


   template <typename Type> 
   PsInputAlias<Type> & addInputAlias (const PsName & aliasName,
                                       const PsName & aliasedObjectName,
                                       const PsName & aliasedInputName,
                                       int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> 
   PsSensitiveInputAlias<Type> & addSensitiveInputAlias( const PsName & aliasName,
                                                         const PsName & aliasedObjectName,
                                                         const PsName & aliasedInputName,
                                                         int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;


   template <typename Type> PsSensitiveNotifyingInputAlias<Type> & 
   addSensitiveNotifyingInputAlias( const PsName & aliasName,
                                    const PsName & aliasedObjectName,
                                    const PsName & aliasedInputName,
                                    int precisionLevel = PsPolatorNT::defaultPrecisionLevel ) ;
   

   template <typename Type> PsOutputAlias<Type> & addOutputAlias( const PsName & aliasName,
                                                              const PsName & aliasedObjectName,
                                                              const PsName & aliasedOutputName,
                                                              PsPolatorNT * interp = 0 ) ;
  
  
  
   
   virtual const PsDate & getSimulatedDate () const ;
   
   float getPeriod( ) const ;
   


   void sendEvent (const PsName & receiver , const PsEventIdentifier & eventId) ;
   

   void sendEvent ( PsSimulatedObject * receiver , const PsEventIdentifier & eventId) ;

   
   void sendEvent ( PsSimulatedObject & receiver , const PsEventIdentifier & eventId) ;

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

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

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


   void sendEvent ( const PsEvent & event ) ;


   void sendEvent ( PsEvent * event ) ;



   virtual void addInstanceCreator(const PsName & className, PsSimulatedObjectCreator * instanceCreator );

   template <typename SimulatedObject>
   void generateAndAddInstanceCreatorFor( const PsName & className);


   virtual const PsNameToPointerMap < PsSimulatedObjectCreator > & getEncapsulatedClassesTable () const ; 

   virtual PsSimulatedObject * createInstanceOfEncapsulatedClass( const PsObjectDescriptor & objectDescriptor ) const ;


protected:

   PsController & _controller;
   
   const PsObjectDescriptor & _objectDescriptor ;
      
   friend class PsInputNT ;
   PsNameToPointerMap<PsInputNT> _inputTable ; 
   
   PsNameToPointerMap<PsOutputNT> _outputTable ; 
   
   PsNameToPointerMap<PsOutputNT> _controlParameterTable ; 
   
   list <PsEventListener *> _listOfEventListeners ;

   PsnObjectHandle * _objectHandle ;
   
   PsNameToPointerMap < PsSimulatedObjectCreator > _encapsulatedClassesTable ;

}; // PsSimulatedObject



//----------------------------------- IMPLEMENTATION OF TEMPLATE MEMBER FUNCTIONS ---------------------

#include "PsController.h"
#include "PsValuedEvent.h"
#include "PsObjectDescriptor.h"
#include "PsUnallowedOverloadingException.h"

template <typename Type> 
list<const PsObjectDescriptor *> * PsSimulatedObject::listSonsOfType (  )
{
   return getObjectDescriptor().template listSonsOfType<Type>(  );
}



template <typename Type> 
list<const PsObjectDescriptor *> * PsSimulatedObject::listBrothersOfType ( )
{
   assert ( getObjectDescriptor().getFathersObjectDescriptor() != NULL ) ;
   return getObjectDescriptor().getFathersObjectDescriptor()->template listSonsOfType<Type> (  );
}



template <typename Type> 
list<const PsObjectDescriptor *> * PsSimulatedObject::listDescendantsOfType ( )
{
   return getObjectDescriptor().template listDescendantsOfType<Type>( );
}


template <typename UserType> 
void PsSimulatedObject::fireValuedSignal( const PsEventIdentifier & sig, const UserType & value ) 
{
   PsValuedEvent<UserType> event ( sig, getSimulatedDate(), getName(), getName(), value) ;
   if ( getObjectHandle() != NULL )
      {
         getObjectHandle()->sendEventsForSignal( event , sig ) ;
      }
   else
      {
         getController().broadcastEventsForSignal ( event, sig ) ;
      }
}

template <typename Type> 
PsInput<Type> & PsSimulatedObject::addInput( const PsName & inputName,
                                             bool makeConnectable,
                                             int precisionLevel ) 
{
   PsInputNT * redefinedInput = _inputTable.getObjectOfIndex ( inputName );
   PsInput<Type> * input ;
   if ( redefinedInput == NULL )
      {
         input = _controller.template createInput<Type> ( inputName, *this, makeConnectable, precisionLevel ) ;
      }
   else 
      {
         input = dynamic_cast<PsInput<Type> *> ( redefinedInput ) ;
         if ( input == NULL ) 
            {
               throw PsUnallowedOverloadingException(inputName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : input "<<inputName<<" of object "<<getName()
                   <<" already defined. No new input created : reference to old one used"<<endl;
            }
      }
   return *input ;
}



template <typename Type> 
PsSensitiveInput<Type> & PsSimulatedObject::addSensitiveInput (const PsName & inputName,
                                                               bool makeConnectable,
                                                               int precisionLevel ) 
{
   PsInputNT * redefinedInput = _inputTable.getObjectOfIndex ( inputName );
   PsSensitiveInput<Type> * input ;
   if ( redefinedInput == NULL )
      {
         input = _controller.template createSensitiveInput<Type>( inputName, *this, makeConnectable, precisionLevel );
      }
   else
      {
         input = dynamic_cast <PsSensitiveInput<Type> *> ( redefinedInput ) ;
         if ( input == NULL )
            {
               throw PsUnallowedOverloadingException( inputName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : sensitiveInput "<<inputName<<" of object "<<getName()
                   <<" already defined. No new sensitiveInput created : reference to old one used"<<endl;
            }
      }
   return *input ;
}



template <typename Type> 
PsSensitiveNotifyingInput<Type> & PsSimulatedObject::addSensitiveNotifyingInput( const PsName & inputName,
                                                                                 bool makeConnectable,
                                                                                 int precisionLevel ) 
{
   PsInputNT * redefinedInput = _inputTable.getObjectOfIndex ( inputName );
   PsSensitiveNotifyingInput<Type> * input ;
   if ( redefinedInput == NULL ) 
      {
           input = _controller.template createSensitiveNotifyingInput<Type>(inputName, *this, makeConnectable, precisionLevel) ; 
      }
   else 
      {
         input = dynamic_cast <PsSensitiveNotifyingInput<Type> * > ( redefinedInput ) ;
         if ( input == NULL )
            {
               throw PsUnallowedOverloadingException ( inputName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : sensitiveNotifyingInput "<<inputName<<" of object "<<getName()
                   <<" already defined. No new sensitiveNotifyingInput created : reference to old one used"<<endl;
            }
      }
   return *input ; 
}



template <typename Type>  
PsOutput<Type> & PsSimulatedObject::addOutput( const PsName & outputName,
                                               PsPolatorNT * polator ) 
{
   PsOutputNT * redefinedOutput = _outputTable.getObjectOfIndex ( outputName ) ;
   PsOutput<Type> * output ;
   if ( redefinedOutput == NULL )
      { 
         output = _controller.template createOutput<Type>(outputName, *this, polator ) ;
      }
   else 
      {
         output = dynamic_cast <PsOutput<Type> *> ( redefinedOutput ) ;
         if ( output == NULL )
            {
               throw PsUnallowedOverloadingException ( outputName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : output "<<outputName<<" of object "<<getName()
                   <<" already defined. No new output created : reference to old one used"<<endl;
            }
      }
   
   _outputTable.addObjectWithIndex (outputName, output) ;
   return *output ;
}

   

template <typename Type> 
PsControlParameter<Type> & PsSimulatedObject::addControlParameter( const PsName & controlParameterName,
                                                                   PsPolatorNT * polator )
{
   PsOutputNT * redefinedControlParameter = _controlParameterTable.getObjectOfIndex ( controlParameterName ) ;
   PsControlParameter<Type> * controlParameter ;
   if ( redefinedControlParameter == NULL )
      {
         controlParameter = _controller.template createControlParameter<Type>( controlParameterName, *this, polator);
      }
   else 
      {
         controlParameter =  dynamic_cast < PsControlParameter<Type> * > ( redefinedControlParameter ) ;
         if (  controlParameter == NULL )
            {
               throw PsUnallowedOverloadingException ( controlParameterName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : controlParameter "<<controlParameterName<<" of "<<getName()
                   <<" already defined. No new controlParameter created : reference to old one used"<<endl;
            }
      }
   PsOutputNT * realControlParameter = dynamic_cast<PsOutputNT *>(controlParameter) ;
   assert ( realControlParameter != NULL ) ; 
   _controlParameterTable.addObjectWithIndex (controlParameterName, realControlParameter) ;
   return *controlParameter ;
} 



template <typename Type> 
PsInputAlias<Type> & PsSimulatedObject::addInputAlias (const PsName & aliasName,
                                                       const PsName & aliasedObjectName,
                                                       const PsName & aliasedInputName,
                                                       int precisionLevel ) 
{
   PsInputNT * redefinedInput =  _inputTable.getObjectOfIndex ( aliasName ) ;
   PsInputAlias<Type> * alias = NULL ;

   if ( redefinedInput == NULL )
      {
         // make sure aliasedObjectName is an ancestor of object
         if ( isAncestor( aliasedObjectName ) )
            {       
               PsSimulatedObject * obj = _controller.getPointerToSimulatedObjectNamed (aliasedObjectName) ;
               PsInputNT * input = obj->_inputTable.getObjectOfIndex( aliasedInputName );
               PsAbstractInput<Type> * realInput = dynamic_cast <PsAbstractInput<Type> *> (input) ;
               
               if (realInput != NULL) 
                  {
                     if (obj != NULL) 
                        {
                           alias = _controller.template createInputAlias<Type>( aliasName, *this, realInput, precisionLevel );
                        } 
                     else 
                        {
                           PsController::error("imposible aliasing ") ;
                        } 
                  }
               else 
                  {
                     PsController::error("impossible aliasing, probably because of type mismatch") ;
                  }
            }
         else
            {
               cerr << "PsSimulatedObject::createInputAlias " << aliasedObjectName << " isn't the father of  " 
                    << getName() << " : aliasing is therefore impossible for alias named " <<  aliasedInputName << endl ;
               PsController::error("");
            }
      }
   else 
      {
         alias = dynamic_cast <PsInputAlias<Type> * > ( redefinedInput );
         if ( alias == NULL )
            {
               throw PsUnallowedOverloadingException ( aliasName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : inputAlias "<<aliasName<<" of object "<<getName()
                   <<" already defined. No new inputAlias created : reference to old one used"<<endl;
            }
      }
   return *alias ;
}



template <typename Type> 
PsSensitiveInputAlias<Type> & PsSimulatedObject::addSensitiveInputAlias( const PsName & aliasName,
                                                                         const PsName & aliasedObjectName,
                                                                         const PsName & aliasedInputName,
                                                                         int precisionLevel )
{
   PsInputNT * redefinedInput =  _inputTable.getObjectOfIndex ( aliasName ) ;
   PsSensitiveInputAlias<Type> * alias = NULL ;

   if ( redefinedInput == NULL )
      {
         // make sure aliasedObjectName is an ancestor of object
         if (isAncestor(aliasedObjectName))
            {    
               PsSimulatedObject * obj = _controller.getPointerToSimulatedObjectNamed (aliasedObjectName) ;
               PsInputNT * input = obj->_inputTable.getObjectOfIndex( aliasedInputName );
               PsAbstractInput<Type> * realInput =   dynamic_cast <PsAbstractInput<Type> *> (input) ;
               if (realInput != NULL) 
                  {
                     if (obj != NULL) 
                        {
                           alias = _controller.template createSensitiveInputAlias<Type>(aliasName,*this,realInput,precisionLevel);
                        } 
                     else 
                        {
                           PsController::error("Impossible aliasing ") ;
                        } 
                  }
               else
                  {
                     PsController::error("impossible aliasing, probably because of type mismatch") ;
                  }
            }
         else
            {
               cerr << "PsSimulatedObject::addSensitiveInputAlias " << aliasedObjectName << " isn't the father of " 
                    << getName() << " : cannot create an alias of " <<  aliasedInputName << endl ;
               throw PsUserException("") ;
            }
      }
   else 
      {
         alias = dynamic_cast <PsSensitiveInputAlias<Type> * > ( redefinedInput );
         if ( alias == NULL )
            {
               throw PsUnallowedOverloadingException ( aliasName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : sensitiveInputAlias "<<aliasName<<" of object "<<getName()
                   <<" already defined. No new sensitiveInputAlias created : reference to old one used"<<endl;
            }
      }
   return *alias ;
}


template <typename Type> 
PsSensitiveNotifyingInputAlias<Type> & 
PsSimulatedObject::addSensitiveNotifyingInputAlias( const PsName & aliasName,
                                                    const PsName & aliasedObjectName,
                                                    const PsName & aliasedInputName,
                                                    int precisionLevel
                                                    )
{
   PsInputNT * redefinedInput =  _inputTable.getObjectOfIndex ( aliasName ) ;
   PsSensitiveNotifyingInputAlias<Type> * alias = NULL ;
   
   if ( redefinedInput == NULL )
      {
      // make sure aliasedObjectName is an ancestor of object
         if( isAncestor( aliasedObjectName ) )
            {
               PsSimulatedObject * obj = _controller.getPointerToSimulatedObjectNamed (aliasedObjectName) ;  
               PsInputNT * input = obj->_inputTable.getObjectOfIndex ( aliasedInputName);
               PsAbstractInput<Type> * realInput;
               realInput =   dynamic_cast <PsAbstractInput<Type> *> (input) ;
               if (realInput != NULL) 
                  {
                     if (obj != NULL) 
                        {
                           alias = _controller.template createSensitiveNotifyingInputAlias<Type>( aliasName, *this, realInput, precisionLevel);
                        } 
                     else 
                        {
                           throw PsUserException("Impossible aliasing ") ;
                        } 
                  }
               else 
                  {
                     PsController::error("alias type mismatch");
                  }
            }
         else
            {
               cerr << "PsSimulatedObject::addSensitiveSeignalingInputAlias " << aliasedObjectName 
                    << " isn' the father of " 
                    << getName() << " : creation of alias named " <<  aliasedInputName << " impossible" << endl ;
               throw PsUserException("");
            }
      }
   else 
      {
         alias = dynamic_cast <PsSensitiveNotifyingInputAlias<Type> * > ( redefinedInput );
         if ( alias == NULL )
            {
               throw PsUnallowedOverloadingException ( aliasName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : sensitiveNotifyingInputAlias "<<aliasName<<" of object "<<getName()
                   <<" already defined. No new sensitiveNotifyingInputAlias : reference to old one used"<<endl;
            }
      }
   return *alias ;
}

template <typename Type> 
PsOutputAlias<Type> & PsSimulatedObject::addOutputAlias( const PsName & aliasName,
                                                         const PsName & aliasedObjectName,
                                                         const PsName & aliasedOutputName,
                                                         PsPolatorNT * interp )
{ 
   PsOutputNT * redefinedOutput =  _outputTable.getObjectOfIndex ( aliasName ) ;     

   PsOutputAlias<Type> * alias = NULL ;
   list<const PsObjectDescriptor *> * listeFils = getController().template listDescendantsOfType<PsSimulatedObject>(aliasedObjectName); 
   int aliasedObjectPresent = false ;
   
   if ( redefinedOutput == NULL ) 
      {
         // make sure aliasedObjectName is an ancestor of object
         if (listeFils!=NULL)
            {
               list<const PsObjectDescriptor *>::const_iterator listeFilsIterator = listeFils->begin() ;
               while((listeFilsIterator != listeFils->end() ) && 
                     (!aliasedObjectPresent) )
                  {
                     aliasedObjectPresent = ( (*listeFilsIterator)->getName() == getName() ) ;
                     ++ listeFilsIterator ;
                  }
               
               delete listeFils;
            }    
         if( aliasedObjectPresent )
            {
               
               PsSimulatedObject * obj = _controller.getPointerToSimulatedObjectNamed (aliasedObjectName) ;
               
               PsOutputNT * Outputnt = obj->getPointerToOutputNamed(aliasedOutputName);
               PsOutput<Type> * refOutput =   dynamic_cast <PsOutput<Type> *> (Outputnt) ;
               if (refOutput != NULL) 
                  {
                     if (obj != NULL) 
                        {
                           alias = _controller.template createOutputAlias<Type>(aliasName,*this,refOutput,interp);
                        } 
                     else 
                        {
                           cerr << "PsSimulatedObject::addOutputAlias " << endl ;
                           cerr << "alias " << aliasName << " cannot be made on inexistant " << aliasedOutputName << endl ;
                           throw PsUserException(""); 
                        } 
                  }
               else 
                  {
                     throw PsUserException("Impossible output aliasing : type mismatch");
                  }
            }
         else
            {
               cout << "PsSimulatedObject::addOutputAlias " << aliasedObjectName << " isn't the father of " 
                    << getName() << " : not possible to alias " <<  aliasedOutputName << endl ;
               PsController::error("");
            }
      }
   else
      {
         alias = dynamic_cast <PsOutputAlias<Type> * > ( redefinedOutput );
         if ( alias == NULL )
            {
               throw PsUnallowedOverloadingException ( aliasName, getName() ) ;
            }
         else 
            {
               cerr<<"Warning : outputAlias already defined. No new outputAlias created : reference to old one used"<<endl;
            }
      }
   _outputTable.addObjectWithIndex (aliasName, alias) ;
   return *alias ;
}



template <typename UserType> 
void PsSimulatedObject::sendValuedEvent (const PsName & receiver , const PsEventIdentifier & eventId, const UserType & userInfo) {
   PsSimulatedObject * receiverObject = _controller.getPointerToSimulatedObjectNamed( receiver ) ;
   if ( receiverObject == NULL ) 
      {
         getController().addToPendingEvents (new PsValuedEvent<UserType> (eventId,
                                                                          _controller.getSimulatedDate (),
                                                                          getName (),
                                                                          receiver ,
                                                                          userInfo) ) ;
      }
   else 
      {
         if ( receiverObject->getObjectHandle() != NULL )
            {
               receiverObject->getObjectHandle()->receiveEvent (new PsValuedEvent<UserType> (eventId,
                                                                                             _controller.getSimulatedDate (),
                                                                                             getName (),
                                                                                             receiver ,
                                                                                             userInfo) ) ;
            }
         else 
            {
               getController().addToPendingEvents(new PsValuedEvent<UserType> (eventId,
                                                                               _controller.getSimulatedDate (),
                                                                               getName (),
                                                                               receiver ,
                                                                               userInfo) ) ;
            }
      }
}


template <typename UserType> 
void PsSimulatedObject::sendValuedEvent ( PsSimulatedObject * receiver , const PsEventIdentifier & eventId , const UserType & userInfo) 
{
   if ( receiver->getObjectHandle() != NULL )
      {
         receiver->getObjectHandle()->receiveEvent (new PsValuedEvent<UserType> (eventId,
                                                                                 _controller.getSimulatedDate (),
                                                                                 getName (),
                                                                                 receiver->getName (),
                                                                                 userInfo) ) ;
      }
   else 
      {
         getController().addToPendingEvents(new PsValuedEvent<UserType> (eventId,
                                                                         _controller.getSimulatedDate (),
                                                                         getName (),
                                                                         receiver->getName (),
                                                                         userInfo) ) ;
      }
}

template <typename UserType> 
void PsSimulatedObject::sendValuedEvent ( PsSimulatedObject & receiver , const PsEventIdentifier & eventId , const UserType & userInfo) 
{
   if ( receiver.getObjectHandle() != NULL )
      {
         receiver.getObjectHandle()->receiveEvent (new PsValuedEvent<UserType> (eventId,
                                                                                _controller.getSimulatedDate (),
                                                                                getName (),
                                                                                receiver.getName (),
                                                                                userInfo) ) ;
      }
   else
      {
         getController().addToPendingEvents (new PsValuedEvent<UserType> (eventId,
                                                                          _controller.getSimulatedDate (),
                                                                          getName (),
                                                                          receiver.getName (),
                                                                          userInfo) ) ;
      }
}


template <typename SimulatedObject>
void PsSimulatedObject::generateAndAddInstanceCreatorFor (const PsName & className)
{
   addInstanceCreator ( className , new PsSimpleSimulatedObjectCreator< SimulatedObject > () ) ; 
}

#endif

---