---

PsInput.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 PsInputHEADER
#define PsInputHEADER

#include <PsAbstractInput.h>
#include <PsSimulatedObject.h>
#include <PsOutput.h>
#include <PsUnInitialisedOutputException.h>

//-----------------------------------------------------------------
#include "PsInputConnectionEventListener.h"

template <typename Type>
class PsInput : public PsAbstractInput <Type>
{
public:

   PsInput (const PsName & inputName, PsSimulatedObject & owner, bool makeConnectable, const int precisionLevel = PsPolatorNT::defaultPrecisionLevel) ;


   /* Destructor
    */
   virtual ~PsInput (void) ;


   virtual bool connect (const PsName & objectName, const PsName & outputName ) ;


   virtual bool connect (PsSimulatedObject & object, const PsName & outputName ) ;


   virtual bool connect (PsSimulatedObject * pointerToObject, const PsName & outputName ) ;


   virtual bool connect (const PsName & objectName, const PsName & outputName, const Type & initialValue) ;


   virtual bool connect (PsSimulatedObject & object, const PsName & outputName, const Type & initialValue) ;


   virtual bool connect (PsSimulatedObject * pointerToObject, const PsName & outputName, const Type & initialValue) ;


   virtual bool connectToControlParameter (const PsName & objectName, const PsName & controlParameterName ) ;


   virtual bool connectToControlParameter (PsSimulatedObject & object, const PsName & controlParameterName )  ;


   virtual bool connectToControlParameter (PsSimulatedObject * pointerToObject, const PsName & controlParameterName ) ;


   virtual bool connectToControlParameter (const PsName & objectName, const PsName & controlParameterName, const Type & initialValue)  ;


   virtual bool connectToControlParameter (PsSimulatedObject & object, const PsName & controlParameterName, const Type & initialValue)  ;


   virtual bool connectToControlParameter (PsSimulatedObject * pointerToObject, const PsName & controlParameterName, const Type & initialValue) ;


   virtual const PsOutputNT * getConnectedOutput () const ;



   virtual void disconnect () ;


   virtual const Type & get (int deltaT = 0); 


   virtual int getDistanceToExactValue () const;


   virtual const Type & getLastExactValue() const ;


   virtual const PsDate & getDateOfLastExactValue() const ;


   virtual void printDebuggingInformation (ostream & err ) const ;


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


   virtual void outputDestroyed () ; 

   virtual bool realConnect (PsOutputNT * output ) ;

protected:

   int _distanceToExactValueOfLastGet ; 


   PsOutput<Type> * _connectedOutput;

   
   Type _calculatedResult ;

   PsInputConnectionEventListener<Type> * _associatedEventListener ;
   
} ; // PsInput






//---------------------------- IMPLEMENTATION -----------------------------


#include "PsNullOutputCreator.h"
#include "PsControlParameter.h"

template <typename Type>
PsInput<Type>::PsInput (const PsName & inputName, PsSimulatedObject & owner, bool makeConnectable, const int precisionLevel)
   : PsAbstractInput<Type>( inputName, owner, makeConnectable, precisionLevel ),
   _connectedOutput (  PsNullOutputCreator::template getNullOutput <Type> () )
{
   // the event listener has to be created even is makeConnectable is false to enable dynamic change in the connectable state without side effects on event listener order. This is important to ensure consistent behaviour in way that doesn't depend on creation and making public order.
   _associatedEventListener = new PsInputConnectionEventListener<Type> ( owner, this ) ;
   owner.addEventListener( *_associatedEventListener ) ;     
};


template <typename Type>
PsInput<Type>::~PsInput () 
{
   if ( _associatedEventListener != NULL ) delete _associatedEventListener ;
   _connectedOutput -> disconnectedMyself (this) ;
}


//-----------------------------------------------------------------


template <typename Type>
inline void PsInput<Type>::disconnect () 
{
   _connectedOutput -> disconnectedMyself (this) ;
   _connectedOutput = PsNullOutputCreator::template getNullOutput<Type> () ;
}


//-----------------------------------------------------------------


