OMKIAttribute.cpp

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) 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   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
                
#include "OMKIAttribute.h"
#include "OMKExtensibleSimulatedObject.h"
#include "OMKInputNT.h"
#include "OMKOutputNT.h"
#include "OMKEventListenerCallBack.h"
#include "OMKParametersAccessor.inl"
#include "OMKSimpleTypeT.inl"


namespace OMK 
{
namespace EventId 
{

//-----------------------------------------------------------------
EventIdentifier CURRENT_ATTRIBUTE_VALUE( "current_attribute_value" ) ;
//-----------------------------------------------------------------
EventIdentifier getCurrentValueEventId( const std::string& id ) 
{ 
  return EventIdentifier( ( "current_value_of_attribute_" + id ).c_str() ) ; 
}
//-----------------------------------------------------------------
EventIdentifier getGetValueEventId( const std::string& id ) 
{ 
  return EventIdentifier( ( "get_value_of_attribute_" + id ).c_str() ) ; 
}
//-----------------------------------------------------------------
EventIdentifier getConnectToEventId( const std::string& id ) 
{ 
  return EventIdentifier( ( "connect_to_attribute_" + id ).c_str() ) ; 
}
//-----------------------------------------------------------------
EventIdentifier getDisconnectEventId( const std::string& id ) 
{ 
  return EventIdentifier( ( "disconnect_attribute_" + id ).c_str() ) ; 
}
//-----------------------------------------------------------------

} // namespace EventId
} // namespace OMK

using namespace OMK ;
//=================================================================

//-----------------------------------------------------------------
IAttribute::IAttribute( const Name& id ) 
: _owner( 0 ),
  _id( id ),
  _updated( false ),
  _connectToListener     ( 0 ),
  _disconnectListener    ( 0 ),
  _connectToId     ( EventId::getConnectToEventId   ( id.getCString() ) ),
  _disconnectId    ( EventId::getDisconnectEventId  ( id.getCString() ) ),
  _getValueListener      ( 0 ),
  _currentValueListener  ( 0 ),
  _currentValueOfListener( 0 ),
  _getValueId      ( EventId::getGetValueEventId    ( id.getCString() ) ),
  _currentValueOfId( EventId::getCurrentValueEventId( id.getCString() ) )
{
}

//-----------------------------------------------------------------
IAttribute::~IAttribute() 
{
  // Delete the event listeners
  delete _connectToListener ;
  delete _disconnectListener ;
  delete _getValueListener ;
  delete _currentValueListener ;
  delete _currentValueOfListener ;
  if( _owner ) _owner->removeAttribute( getId() ) ;
}

//-----------------------------------------------------------------
const ExtensibleSimulatedObject* const
IAttribute::getOwner() const
{
        return _owner ;
}

