---

PsAbstractInput.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 PsAbstractInputHEADER
#define PsAbstractInputHEADER

#include <PsSimulatedObject.h>
#include <PsController.h>
#include <PsInputNT.h>

template <class Type>
class PsAbstractInput : public PsInputNT
{
public:
   
   PsAbstractInput (const PsName & inputName, PsSimulatedObject & owner, bool makeConnectable, const int precisionLevel=PsPolatorNT::defaultPrecisionLevel);
   

   virtual ~PsAbstractInput (void) ;
   

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


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


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


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


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


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


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


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


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


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


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


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


   virtual bool isConnectable () const ;

   
   virtual void setConnectable (bool nextConnectableState ) ;


   virtual const PsOutputNT * getConnectedOutput () const = 0 ;


   const PsEventIdentifier & getConnectionEventId () const ;


   const PsEventIdentifier & getConnectionToControlParameterEventId () const ;


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


  virtual int getDistanceToExactValue() const = 0;


   virtual const Type & getLastExactValue() const = 0 ;
   

   virtual const PsDate & getDateOfLastExactValue() const = 0 ;
   

   virtual void printDebuggingInformation (ostream & err) const = 0;


   virtual int getPrecisionLevel() const ;


   virtual int setPrecisionLevel (const int newValue) ;


   virtual void notifyAliasing(PsInputAlias<Type> * aliasingInputAlias) ;


   virtual void notifyUnaliasing (PsInputAlias<Type> *aliasingInputAlias) ;


protected:
   list<PsInputAlias<Type> *> _listOfAliases ;

   int _precisionLevel ;

   bool _connectable ;

   const PsEventIdentifier _connectionEventId ;

   const PsEventIdentifier _connectionToControlParameterEventId ;

} ; // PsAbstractInput


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

#include "PsnCurrentActiveObject.h"


template <typename Type>
inline PsAbstractInput<Type>::PsAbstractInput (const PsName & inputName,
                                               PsSimulatedObject & owner,
                                               bool makeConnectable,
                                               const int precisionLevel)
   : PsInputNT ( owner, inputName ),
     _precisionLevel ( precisionLevel ),
     _connectable ( makeConnectable ),
     _connectionEventId ( PsString("newConnection ") + inputName ),
     _connectionToControlParameterEventId ( PsString("newConnectionToControlParameter ") + inputName )
{
#ifdef _DEBUGTYPEUTIL
  cout << "PsAbstractInput<Type>::PsAbstractInput --> constructeur " << endl;
#endif
  registerMe () ; 
}

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

template <typename Type>
inline PsAbstractInput<Type>::~PsAbstractInput (void)
{
#ifdef _TYPENAMENOTIMPLICIT
   typename 
#endif
   list<PsInputAlias<Type> *>::iterator i;
   for (i=_listOfAliases.begin();i!=_listOfAliases.end();i++) 
      {
         (*i)->inputAliasedDeleted();
      }
}

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

template <typename Type>
inline int PsAbstractInput<Type>::getPrecisionLevel (void) const
{
  return _precisionLevel ;
}

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

template <typename Type>
inline int PsAbstractInput<Type>::setPrecisionLevel (const int newValue )
{
   int oldValue = _precisionLevel ;
   _precisionLevel = newValue ;
   return oldValue ;
}

template <typename Type>
inline void PsAbstractInput<Type>::notifyAliasing (PsInputAlias <Type> * aliasingInputAlias )
{
   if ( aliasingInputAlias != NULL )
      {
         _listOfAliases.push_back( aliasingInputAlias );
      }
}



template <typename Type>
inline void PsAbstractInput<Type>::notifyUnaliasing (PsInputAlias <Type> * aliasingInputAlias )
{
   if ( aliasingInputAlias != NULL )
      {
         _listOfAliases.push_back( aliasingInputAlias );
      }
}



template <typename Type>
inline bool PsAbstractInput<Type>::isConnectable () const 
{
   return _connectable ;
}



template <typename Type>
void PsAbstractInput<Type>::setConnectable ( bool newConnectableState )  
{
   if ( PsnCurrentActiveObject::getCurrentActiveObject() == & _owner ||
        PsnCurrentActiveObject::getCurrentActiveObject() == & _owner.getController() ||
        PsnCurrentActiveObject::getCurrentActiveObject() == NULL ) 
      {
         _connectable = newConnectableState ;
      }
   else 
      {
         cerr<<"Warning: "
             <<_owner.getName()
             <<"::"
             <<getName()
             <<"only the owner can change the the connectable state of an input"<<endl;
      }
}


template <typename Type>
inline const PsEventIdentifier & PsAbstractInput<Type>::getConnectionEventId () const 
{
   return _connectionEventId ;
}


template <typename Type>
inline const PsEventIdentifier & PsAbstractInput<Type>::getConnectionToControlParameterEventId () const 
{
   return _connectionToControlParameterEventId ;
}


template <typename Type>
inline bool PsAbstractInput<Type>::connect (PsSimulatedObject * pointerToObject,
                                            const PsName & outputName)
{
   if ( pointerToObject != NULL )
      {
         return connect (*pointerToObject, outputName) ;
      }
   else
      {
         cerr<<"PsAbstractInput<Type>::connect : got NULL pointer"<<endl;
         printDebuggingInformation ( cerr ) ;
         return false ;
      } 
}



template <typename Type>
inline bool PsAbstractInput<Type>::connect (PsSimulatedObject * pointerToObject,
                                            const PsName & outputName,
                                            const Type & initialValue)
{
   if ( pointerToObject != NULL )
      {
         return connect (*pointerToObject, outputName, initialValue) ;
      }
   else
      {
         cerr<<"PsAbstractInput<Type>::connect : got NULL pointer"<<endl;
         printDebuggingInformation ( cerr ) ;
         return false ;
      } 
}



template <typename Type>
inline bool PsAbstractInput<Type>::connectToControlParameter (PsSimulatedObject * pointerToObject,
                                            const PsName & outputName)
{
   if ( pointerToObject != NULL )
      {
         return connectToControlParameter (*pointerToObject, outputName) ;
      }
   else
      {
         cerr<<"PsAbstractInput<Type>::connect : got NULL pointer"<<endl;
         printDebuggingInformation ( cerr ) ;
         return false ;
      } 
}



template <typename Type>
inline bool PsAbstractInput<Type>::connectToControlParameter (PsSimulatedObject * pointerToObject,
                                            const PsName & outputName,
                                            const Type & initialValue)
{
   if ( pointerToObject != NULL )
      {
         return connectToControlParameter (*pointerToObject, outputName, initialValue) ;
      }
   else
      {
         cerr<<"PsAbstractInput<Type>::connect : got NULL pointer"<<endl;
         printDebuggingInformation ( cerr ) ;
         return false ;
      } 
}
#endif

---