OMKAbstractInput.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 AbstractInputHEADER
#define AbstractInputHEADER

#include "OMKSimulatedObject.h"
#include "OMKController.h"
#include "OMKInputNT.h"

namespace OMK
{
template < class Type >
class AbstractInput : public InputNT
{
public:
   
  AbstractInput( const Name & inputName, SimulatedObject & owner, bool makeConnectable, const int precisionLevel = OMK::Type::PolatorNT::defaultPrecisionLevel ) ;


   virtual ~AbstractInput() ;
   

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


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


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


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


   virtual bool connect( SimulatedObject & object, const Name & outputName, const Type & initialValue ) = 0 ;


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


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


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


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


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


   virtual bool connectToControlParameter( SimulatedObject & object, const Name & controlParameterName, const Type & initialValue ) = 0 ;


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


   virtual bool isConnectable() const ;

   bool isConnected() const { return getConnectedOutput() != 0 ; }

   
   virtual void setConnectable( bool nextConnectableState ) ;


   virtual const OutputNT * getConnectedOutput() const = 0 ;


   const EventIdentifier & getConnectionEventId() const ;


   const EventIdentifier & getConnectionToControlParameterEventId() const ;


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


  virtual int getDistanceToExactValue() const = 0;


   virtual const Type & getLastExactValue() const = 0 ;
   

   virtual const Date & getDateOfLastExactValue() const = 0 ;
   

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


   virtual int getPrecisionLevel() const ;


   virtual int setPrecisionLevel( const int newValue ) ;


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


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


protected:
   std::list<InputAlias<Type> *> _listOfAliases ;

   int _precisionLevel ;

   bool _connectable ;

   const EventIdentifier _connectionEventId ;

   const EventIdentifier _connectionToControlParameterEventId ;

} ; // AbstractInput

} // namespace OMK


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


#include "OMKCurrentActiveObject.h"
#include "OMKInputAlias.h"

namespace OMK
{

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

template < typename Type >
inline AbstractInput< Type >::AbstractInput( const Name & inputName,
                                             SimulatedObject & owner,
                                             bool makeConnectable,
                                             const int precisionLevel )
  : InputNT( owner, inputName ),
    _precisionLevel( precisionLevel ),
    _connectable( makeConnectable ),
    _connectionEventId( ( "newConnection " + inputName.getString() ).c_str() ),
    _connectionToControlParameterEventId( ( "newConnectionToControlParameter "
                                            + inputName.getString() ).c_str() )
{
#ifdef _DEBUGTYPEUTIL
  std::cout << "AbstractInput<Type>::AbstractInput --> constructor " 
            << std::endl ;
#endif
  registerMe() ;
}

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

template< typename Type >
inline AbstractInput< Type >::~AbstractInput()
{
  typename std::list< InputAlias< Type > * >::iterator i ;
  for( i =_listOfAliases.begin() ; i != _listOfAliases.end() ; ++i )
  {
    (*i)->inputAliasedDeleted() ;
  }
}

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

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

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

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

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

template< typename Type >
inline void AbstractInput< Type >::notifyAliasing(
  InputAlias< Type > * aliasingInputAlias )
{
  if( aliasingInputAlias != 0 )
  {
    _listOfAliases.push_back( aliasingInputAlias ) ;
  }
}

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

template< typename Type >
inline void AbstractInput< Type >::notifyUnaliasing(
  InputAlias< Type > * aliasingInputAlias )
{
  if( aliasingInputAlias != 0 )
  {
    _listOfAliases.push_back( aliasingInputAlias ) ;
  }
}

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

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

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

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

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

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

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

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

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

template< typename Type >
inline bool AbstractInput< Type >::connect( SimulatedObject * pointerToObject,
                                            const Name & outputName )
{
  if( pointerToObject != 0 )
  {
    return connect( *pointerToObject, outputName ) ;
  }
  else
  {
    OMERROR( "AbstractInput<Type>::connect : got null pointer" ) ;
    printDebuggingInformation( std::cerr ) ;
    return false ;
  }
}

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

template< typename Type >
inline bool AbstractInput< Type >::connect( SimulatedObject * pointerToObject,
                                            const Name & outputName,
                                            const Type & initialValue )
{
  if( pointerToObject != 0 )
  {
    return connect( *pointerToObject, outputName, initialValue ) ;
  }
  else
  {
    OMERROR( "AbstractInput< Type >::connect : got null pointer" ) ;
    printDebuggingInformation( std::cerr ) ;
    return false ;
  }
}

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

template< typename Type >
inline bool AbstractInput< Type >::connectToControlParameter(
  SimulatedObject * pointerToObject,
  const Name & outputName )
{
  if( pointerToObject != 0 )
  {
    return connectToControlParameter( *pointerToObject, outputName ) ;
  }
  else
  {
    OMERROR( "AbstractInput< Type >::connect : got null pointer" ) ;
    printDebuggingInformation( std::cerr ) ;
    return false ;
  }
}

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

template< typename Type >
inline bool AbstractInput< Type >::connectToControlParameter(
  SimulatedObject * pointerToObject,
  const Name & outputName,
  const Type & initialValue )
{
  if( pointerToObject != 0 )
  {
    return connectToControlParameter( *pointerToObject,
                                      outputName,
                                      initialValue ) ;
  }
  else
  {
    OMERROR( "AbstractInput< Type >::connect : got null pointer" ) ;
    printDebuggingInformation( std::cerr ) ;
    return false ;
  }
}

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

} // namespace OMK

#endif

---