//-----------------------------------------------------------------
void IAttribute::setOwner( ExtensibleSimulatedObject* owner, bool withOutput ) 
{
  // Set the owner
  OMASSERTM( !_owner, "cannot be intialised twice !" ) ;
  _owner = owner ;
  OMASSERTM( _owner, "must be valid !" ) ;

  // Look for the creation of the associated output
  bool createOutputCfg = false ;
  std::string strId( getId().getCString() ) ;
  ParametersAccessor::get( _owner->getConfigurationParameters(), strId + "Output" , createOutputCfg ) ;

  if( withOutput || createOutputCfg )
  {
    createOutput() ;
  }
}
//-----------------------------------------------------------------
bool IAttribute::loadParameters( const ConfigurationParameterDescriptor * node, 
                                 const std::string* aliasName ) 
{
  std::string strId( aliasName ? *aliasName : getId().getCString() ) ;
  // Read parameters to connect the input, ignores if cannot
  // to get the parameters
  std::pair< std::string, std::string > connectParam; // first = target name / second = output name
  if( ParametersAccessor::get( node, strId + "Connect", connectParam ) )
  {
    connectTo( connectParam.first, connectParam.second ) ;
  }
  // Event activation
  bool activate = false ;
  std::vector< Name > emitters ;

  activate = false ;
  ParametersAccessor::get( node, strId + "ConnectByEvent", activate ) ;
  if( activate ) activateConnectByEvent()  ;
  activate = false ;
  emitters.clear() ;
  if( ParametersAccessor::get( node, strId + "ConnectBySignal", activate )
   && activate ) 
  {
    activateConnectBySignal()  ;
  }
  else if( ParametersAccessor::get( node, strId + "ConnectBySignal", emitters ) )
  {
    for( size_t i = 0 ; i < emitters.size() ; i++ )
    {
      activateConnectBySignal( emitters[ i ] ) ;
    }
  }

  activate = false ;
  ParametersAccessor::get( node, strId + "GetByEvent", activate ) ;
  if( activate ) activateGetByEvent() ;
  activate = false ;
  emitters.clear() ;
  if( ParametersAccessor::get( node, strId + "GetBySignal", activate ) 
   && activate ) 
  {
    activateGetBySignal() ;
  }
  else if( ParametersAccessor::get( node, strId + "GetBySignal", emitters ) )
  {
    for( size_t i = 0 ; i < emitters.size() ; i++ )
    {
      activateGetBySignal( emitters[ i ] ) ;
    }
  }


  activate = false ;
  ParametersAccessor::get( node, strId + "SetByEvent", activate ) ;
  if( activate ) activateSetByEvent() ;
  activate = false ;
  emitters.clear() ;
  if( ParametersAccessor::get( node, strId + "SetBySignal", activate ) 
   && activate ) 
  {
    activateSetBySignal() ;
  }
  else if( ParametersAccessor::get( node, strId + "SetBySignal", emitters ) )
  {
    for( size_t i = 0 ; i < emitters.size() ; i++ )
    {
      activateSetBySignal( emitters[ i ] ) ;
    }
  }

  activate = false ;
  ParametersAccessor::get( node, strId + "SetByEventOf", activate ) ;
  if( activate ) activateSetByEventOf() ;
  activate = false ;
  emitters.clear() ;
  if( ParametersAccessor::get( node, strId + "SetBySignalOf", activate )
   && activate ) 
  {
    activateSetBySignalOf() ;
  }
  else if( ParametersAccessor::get( node, strId + "SetBySignalOf", emitters ) )
  {
    for( size_t i = 0 ; i < emitters.size() ; i++ )
    {
      activateSetBySignalOf( emitters[ i ] ) ;
    }
  }

  return true ;
}

