OMKInputAlias.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 InputAliasHEADER
#define InputAliasHEADER

#include "OMKSimulatedObject.h"
#include "OMKController.h"
#include "OMKInput.h"
#include <iostream>

namespace OMK
{
template< typename T >
class InputAlias : public AbstractInput< T >
{                            
 protected:
  using AbstractInput < T >::_owner ;
  using AbstractInput < T >::_precisionLevel ;

 public:

   InputAlias( const Name & inputName,
               SimulatedObject & owner,
               AbstractInput< T > * aliasedInput,
               const int requestedPrecisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel )
     : AbstractInput< T >( inputName,
                           owner,
                           aliasedInput->isConnectable(),
                           requestedPrecisionLevel ),
       _aliasedInput(  aliasedInput )
   {
     if( _aliasedInput != 0 )
     {
       _aliasedInput->notifyAliasing( this ) ;
     }
     else 
     {
       OMERROR( "WARNING: InputAlias::InputAlias : aliased input is null " ) ;
     }
   }

   virtual ~InputAlias()
   {
     if( _aliasedInput != 0 )
     {
       _aliasedInput->notifyUnaliasing( this ) ;
     }
   }

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


   virtual const Date & getDateOfLastExactValue() const ;


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


   virtual bool connect( SimulatedObject & object, const Name & outputName ) ;


   virtual bool connect( SimulatedObject * pointerToObject, const Name & outputName ) ;


   virtual bool connect( const Name & objectName, const Name & outputName, const T & initialValue ) ;


   virtual bool connect( SimulatedObject & object, const Name & outputName, const T & initialValue ) ;


   virtual bool connect( SimulatedObject * pointerToObject, const Name & outputName, const T & initialValue ) ;


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


   virtual bool connectToControlParameter( SimulatedObject & object, const Name & controlParameterName )  ;


   virtual bool connectToControlParameter( SimulatedObject * pointerToObject, const Name & controlParameterName ) ;


   virtual bool connectToControlParameter( const Name & objectName, const Name & controlParameterName, const T & initialValue )  ;


   virtual bool connectToControlParameter( SimulatedObject & object, const Name & controlParameterName, const T & initialValue )  ;


   virtual bool connectToControlParameter( SimulatedObject * pointerToObject, const Name & controlParameterName, const T & initialValue ) ;


   virtual const OutputNT * getConnectedOutput() const ;


   virtual void disconnect() ;


   virtual void extract( std::istream & = std::cin ) ;

   virtual void insertInStream( std::ostream & = std::cout ) const ;

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

   virtual void inputAliasedDeleted() ;
protected:

  AbstractInput< T > * _aliasedInput ;
  
} ; // InputAlias


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


template< typename T >
inline void InputAlias< T >::inputAliasedDeleted()
{
  _aliasedInput = 0 ;
}

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

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

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

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

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

template< typename T >
inline void InputAlias< T >::extract( std::istream & in )
{
  _aliasedInput->extract( in ) ;
}

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

template< typename T >
inline void InputAlias< T >::insertInStream( std::ostream & out ) const
{
  _aliasedInput->insertInStream( out ) ;
}

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

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

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

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

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

template< typename T >
const Date & InputAlias< T >::getDateOfLastExactValue() const
{
  return _aliasedInput->getDateOfLastExactValue() ;
}

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

template< typename T >
bool InputAlias< T >::connect( const Name & objectName,
                               const Name & outputName )
{
  return _aliasedInput->connect( objectName, outputName ) ;
}

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

template< typename T >
bool InputAlias< T >::connect( SimulatedObject & object,
                               const Name & outputName )
{
  return _aliasedInput->connect( object, outputName ) ;
}

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

template< typename T >
bool InputAlias< T >::connect( SimulatedObject * object,
                               const Name & outputName )
{
  return AbstractInput< T >::connect( object, outputName ) ;
}

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

template< typename T >
bool InputAlias< T >::connect( const Name & objectName,
                               const Name & outputName,
                               const T & initialValue )
{
  return _aliasedInput->connect( objectName, outputName, initialValue ) ;
}

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

template< typename T >
bool InputAlias< T >::connect( SimulatedObject & object,
                               const Name & outputName,
                               const T & initialValue )
{
  return _aliasedInput->connect( object, outputName, initialValue ) ;
}

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

template< typename T >
bool InputAlias< T >::connect( SimulatedObject * object,
                               const Name & outputName,
                               const T & initialValue )
{
  return AbstractInput< T >::connect( object, outputName, initialValue ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  const Name & objectName,
  const Name & controlParameterName )
{
  return _aliasedInput->connectToControlParameter(
    objectName, controlParameterName ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  SimulatedObject & object,
  const Name & controlParameterName )
{
  return _aliasedInput->connectToControlParameter(
    object, controlParameterName ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  SimulatedObject * object,
  const Name & controlParameterName )
{
  return AbstractInput< T >::connectToControlParameter(
    object, controlParameterName ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  const Name & objectName,
  const Name & controlParameterName,
  const T & initialValue )
{
  return _aliasedInput->connectToControlParameter(
    objectName, controlParameterName, initialValue ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  SimulatedObject & object,
  const Name & controlParameterName,
  const T & initialValue )
{
  return _aliasedInput->connectToControlParameter(
    object, controlParameterName, initialValue ) ;
}

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

template< typename T >
bool InputAlias< T >::connectToControlParameter(
  SimulatedObject * object,
  const Name & controlParameterName,
  const T & initialValue )
{
  return AbstractInput< T >::connectToControlParameter(
    object, controlParameterName, initialValue ) ;
}

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

template< typename T >
void InputAlias< T >::disconnect()
{
  _aliasedInput->disconnect() ;
}

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

template< typename T >
const OutputNT * InputAlias< T >::getConnectedOutput() const
{
  return _aliasedInput->getConnectedOutput() ;
}

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

} // namespace OMK

#endif

---