---

PsInputAlias.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 PsInputAliasHEADER
#define PsInputAliasHEADER



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

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

  PsInputAlias (const PsName & inputName,
                PsSimulatedObject & owner, 
                PsAbstractInput<Type> * aliasedInput,
                const int requestedPrecisionLevel=PsPolatorNT::defaultPrecisionLevel ) 
     : PsAbstractInput<Type>(inputName,
                             owner,
                             aliasedInput->isConnectable(),
                             requestedPrecisionLevel) ,
     _aliasedInput ( aliasedInput )
   {
      if ( _aliasedInput != NULL )
         {
            _aliasedInput->notifyAliasing(this) ;
         }
      else 
         {
            cerr<<"WARNING : PsInputAlias::PsInputAlias : aliased input is NULL "<<endl;
         }
   };

   virtual ~PsInputAlias (void) 
   {
      if ( _aliasedInput != NULL )
         {
            _aliasedInput->notifyUnaliasing(this) ;
         }
   };

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


   virtual const PsDate & getDateOfLastExactValue() const ;


   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 void extract (istream & = cin) ;

  virtual void insertInStream (ostream & = cout) const ;

  virtual void printDebuggingInformation ( ostream & err ) const ;
  
   virtual bool realConnect (PsOutputNT * output) {
      return _aliasedInput->realConnect(output);
   }

   virtual void inputAliasedDeleted () ;
protected:

  PsAbstractInput<Type> * _aliasedInput;
  
} ; // PsInputAlias

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

template <typename Type>
inline void PsInputAlias<Type>::inputAliasedDeleted () 
{
   _aliasedInput = NULL ;
}

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

template <typename Type>
inline const Type & PsInputAlias<Type>::get (int deltaT) 
{
#ifdef _DEBUGTYPEUTIL
  cout << "PsInputAlias<Type>::localGet calling get of _aliasedInput " << endl;
#endif
  return _aliasedInput->get (deltaT);
}

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

template <typename Type>
inline int PsInputAlias<Type>::getDistanceToExactValue () const
{
  return _aliasedInput->getDistanceToExactValue();
}

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

template <typename Type>
inline void PsInputAlias<Type>::extract (istream & in)
{
  _aliasedInput->extract(in) ;
}

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

template <typename Type>
inline void PsInputAlias<Type>::insertInStream (ostream & out) const
{
  _aliasedInput->insertInStream(out) ;
}

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

template <typename Type>
inline void PsInputAlias<Type>::printDebuggingInformation ( ostream & err ) const
{
  err << "**********************************************************" << endl;
  err << "Class PsInputAlias" << endl;
  err << "Owner : " << _owner.getName() << endl;
  err << "polation precision level : " << _precisionLevel << endl;
}


template <typename Type>
const Type & PsInputAlias<Type>::getLastExactValue() const {
   return _aliasedInput->getLastExactValue() ;
}


template <typename Type>
const PsDate & PsInputAlias<Type>::getDateOfLastExactValue() const {
   return _aliasedInput->getDateOfLastExactValue() ;
}

template <typename Type>
bool PsInputAlias<Type>::connect (const PsName & objectName,
                                  const PsName & outputName) 
{
   return _aliasedInput->connect(objectName,outputName);
}


template <typename Type>
bool PsInputAlias<Type>::connect (PsSimulatedObject & object,
                                  const PsName & outputName) 
{
   return _aliasedInput->connect(object, outputName);
}


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


template <typename Type>
bool PsInputAlias<Type>::connect (const PsName & objectName,
                                  const PsName & outputName,
                                  const Type & initialValue) 
{
   return _aliasedInput->connect( objectName, outputName, initialValue );
}


template <typename Type>
bool PsInputAlias<Type>::connect (PsSimulatedObject & object,
                                  const PsName & outputName,
                                  const Type & initialValue) 
{
   return _aliasedInput->connect( object, outputName, initialValue );
}

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

template <typename Type>
bool PsInputAlias<Type>::connectToControlParameter (const PsName & objectName,
                                                    const PsName & controlParameterName) 
{
   return _aliasedInput->connectToControlParameter(objectName,controlParameterName);
}


template <typename Type>
bool PsInputAlias<Type>::connectToControlParameter (PsSimulatedObject & object,
                                                    const PsName & controlParameterName) 
{
   return _aliasedInput->connectToControlParameter(object, controlParameterName);
}


template <typename Type>
bool PsInputAlias<Type>::connectToControlParameter (PsSimulatedObject * object,
                                                    const PsName & controlParameterName) 
{
   return PsAbstractInput<Type>::connectToControlParameter(object, controlParameterName);
}


template <typename Type>
bool PsInputAlias<Type>::connectToControlParameter (const PsName & objectName,
                                                    const PsName & controlParameterName,
                                                    const Type & initialValue) 
{
   return _aliasedInput->connectToControlParameter( objectName, controlParameterName, initialValue );
}


template <typename Type>
bool PsInputAlias<Type>::connectToControlParameter (PsSimulatedObject & object,
                                                    const PsName & controlParameterName,
                                                    const Type & initialValue) 
{
   return _aliasedInput->connectToControlParameter( object, controlParameterName, initialValue );
}


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


template <typename Type>
void PsInputAlias<Type>::disconnect () 
{
   _aliasedInput->disconnect( );
}


template <typename Type>
const PsOutputNT * PsInputAlias<Type>::getConnectedOutput () const 
{
   return _aliasedInput->getConnectedOutput( );
}

#endif

---