template <typename Type>
inline bool PsInput<Type>::connect (const PsName & objectName,
                                    const PsName & outputName) {
#ifdef _DEBUGTYPEUTIL
  cout << "PsInput<Type>::connect" << endl;
#endif
  PsSimulatedObject * object = _owner.getController ().getPointerToSimulatedObjectNamed (objectName) ;
  if (object != NULL) 
     {
#ifdef DEBUG
          cerr << "PsInput<Type>::connect, objet : " << objectName 
                    << ", sur sortie : " << outputName << endl
                    << "pointeur de la sortie de l'objet : " << object->getPointerToOutputNamed ( outputName ) << endl ;
#endif
        return realConnect ( object->getPointerToOutputNamed ( outputName ) ) ;
     } 
  else 
     {
        printDebuggingInformation ( cerr ) ;
        cerr<< "PsInput<Type>::connect " <<objectName<<" unknown"<< endl ;
        return false ;
     }
}


template <typename Type>
inline bool PsInput<Type>::connect (const PsName & objectName,
                                     const PsName & outputName,
                                     const Type & initialValue) 
{
   if ( connect (objectName, outputName) )
      {
         _connectedOutput->suggest (initialValue) ;
         return true ;
      }
   else 
      {
         return false ;
      }
}

//-----------------------------------------------------------------

template <typename Type>
inline bool PsInput<Type>::connect (PsSimulatedObject & object,
                                    const PsName & outputName,
                                    const Type & initialValue) 
{
   if ( connect (object, outputName) )
      {
         _connectedOutput->suggest (initialValue) ;
         return true ;
      }
   else 
      {
         return false ;
      }
}

template <typename Type>
inline bool PsInput<Type>::connect (PsSimulatedObject * object,
                                    const PsName & outputName,
                                    const Type & initialValue) 
{
   return PsAbstractInput<Type>::connect (object, outputName, initialValue );
}

//-----------------------------------------------------------------
template <typename Type>
inline bool PsInput<Type>::connect (PsSimulatedObject & object,
                                    const PsName & outputName) 
{
  
#ifdef _DEBUGTYPEUTIL
   cout << "PsInput<Type>::connect" << endl;
#endif
   return realConnect (object.getPointerToOutputNamed (outputName)) ;
}

//-----------------------------------------------------------------
template <typename Type>
inline bool PsInput<Type>::connect (PsSimulatedObject * object,
                                    const PsName & outputName) 
{
   return PsAbstractInput<Type>::connect(object, outputName) ;
}


//-----------------------------------------------------------------


template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (const PsName & objectName,
                                                      const PsName & controlParameterName) {
#ifdef _DEBUGTYPEUTIL
   cout << "PsInput<Type>::connectToControlParameter" << endl;
#endif
   PsSimulatedObject * object = _owner.getController ().getPointerToSimulatedObjectNamed (objectName) ;
   if (object != NULL) 
      {
         return realConnect ( object->getPointerToControlParameterNamed ( controlParameterName ) ) ;
      } 
   else 
      {
         printDebuggingInformation ( cerr ) ;
         cerr<< "PsInput<Type>::connectToControlParameter " <<objectName<<" unknown"<< endl ;
         return false ;
      }
}


template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (const PsName & objectName,
                                                      const PsName & controlParameterName,
                                                      const Type & initialValue) 
{
   if ( connect (objectName, controlParameterName) )
      {
         _connectedOutput->suggest (initialValue) ;
         return true ;
      }
   else 
      {
         return false ;
      }
}

//-----------------------------------------------------------------

template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (PsSimulatedObject & object,
                                                      const PsName & controlParameterName,
                                                      const Type & initialValue) 
{
   if ( connect (object, controlParameterName) )
      {
         _connectedOutput->suggest (initialValue) ;
         return true ;
      }
   else 
      {
         return false ;
      }
}

template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (PsSimulatedObject * pointerToObject,
                                                      const PsName & controlParameterName,
                                                      const Type & initialValue) 
{
   return PsAbstractInput<Type>::connectToControlParameter ( pointerToObject, controlParameterName, initialValue ) ;
}



//-----------------------------------------------------------------
template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (PsSimulatedObject & object,
                                                      const PsName & controlParameterName) 
{
#ifdef _DEBUGTYPEUTIL
   cerr << "PsInput<Type>::connect" << endl;
#endif
   return realConnect (object.getPointerToControlParameterNamed (controlParameterName)) ;
}


