OMKInput.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 OMKInputHEADER
#define OMKInputHEADER

#include "OMKAbstractInput.h"
#include "OMKSimulatedObject.h"
#include "OMKOutput.h"
#include "OMKUnInitialisedOutputException.h"
#include "OMKTracer.h"
#include "OMKInvalidOutputException.h"
#include "OMKInputConnectionEventListener.h"

namespace OMK
{
template< typename T >
class Input : public AbstractInput< T >
{
public:
  using AbstractInput< T >::isConnectable;
  using AbstractInput< T >::getConnectionEventId;
  using AbstractInput< T >::getConnectionToControlParameterEventId;
  using AbstractInput< T >::getName;
protected:
  using AbstractInput< T >::_owner ;
  using AbstractInput< T >::_precisionLevel;
  using AbstractInput< T >::_name;

public:

  Input( const Name & inputName, SimulatedObject & owner, bool makeConnectable, const int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


  /* Destructor
  */
  virtual ~Input() ;


  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 bool isConnected() ;

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


  virtual int getDistanceToExactValue() const;


  virtual const T & getLastExactValue() const ;


  virtual const Date & getDateOfLastExactValue() const ;


  virtual void printDebuggingInformation( std::ostream & err ) const ;


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

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


  virtual void outputDestroyed() ; 

  virtual bool realConnect( OutputNT * output ) ;

protected:

  int _distanceToExactValueOfLastGet ; 


  Output<T> * _connectedOutput;


  T _calculatedResult ;

  InputConnectionEventListener<T> * _associatedEventListener ;

} ; // Input

} // namespace OMK


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


#include "OMKControlParameter.h"

namespace OMK
{

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

template< typename T >
Input<T>::Input( const Name & inputName, SimulatedObject & owner,
                 bool makeConnectable,
                 const int precisionLevel )
  : AbstractInput<T>( inputName, owner, makeConnectable, precisionLevel ),
    _connectedOutput( 0 )
{
  /* 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 InputConnectionEventListener<T>(
    owner, this ) ;
};

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

template< typename T >
Input<T>::~Input() 
{
  delete _associatedEventListener ;
  if( _connectedOutput )
  {
    _connectedOutput->disconnectedMyself( this ) ;
  }
}

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

template< typename T >
inline void Input<T>::disconnect() 
{
  if( _connectedOutput )
  {
    _connectedOutput->disconnectedMyself( this ) ;
    _connectedOutput = 0 ;
  }
}

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

template< typename T >
inline bool Input<T>::connect( const Name & objectName,
                               const Name & outputName ) 
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE,
             "Input: trying connection with object \"" << objectName
             << "\" on output \"" << outputName << "\"" ) ;
  SimulatedObject * object =
    _owner.getController().getPointerToSimulatedObjectNamed( objectName ) ;
  bool ok = false ;
  if( object ) 
  {
    OutputNT * output = object->getPointerToOutputNamed( outputName ) ;
    if( output != 0 )
    {
      ok = realConnect( output ) ;
    }
    else
    {
      OMERROR( "Output \"" << outputName
               << "\" not found on object \"" << objectName << "\"" ) ;
    }
  } 
  else
  {
    std::ostringstream msg ;
    printDebuggingInformation( msg ) ;
    OMERROR( msg.str() << "Input<T>::connect \"" << objectName
             << "\" unknown" ) ;
  }
  return ok ;
}

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

template< typename T >
inline bool Input<T>::connect( const Name & objectName,
                               const Name & outputName,
                               const T & initialValue ) 
{
  bool connected = false ;
  if( connect( objectName, outputName ) && _connectedOutput )
  {
    _connectedOutput->suggest( initialValue ) ;
    connected = true ;
  }
  return connected ;
}

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

template< typename T >
inline bool Input<T>::connect( SimulatedObject & object,
                               const Name & outputName,
                               const T & initialValue ) 
{
  bool connected = false ;
  if( connect( object, outputName ) )
  {
    _connectedOutput->suggest( initialValue ) ;
    connected = true ;
  }
  return connected ;
}

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

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

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

template< typename T >
inline bool Input<T>::connect( SimulatedObject & object,
                               const Name & outputName ) 
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE, "Input<T>::connect( \""
             << object.getName() << "\", \"" << outputName << "\" )" ) ;
  return realConnect( object.getPointerToOutputNamed( outputName ) ) ;
}

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

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

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

template< typename T >
inline bool Input<T>::connectToControlParameter(
  const Name& objectName,
  const Name& controlParameterName ) 
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE,
             "Input<T>::connectToControlParameter( \""
             << objectName << "\", \"" << controlParameterName
             << "\" )" ) ;
  SimulatedObject * object =
    _owner.getController().getPointerToSimulatedObjectNamed( objectName ) ;
  bool ok = false ;
  if( object ) 
  {
    ok = realConnect( object->getPointerToControlParameterNamed( 
                        controlParameterName ) ) ;
  } 
  else 
  {
    std::ostringstream msg ;
    printDebuggingInformation( msg ) ;
    OMERROR( msg.str() << "Input<T>::connectToControlParameter "
             << objectName << " unknown" ) ;
  }
  return ok ;
}

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

template< typename T >
inline bool Input<T>::connectToControlParameter(
  const Name& objectName,
  const Name& controlParameterName,
  const T& initialValue ) 
{
  bool ok = false ;
  if( connect( objectName, controlParameterName ) && _connectedOutput )
  {
    _connectedOutput->suggest( initialValue ) ;
    ok = true ;
  }
  return ok ;
}

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

template< typename T >
inline bool Input<T>::connectToControlParameter(
  SimulatedObject& object,
  const Name& controlParameterName,
  const T& initialValue ) 
{
  bool ok = false ;
  if( connect( object, controlParameterName ) && _connectedOutput )
  {
    _connectedOutput->suggest( initialValue ) ;
    ok = true ;
  }
  return ok ;
}

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

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

//-----------------------------------------------------------------------------
template< typename T >
inline bool Input<T>::connectToControlParameter(
  SimulatedObject & object,
  const Name & controlParameterName ) 
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE,
             "Input<T>::connectToControlParameter( \""
             << object.getName() << "\", \"" << controlParameterName
             << "\" )" ) ;
  return realConnect( object.getPointerToControlParameterNamed(
                        controlParameterName ) ) ;
}

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

template< typename T >
inline bool Input<T>::connectToControlParameter(
  SimulatedObject * object,
  const Name & controlParameterName )
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE,
             "Input<T>::connectToControlParameter( \""
             << object->getName() << "\", \"" << controlParameterName
             << "\" )" ) ;
  return AbstractInput<T>::connectToControlParameter(
    object, controlParameterName ) ;
}


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

template< typename T >
inline bool Input<T>::realConnect( OutputNT * output ) 
{
  /* if the current active object isn't initialised or is the owner
   * of the input, proceed with connection
   */
  if( CurrentActiveObject::getCurrentActiveObject() == &_owner ||
      CurrentActiveObject::getCurrentActiveObject() == &_owner.getController() ||
      CurrentActiveObject::getCurrentActiveObject() == 0 )
  {
    // BEGIN TDTD add because problems with local objects // 10-04-2006
    if( _connectedOutput != 0 ) 
    {
      disconnect() ;
    }
    // END TDTD
    _connectedOutput = dynamic_cast< Output< T > * >( output ) ;

    if( _connectedOutput == 0 ) 
    {
      std::ostringstream msg ;
      printDebuggingInformation( msg ) ;
      if( output )
      {
        output->printDebuggingInformation( msg ) ;
      }
      OMERROR( msg.str()
               << ":-( Input::realConnect outpout is of wrong type or null" ) ;
      return false ;
    }
    else 
    {
      _connectedOutput->connectedMyself( this ) ;
      return true ;
    }
  }
  else if( isConnectable() )
  {
    ControlParameter<T> * controlParameter =
      dynamic_cast<ControlParameter<T> *>( output ) ;
    if( controlParameter == 0 )
    {
      CurrentActiveObject::getCurrentActiveObject()->sendValuedEvent(
        _owner,
        getConnectionEventId(),
        output->getName() ) ;
    }
    else
    {
      CurrentActiveObject::getCurrentActiveObject()->sendValuedEvent(
        _owner,
        getConnectionToControlParameterEventId(),
        output->getName() ) ;
    }
    return true ;
  }
  else
  {
    OMERROR( "Warning: " << _owner.getName() << "::" <<getName()
             << " is not connectable" ) ;
    return false ;
  }
}

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

template< typename T >
inline const OutputNT * Input<T>::getConnectedOutput() const
{
  return _connectedOutput ;
}

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

template< typename T >
inline const T & Input<T>::get( int deltaT ) 
{
  OMTRACEID( OMK_DEBUG_OMK_TYPE,
             "Input<T>::localGet calling get of _connectedOutput" ) ;
  if( !_connectedOutput )
  {
    OMERROR( "Input< " << typeid( T ).name() << " >::get \n"
             << "Of owner \"" << _owner.getName()
             << "\" named \"" << _name << "\"" ) ;
    throw InvalidOutputException() ;
  }
  return _connectedOutput->get( _distanceToExactValueOfLastGet,
                                _precisionLevel, 
                                deltaT,
                                _calculatedResult ) ;
}

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

template< typename T >
inline const T & Input<T>::getLastExactValue() const 
{
  if( !_connectedOutput )
  {
    OMERROR( "Input< " << typeid( T ).name()
             << " >::getLastExactValue \n"
             << "Of owner \"" << _owner.getName()
             << "\" named \"" << _name << "\"" ) ;
    throw InvalidOutputException() ;
  }
  return _connectedOutput->getLastExactValue() ;
}

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

template< typename T >
inline const Date & Input<T>::getDateOfLastExactValue() const 
{
  if( !_connectedOutput )
  {
    OMERROR( "Input< " << typeid( T ).name()
             << " >::getDateOfLastExactValue \n"
             << "Of owner \"" << _owner.getName()
             << "\" named \"" << _name << "\"" ) ;
    throw InvalidOutputException() ;
  }
  return _connectedOutput->getDateOfLastExactValue() ;
}

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

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

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

template< typename T >
inline void Input<T>::extract( std::istream & in )
{
  OMASSERTM( false, "shouldn't be called" ) ;
  in >> *_connectedOutput ;
}

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

template< typename T >
inline void Input<T>::insertInStream( std::ostream & out ) const
{
  OMASSERTM( false, "shouldn't be called" ) ;
  out << *_connectedOutput << " " ;
}

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

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

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

template< typename T >
inline void Input<T>::outputDestroyed() 
{
  _connectedOutput = 0 ;
} 

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

template< typename T >
inline bool Input<T>::isConnected() 
{
  return _connectedOutput != 0 ;
} 

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

} // namespace OMK

#endif

---