//-----------------------------------------------------------------
void IAttribute::activateConnectByEvent() 
{
  if( !_connectToListener )
  {
    _connectToListener = new ConnectToEventListener
      ( *_owner, this, 
        (ConnectToEventListener::CallBackFct)&IAttribute::processConnectTo, 
        _connectToId ) ;
    _disconnectListener = new EventListenerCallBack< IAttribute >
      ( *_owner, this, 
        (EventListenerCallBack< IAttribute >::CallBackFct)&IAttribute::processDisconnect, 
        _disconnectId ) ;
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
      "Information for " << OMK::debugMsg( this ) << std::endl
      << ">>> :-) Connection by event is activated!" ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::activateConnectBySignal( const Name& emitter ) 
{
  activateConnectByEvent() ;
  if( emitter.undefined() )
  {
    _owner->registerForSignal( _connectToId ) ;
    _owner->registerForSignal( _disconnectId ) ;
  }
  else
  {
    _owner->registerForSignalBy( _connectToId, emitter ) ;
    _owner->registerForSignalBy( _disconnectId, emitter ) ;
  }
}

//-----------------------------------------------------------------
void IAttribute::activateGetByEvent() 
{
  if( !_getValueListener )
  {
    _getValueListener = new EventListenerCallBack< IAttribute >
      ( *_owner, this, 
        (EventListenerCallBack< IAttribute >::CallBackFct)&IAttribute::processGetValue, 
        _getValueId ) ;
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
      "Information for " << OMK::debugMsg( this ) << std::endl
      << ">>> :-) Get by event is activated!" ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::activateGetBySignal( const Name& emitter ) 
{
  activateGetByEvent() ;
  if( emitter.undefined() )
  {
    _owner->registerForSignal( _getValueId ) ;
  }
  else
  {
    _owner->registerForSignalBy( _getValueId, emitter ) ;
  }
}

//-----------------------------------------------------------------
bool IAttribute::connectTo( const Name &objectName, const Name &outputName ) 
{
  InputNT *associatedInput = getInput() ;
  if( !associatedInput )
  { // No input defined => create it and try again
    createInput() ;
    associatedInput = getInput() ;
  }
  bool ok = associatedInput && associatedInput->connect( objectName, outputName ) ;
  if( !ok )
  {
    // No associated input or unable to connect
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
               "Error for " << OMK::debugMsg( this ) << std::endl
                   << ">>> :-( Unable to connect the attribute to the output \"" << outputName.getString() 
                   << "\" of the object \"" << objectName.getString() << "\" !" ) ;
  }
  else
  {
    // No associated input or unable to connect
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
               "Information for " << OMK::debugMsg( this ) << std::endl
                   << ">>> :-) Connect the attribute to the output \"" << outputName.getString() 
                   << "\" of the object \"" << objectName.getString() << "\" !" ) ;
  }
  return ok ;
}

//-----------------------------------------------------------------
void IAttribute::disconnect() 
{
  InputNT *associatedInput = getInput() ;
  if( associatedInput ) associatedInput->disconnect() ;
}

//-----------------------------------------------------------------
bool IAttribute::processConnectTo( ConnectToEvent* e ) 
{
  OMASSERTM( _connectToId == e->eventId, "Not the good event id !" ) ;
  return connectTo( e->value.getValue().first, e->value.getValue().second ) ;
}

//-----------------------------------------------------------------
bool IAttribute::processDisconnect( Event* e ) 
{
  disconnect() ;
  return true ;
}

//-----------------------------------------------------------------
void IAttribute::activateSetBySignal( const Name& emitter ) 
{
  activateSetByEvent() ;
  if( emitter.undefined() )
  {
    _owner->registerForSignal( EventId::CURRENT_ATTRIBUTE_VALUE ) ;
  }
  else
  {
    _owner->registerForSignalBy( EventId::CURRENT_ATTRIBUTE_VALUE, emitter ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::activateSetBySignalOf( const Name& emitter ) 
{
  activateSetByEventOf() ;
  if( emitter.undefined() )
  {
    _owner->registerForSignal( _currentValueOfId ) ;
  }
  else
  {
    _owner->registerForSignalBy( _currentValueOfId, emitter ) ;
  }
}
//-----------------------------------------------------------------
bool IAttribute::processGetValue( Event* e ) 
{
  ValuedEvent< Name >* eventName = dynamic_cast< ValuedEvent< Name >* >( e ) ;
  if( eventName )
  {
    sendValue( e->sender, EventId::getCurrentValueEventId( eventName->value.getString() ) ) ;
  }
  else
  {
    sendValue( e->sender, _currentValueOfId ) ;
  }
  return true ;
}
//-----------------------------------------------------------------
void IAttribute::sendValueTo( const Name &receiver, const Name &attributeId, bool genericId )
{
  if( genericId )
  {
    sendIdAndValue( receiver, EventId::CURRENT_ATTRIBUTE_VALUE, attributeId ) ;
  }
  else
  {
    sendValue( receiver, EventId::getCurrentValueEventId( attributeId.getString() ) ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::sendValueOf( const Name &receiver, bool genericId ) 
{
  if( genericId )
  {
    sendIdAndValue( receiver, EventId::CURRENT_ATTRIBUTE_VALUE, getId() ) ;
  }
  else
  {
    sendValue( receiver, _currentValueOfId ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::fireValueTo( const Name &attributeId, bool genericId )
{
  if( genericId )
  {
    fireIdAndValue( EventId::CURRENT_ATTRIBUTE_VALUE, attributeId ) ;
  }
  else
  {
    fireValue(  EventId::getCurrentValueEventId( attributeId.getString() ) ) ;
  }
}
//-----------------------------------------------------------------
void IAttribute::fireValueOf( bool genericId )
{
  if( genericId )
  {
    fireIdAndValue( EventId::CURRENT_ATTRIBUTE_VALUE, getId() ) ;
  }
  else
  {
    fireValue( _currentValueOfId ) ;
  }
}
//-----------------------------------------------------------------

---