//-----------------------------------------------------------------
template <typename Type>
inline bool PsInput<Type>::connectToControlParameter (PsSimulatedObject * object,
                                                      const PsName & controlParameterName) 
{
#ifdef _DEBUGTYPEUTIL
   cerr << "PsInput<Type>::connect" << endl;
#endif
   return PsAbstractInput<Type>::connectToControlParameter (object, controlParameterName) ;
}


//-----------------------------------------------------------------

template <typename Type>
inline bool PsInput<Type>::realConnect (PsOutputNT * output) 
{
   /* if the current active object isn't initialised or is the owner of the input, proceed with connection*/
   if ( PsnCurrentActiveObject::getCurrentActiveObject() == &_owner ||
        PsnCurrentActiveObject::getCurrentActiveObject() == &_owner.getController() ||
        PsnCurrentActiveObject::getCurrentActiveObject() == NULL )
      {
         disconnect() ;
         _connectedOutput = dynamic_cast <PsOutput<Type> *> (output) ;
         
         if ( _connectedOutput == NULL ) 
            {
               printDebuggingInformation ( cerr ) ;
               cerr<<"PsInput::realConnect outpout is of wrong type"<<endl;
               return false ;
            }
         else 
            {
               _connectedOutput->connectedMyself(this) ;
               return true ;
            }
      }
   else if ( isConnectable() )
      {
         PsControlParameter<Type> * controlParameter = dynamic_cast<PsControlParameter<Type> *> (output) ;
         if ( controlParameter == NULL )
            {
               PsnCurrentActiveObject::getCurrentActiveObject()->sendValuedEvent(_owner,
                                                                                 getConnectionEventId(),
                                                                                 output->getName() ) ;
            }
         else
            {
               PsnCurrentActiveObject::getCurrentActiveObject()->sendValuedEvent(_owner,
                                                                                 getConnectionToControlParameterEventId(),
                                                                                 output->getName() ) ;
            }
         return true ;
      }
   else
      {
         cerr<<"Warning: "
             <<_owner.getName()<<"::"<<getName()<<" "
             <<"is not connectable"<<endl;
         return false ;
      }
}



template <typename Type>
inline const PsOutputNT * PsInput<Type>::getConnectedOutput () const
{
   return _connectedOutput ;
}

//-----------------------------------------------------------------

template <typename Type>
inline const Type & PsInput<Type>::get (int deltaT ) 
{
#ifdef _DEBUGTYPEUTIL
   cout << "PsInput<Type>::localGet calling get of _connectedOutput " <<refOutput<< endl;
#endif
   try {
      return _connectedOutput->get (_distanceToExactValueOfLastGet, 
                              _precisionLevel, 
                              deltaT, 
                              _calculatedResult);
   }
   catch (PsUnInitialisedOutputException & s ) {
      s<<"PsInput<"<<typeid(Type).name()<<">::get \n";
      s<<"Owner "<< _owner.getName() <<"de nom "<<_name<<"\n";
      throw ;
   }
}


template <typename Type>
inline const Type & PsInput<Type>::getLastExactValue() const {
   return _connectedOutput->getLastExactValue () ;
}


template <typename Type>
inline const PsDate & PsInput<Type>::getDateOfLastExactValue() const {
   return _connectedOutput->getDateOfLastExactValue () ;
}

//-----------------------------------------------------------------

template <typename Type>
inline int PsInput<Type>::getDistanceToExactValue () const
{
   return _distanceToExactValueOfLastGet ;
}

//-----------------------------------------------------------------

template <typename Type>
inline void PsInput<Type>::extract (istream & in)
{
   assert ( false ) ; //shouldn't be called
   in >> *_connectedOutput ;
}

//-----------------------------------------------------------------

template <typename Type>
inline void PsInput<Type>::insertInStream (ostream & out) const
{
   assert ( false ) ; //shouldn't be called
   out << *_connectedOutput << " " ;
}

//-----------------------------------------------------------------

template <typename Type>
inline void PsInput<Type>::printDebuggingInformation (ostream & err) const
{
  err << "**********************************************************" << endl;
  err << "Class PsInput" << endl;
  err << "owner : " << _owner.getName() << endl;
  err << "polation precision level : " << _precisionLevel << endl;
  err << "element type : " << typeid(Type).name() << endl;
}

template <typename Type>
void PsInput<Type>::outputDestroyed () 
{
   _connectedOutput = PsNullOutputCreator::template getNullOutput<Type> () ;
} 

#endif

---