OMKSimulatedObject.inl

Go to the documentation of this file.

#ifndef OMKSimulatedObjectINL
#define OMKSimulatedObjectINL

#include "OMKController.h"
#include "OMKValuedEvent.h"
#include "OMKObjectHandle.h"
#include "OMKUnallowedOverloadingException.h"

//  Implementation of template member functions

namespace OMK
{
//-----------------------------------------------------------------------------
template < typename Type >
std::list< const ObjectDescriptor * > * SimulatedObject::listSonsOfType()
{
  return getObjectDescriptor().template listSonsOfType< Type >() ;
}
//-----------------------------------------------------------------------------
template < typename Type >
std::list< const ObjectDescriptor * > * SimulatedObject::listBrothersOfType()
{
   OMASSERT( getObjectDescriptor().getFathersObjectDescriptor() != 0 ) ;
   return getObjectDescriptor().
             getFathersObjectDescriptor()->template listSonsOfType< Type >() ;
}
//-----------------------------------------------------------------------------
template < typename Type >
std::list< const ObjectDescriptor * > * SimulatedObject::listDescendantsOfType()
{
  return getObjectDescriptor().template listDescendantsOfType< Type >();
}
//-----------------------------------------------------------------------------
template < typename UserType >
void SimulatedObject::fireValuedSignal( const EventIdentifier &sig,
                                        const UserType &value )
{
  ValuedEvent< UserType > event( sig, getSimulatedDate(), getName(),
                                 getName(), value) ;
  if( getObjectHandle() != 0 )
  {
    getObjectHandle()->sendEventsForSignal( event , sig ) ;
  }
  else
  {
    getController().broadcastEventsForSignal( event, sig ) ;
  }
}
//-----------------------------------------------------------------------------
template < typename Type >
Input< Type > & SimulatedObject::addInput( const Name &inputName,
                                           bool makeConnectable,
                                           int precisionLevel ) 
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( inputName ) ) ;
  Input< Type > * input( 0 ) ;
  if( redefinedInput == 0 )
  {
    input = _controller.template createInput< Type >( inputName, *this,
                                                      makeConnectable,
                                                      precisionLevel ) ;
  }
  else 
  {
    input = dynamic_cast< Input< Type > * >( redefinedInput ) ;
    if( input == 0 ) 
    {
      throw UnallowedOverloadingException( inputName, getName() ) ;
    }
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "input \"" << inputName
                 << "\" of " << OMK::debugMsg( this )
                 <<" already defined. No new input created : reference to old one used" ) ;
    }
  }
  return *input ;
}
//-----------------------------------------------------------------------------
template < typename Type >
SensitiveInput<Type> & SimulatedObject::addSensitiveInput( const Name &inputName,
                                                           bool makeConnectable,
                                                           int precisionLevel ) 
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( inputName ) ) ;
  SensitiveInput< Type > *input( 0 ) ;
  if( redefinedInput == 0 )
  {
    input = _controller.template createSensitiveInput< Type >( inputName,
                                                               *this,
                                                               makeConnectable,
                                                               precisionLevel );
  }
  else
  {
    input = dynamic_cast< SensitiveInput< Type > * >( redefinedInput ) ;
    if( input == 0 )
    {
      throw UnallowedOverloadingException( inputName, getName() ) ;
    }
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "sensitiveInput \"" << inputName
                 << "\" of " << OMK::debugMsg( this )
                 <<" already defined. No new sensitiveInput created : reference to old one used" ) ;
    }
  }
  return *input ;
}
//-----------------------------------------------------------------------------
template < typename Type >
SensitiveNotifyingInput< Type > & SimulatedObject::addSensitiveNotifyingInput(
  const Name &inputName,
  bool makeConnectable,
  int precisionLevel ) 
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( inputName ) ) ;
  SensitiveNotifyingInput< Type > *input( 0 ) ;
  if( redefinedInput == 0 ) 
  {
    input = _controller.template createSensitiveNotifyingInput< Type >(
      inputName, *this, makeConnectable, precisionLevel ) ;
  }
  else 
  {
    input = dynamic_cast< SensitiveNotifyingInput< Type > * >( redefinedInput ) ;
    if( input == 0 )
    {
      throw UnallowedOverloadingException( inputName, getName() ) ;
    }
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "sensitiveNotifyingInput \"" << inputName
                 << "\" of " << OMK::debugMsg( this ) 
                 << " already defined. No new sensitiveNotifyingInput created : reference to old one used" ) ;
    }
  }
  return *input ; 
}
//-----------------------------------------------------------------------------
template < typename Type >
Output< Type > & SimulatedObject::addOutput( const Name &outputName,
                                             OMK::Type::PolatorNT *polator )
{
  OutputNT *redefinedOutput( _outputTable.getObjectOfIndex( outputName ) ) ;
  Output< Type > *output( 0 );
  if( redefinedOutput == 0 )
  {
    output = _controller.template createOutput< Type >( outputName, *this,
                                                        polator ) ;
  }
  else 
  {
    output = dynamic_cast< Output< Type > * >( redefinedOutput ) ;
    if( output == 0 )
    {
      throw UnallowedOverloadingException( outputName, getName() ) ;
    }
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "output \"" << outputName << "\" of "
                 << OMK::debugMsg( this )
                 << " already defined. No new output created : reference to old one used" ) ;
    }
  } 
  _outputTable.addObjectWithIndex( outputName, output ) ;
  return *output ;
}
//-----------------------------------------------------------------------------
template < typename Type >
ControlParameter< Type > & SimulatedObject::addControlParameter(
  const Name &controlParameterName,
  OMK::Type::PolatorNT *polator )
{
  OutputNT *redefinedControlParameter( _controlParameterTable.getObjectOfIndex(
                                         controlParameterName ) ) ;
  ControlParameter< Type > *controlParameter( 0 ) ;
  if( redefinedControlParameter == 0 )
  {
    controlParameter = _controller.template createControlParameter< Type >(
      controlParameterName, *this, polator ) ;
  }
  else 
  {
    controlParameter = dynamic_cast < ControlParameter<Type> * >(
      redefinedControlParameter ) ;
    if( controlParameter == 0 )
    {
      throw UnallowedOverloadingException( controlParameterName, getName() ) ;
    }
    else 
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "controlParameter \"" <<
                 controlParameterName << "\" of " << OMK::debugMsg( this )
                 <<" already defined. No new controlParameter created : reference to old one used" ) ;
    }
  }
  OutputNT *realControlParameter( dynamic_cast< OutputNT * >( controlParameter ) ) ;
  OMASSERT( realControlParameter != 0 ) ; 
  _controlParameterTable.addObjectWithIndex( controlParameterName,
                                             realControlParameter ) ;
  return *controlParameter ;
}
//-----------------------------------------------------------------------------
template < typename Type >
InputAlias< Type > & SimulatedObject::addInputAlias( const Name &aliasName,
                                                     const Name &aliasedObjectName,
                                                     const Name &aliasedInputName,
                                                     int precisionLevel )
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( aliasName ) ) ;
  InputAlias< Type > *alias( 0 ) ;
  if( redefinedInput == 0 )
  {
    // make sure aliasedObjectName is an ancestor of object
    if( isAncestor( aliasedObjectName ) )
    {
      SimulatedObject *obj( _controller.getPointerToSimulatedObjectNamed(
                              aliasedObjectName ) ) ;
      InputNT *input( obj->_inputTable.getObjectOfIndex( aliasedInputName ) ) ;
      AbstractInput< Type > *realInput( dynamic_cast< AbstractInput< Type > * >(
                                          input ) ) ;
      if( realInput != 0 )
      {
        if( obj != 0 )
        {
          alias = _controller.template createInputAlias< Type >( aliasName,
                                                                 *this,
                                                                 realInput,
                                                                 precisionLevel ) ;
        }
        else
        {
          Controller::error( "imposible aliasing " ) ;
        }
      }
      else
      {
        Controller::error( "impossible aliasing, probably because of type mismatch" ) ;
      }
    }
    else
    {
      OMERROR( "SimulatedObject::createInputAlias \"" << aliasedObjectName
               << "\" isn't the father of " 
               << OMK::debugMsg( this )
               << " : aliasing is therefore impossible for alias named \""
               << aliasedInputName << "\"" ) ;
      Controller::error( "" ) ;
    }
  }
  else 
  {
    alias = dynamic_cast< InputAlias< Type > * >( redefinedInput ) ;
    if( alias == 0 )
    {
      throw UnallowedOverloadingException( aliasName, getName() ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "inputAlias \"" << aliasName
                 << "\" of " << OMK::debugMsg( this )
                 <<" already defined. No new inputAlias created : reference to old one used" ) ;
    }
  }
  return *alias ;
}
//-----------------------------------------------------------------------------
template < typename Type >
SensitiveInputAlias< Type > & SimulatedObject::addSensitiveInputAlias(
  const Name &aliasName,
  const Name &aliasedObjectName,
  const Name &aliasedInputName,
  int precisionLevel )
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( aliasName ) ) ;
  SensitiveInputAlias< Type > *alias( 0 ) ;
  if( redefinedInput == 0 )
  {
    // make sure aliasedObjectName is an ancestor of object
    if( isAncestor( aliasedObjectName ) )
    {
      SimulatedObject *obj( _controller.getPointerToSimulatedObjectNamed(
                              aliasedObjectName ) ) ;
      InputNT * input( obj->_inputTable.getObjectOfIndex( aliasedInputName ) ) ;
      AbstractInput< Type > *realInput( dynamic_cast< AbstractInput< Type > * >(
                                          input ) ) ;
      if( realInput != 0 )
      {
        if( obj != 0 )
        {
          alias = _controller.template createSensitiveInputAlias< Type >(
            aliasName, *this, realInput, precisionLevel ) ;
        }
        else
        {
          Controller::error( "Impossible aliasing " ) ;
        }
      }
      else
      {
        Controller::error( "impossible aliasing, probably because of type mismatch" ) ;
      }
    }
    else
    {
      OMERROR( "SimulatedObject::addSensitiveInputAlias \n" << aliasedObjectName
               << "\n isn't the father of " << OMK::debugMsg( this )
               << " : cannot create an alias of \""
               << aliasedInputName << "\"" ) ;
      throw UserException( "" ) ;
    }
  }
  else 
  {
    alias = dynamic_cast< SensitiveInputAlias< Type > * >( redefinedInput ) ;
    if( alias == 0 )
    {
      throw UnallowedOverloadingException( aliasName, getName() ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "sensitiveInputAlias \"" << aliasName
                 << "\" of " << OMK::debugMsg( this )
                 <<" already defined. No new sensitiveInputAlias created : reference to old one used" ) ;
    }
  }
  return *alias ;
}
//-----------------------------------------------------------------------------
template < typename Type > 
SensitiveNotifyingInputAlias< Type > & 
SimulatedObject::addSensitiveNotifyingInputAlias( const Name &aliasName,
                                                  const Name &aliasedObjectName,
                                                  const Name &aliasedInputName,
                                                  int precisionLevel )
{
  InputNT *redefinedInput( _inputTable.getObjectOfIndex( aliasName ) ) ;
  SensitiveNotifyingInputAlias< Type > *alias( 0 ) ;
  if( redefinedInput == 0 )
  {
    // make sure aliasedObjectName is an ancestor of object
    if( isAncestor( aliasedObjectName ) )
    {
      SimulatedObject *obj( _controller.getPointerToSimulatedObjectNamed(
                              aliasedObjectName ) ) ;
      InputNT *input( obj->_inputTable.getObjectOfIndex( aliasedInputName ) ) ;
      AbstractInput< Type > *realInput( dynamic_cast < AbstractInput< Type > * >(
                                          input ) ) ;
      if( realInput != 0 )
      {
        if( obj != 0 )
        {
          alias =
            _controller.template createSensitiveNotifyingInputAlias< Type >(
              aliasName, *this, realInput, precisionLevel ) ;
        }
        else
        {
          throw UserException( "Impossible aliasing " ) ;
        }
      }
      else
      {
        Controller::error( "alias type mismatch" ) ;
      }
    }
    else
    {
      OMERROR( "SimulatedObject::addSensitiveSeignalingInputAlias \""
               << aliasedObjectName << "\" isn' the father of "
               << OMK::debugMsg( this )
               << " : creation of alias named \"" << aliasedInputName
               << "\" impossible" ) ;
      throw UserException( "" );
    }
  }
  else
  {
    alias = dynamic_cast< SensitiveNotifyingInputAlias< Type > * >(
      redefinedInput ) ;
    if( alias == 0 )
    {
      throw UnallowedOverloadingException( aliasName, getName() ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC, "sensitiveNotifyingInputAlias \""
                 << aliasName << " of " << OMK::debugMsg( this )
                 <<" already defined. No new sensitiveNotifyingInputAlias : reference to old one used" ) ;
    }
  }
  return *alias ;
}
//-----------------------------------------------------------------------------
template < typename Type > 
OutputAlias< Type > & SimulatedObject::addOutputAlias(
  const Name &aliasName,
  const Name &aliasedObjectName,
  const Name &aliasedOutputName,
  OMK::Type::PolatorNT *interp )
{
  OutputNT *redefinedOutput( _outputTable.getObjectOfIndex( aliasName ) ) ;
  OutputAlias< Type > *alias( 0 ) ;
  std::list< const ObjectDescriptor * > *listeFils(
    getController().template listDescendantsOfType< SimulatedObject >(
      aliasedObjectName ) ) ;
  bool aliasedObjectPresent( false ) ;
   
  if( redefinedOutput == 0 ) 
  {
    // make sure aliasedObjectName is an ancestor of object
    if( listeFils != 0 )
    {
      std::list< const ObjectDescriptor * >::const_iterator listeFilsIterator(
        listeFils->begin() ) ;
      while( listeFilsIterator != listeFils->end() && !aliasedObjectPresent )
      {
        aliasedObjectPresent = ( (*listeFilsIterator)->getName() == getName() ) ;
        ++listeFilsIterator ;
      }       
      delete listeFils ;
    }
    if( aliasedObjectPresent )
    {
      SimulatedObject *obj( _controller.getPointerToSimulatedObjectNamed(
                              aliasedObjectName ) ) ;
      OutputNT *Outputnt( obj->getPointerToOutputNamed( aliasedOutputName ) ) ;
      Output< Type > *refOutput( dynamic_cast< Output< Type > * >( Outputnt ) ) ;
      if( refOutput != 0 )
      {
        if( obj != 0 ) 
        {
          alias = _controller.template createOutputAlias< Type >(
            aliasName, *this, refOutput, interp ) ;
        }
        else
        {
          OMERROR( "SimulatedObject::addOutputAlias " << std::endl 
                   << "alias \"" << aliasName
                   << "\" cannot be made on inexistant \""
                   << aliasedOutputName << "\"" ) ;
          throw UserException( "" ) ;
        }
      }
      else
      {
        throw UserException( "Impossible output aliasing : type mismatch" ) ;
      }
    }
    else
    {
      OMERROR( "SimulatedObject::addOutputAlias \"" << aliasedObjectName
               << "\" isn't the father of "  << OMK::debugMsg( this )
               << " : not possible to alias \""
               <<  aliasedOutputName << "\"" ) ;
      Controller::error( "" ) ;
    }
  }
  else
  {
    alias = dynamic_cast< OutputAlias< Type > * >( redefinedOutput ) ;
    if( alias == 0 )
    {
      throw UnallowedOverloadingException( aliasName, getName() ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_EXEC,
                 "outputAlias already defined. No new outputAlias created : reference to old one used" ) ;
    }
  }
  _outputTable.addObjectWithIndex( aliasName, alias ) ;
  return *alias ;
}
//-----------------------------------------------------------------------------
template < typename UserType >
void SimulatedObject::sendValuedEvent( const Name &receiver,
                                       const EventIdentifier &eventId,
                                       const UserType &userInfo )
{
  SimulatedObject *receiverObject(
    _controller.getPointerToSimulatedObjectNamed( receiver ) ) ;
  if( receiverObject == 0 )
  {
    getController().addToPendingEvents(
      new ValuedEvent< UserType >( eventId,
                                   _controller.getSimulatedDate(),
                                   getName(),
                                   receiver,
                                   userInfo ) ) ;
  }
  else
  {
    sendValuedEvent( receiverObject, eventId, userInfo ) ;
  }
}
//-----------------------------------------------------------------------------
template < typename UserType >
void SimulatedObject::sendValuedEvent( SimulatedObject *receiver,
                                       const EventIdentifier &eventId,
                                       const UserType &userInfo)
{
  if( receiver->getObjectHandle() == 0 )
  {
    getController().addToPendingEvents(
      new ValuedEvent< UserType >( eventId,
                                   _controller.getSimulatedDate(),
                                   getName(),
                                   receiver->getName(),
                                   userInfo ) ) ;
  }
  else
  {
    receiver->getObjectHandle()->receiveEvent(
      new ValuedEvent< UserType >( eventId,
                                   _controller.getSimulatedDate(),
                                   getName(),
                                   receiver->getName(),
                                   userInfo ) ) ;
  }
}
//-----------------------------------------------------------------------------
template < typename UserType >
void SimulatedObject::sendValuedEvent( SimulatedObject &receiver,
                                       const EventIdentifier &eventId,
                                       const UserType &userInfo )
{
  sendValuedEvent( &receiver, eventId, userInfo ) ;
}
//-----------------------------------------------------------------------------
} // namespace OMK

#endif // OMKSimulatedObjectINL

---