OMKExtensibleSimulatedObject.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 "OMKExtensibleSimulatedObject.h"
#include "OMKExtension.h"
#include "OMKIAttribute.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKParametersAccessor.inl"
#include <vector>
#include <string>
#include <iostream>

namespace OMK
{
namespace EventId 
{
EventIdentifier CREATE_AND_ADD_EXTENSION( "Create_and_add_extension" ) ;
}
}
using namespace OMK ;
//-----------------------------------------------------------------

// Default constructor
ExtensibleSimulatedObject::ExtensibleSimulatedObject( Controller& ctrl, const ObjectDescriptor& objectDescriptor )
: SimulatedObject( ctrl, objectDescriptor ),
  ExtensionManager(),
  _exitOnInitError( true )
{
}

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

// Destructor
ExtensibleSimulatedObject::~ExtensibleSimulatedObject()
{
}
//-----------------------------------------------------------------
void ExtensibleSimulatedObject::postConstruction() 
{
  // Retrieve the extension fields to create the extensions which defined a "Class"
  createExtensionsFromParameters( this, getObjectDescriptor().getExtensionsParameters() ) ;
}
//-----------------------------------------------------------------

// finish
void ExtensibleSimulatedObject::finish()
{
  // Destroy every extensions
  deleteExtensions() ;
  // Calls the ancestor
  SimulatedObject::finish() ;
}
//-----------------------------------------------------------------
// Initialisation
void ExtensibleSimulatedObject::init()
{
  bool ok = true ;

  // The configuration parameter node
  const ConfigurationParameterDescriptor* node = getConfigurationParameters() ;
  const ConfigurationParameterDescriptor* extensionsNode = getObjectDescriptor().getExtensionsParameters() ;
  //---Load Extension order if there is one
  loadOrder( extensionsNode, "LoadParametersOrder", _orderedExtensionsForLoadParameters ) ;
 
  //---Load the user parameters
  // Load object parameters for the attributes 
  for( AttributeStore::iterator i = _attributes.begin() ; i != _attributes.end(); i++ )
  {
    OMTRACEID( OMK_DEBUG_OMK_ATTR, "Load configuration for " << OMK::debugMsg( i->second ) ) ;
    ok = i->second->loadParameters( node ) && ok ;
  }

  //--- Load parameters for extensions
  ok = loadFromObjectParameters( node ) && ok ;

  // Load object parameters for the object
  ok = loadParameters( node ) && ok ;

  //--- Load parameters for extensions
  // In case Extension parameter create extensionNode
  extensionsNode = getObjectDescriptor().getExtensionsParameters() ;
  ok = loadFromExtensionsParameters( extensionsNode ) && ok ;

  loadOrder( extensionsNode, "PreComputeOrder"    , _orderedExtensionsForPreCompute     ) ;
  loadOrder( extensionsNode, "PostComputeOrder"   , _orderedExtensionsForPostCompute    ) ;

  if( !ok )
  { // Not ok, display the following message and exit
    OMFATALERROR( "Error in ExtensibleSimulatedObject::init for " << debugMsg( this ) << std::endl
      << ">>> :-( Unable to initialize the object" ) ; 
  }
}
//-----------------------------------------------------------------

void ExtensibleSimulatedObject::compute()
{
  // to retrieve the inputs value
  computeInputs();

  // Call the extensions which work on inputs parameters
  preComputeExtension() ;

  // To compute the behavior
  computeParameters();

  // Call the extensions which work on outputs parameters
  postComputeExtension() ;

  // To set the outputs
  computeOutputs();
}

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

void ExtensibleSimulatedObject::computeInputs()
{
  // Call the attribute which work with inputs 
  for( AttributeStore::iterator i = _attributes.begin() ; i != _attributes.end(); i++ )
  {
    i->second->getValueFromInput() ;
  }
}

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

void ExtensibleSimulatedObject::computeParameters()
{
}
//-----------------------------------------------------------------

void ExtensibleSimulatedObject::computeOutputs()
{
  // Call the attribute which work with outputs
  for( AttributeStore::iterator i = _attributes.begin() ; i != _attributes.end(); i++ )
  {
    i->second->setValueToOutput() ;
    i->second->resetUpdated() ;
  }
}
//-----------------------------------------------------------------
bool ExtensibleSimulatedObject::loadParameters( const ConfigurationParameterDescriptor * node )
{ 
  return true ;
}
//-----------------------------------------------------------------
void ExtensibleSimulatedObject::activateCreateExtensionByEvent( bool activate ) 
{
  if( activate ) 
  {
    if( !_eventCreateAndAddExtensionListener )
    {
      _eventCreateAndAddExtensionListener = new CreateAndAddExtensionEventListener
                         ( *this, 
                           &ExtensibleSimulatedObject::processCreateAndAddExtension, 
                           EventId::CREATE_AND_ADD_EXTENSION ) ; 
    }
  }
  else
  {
    delete _eventCreateAndAddExtensionListener ;
    _eventCreateAndAddExtensionListener = 0 ;
  }
}
//-----------------------------------------------------------------
bool ExtensibleSimulatedObject::processCreateAndAddExtension( CreateAndAddExtensionEvent * event ) 
{
  const CreateAndAddExtensionPrm& value = event->value.getValue() ;
  createAndAddExtension( this, value.first, value.second ) ;
  return true ;
}
//-----------------------------------------------------------------
IAttribute* ExtensibleSimulatedObject::getAttribute( const Name& id ) 
{
  AttributeStore::iterator i = _attributes.find( id );
  return ( i == _attributes.end() ) ? 0 : i->second ;
}
//-----------------------------------------------------------------
void ExtensibleSimulatedObject::addAttribute( IAttribute& attribute, bool createOutput ) 
{
  // Check for duplicate attribute
  AttributeStore::iterator i = _attributes.find( attribute.getId() );
  if( i == _attributes.end() ) 
  { 
    // Initialise the owner of the attribute as itself
    attribute.setOwner( this, createOutput ) ;
    // It is a really new item, adds it in the main list
    _attributes[ attribute.getId() ] = &attribute ;
  }
  else 
  {
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
      "Error to add attribute to " << debugMsg( this ) << std::endl
      << ">>> :-( The attribute \"" << attribute.getId().getString() << "\" is a duplicate one" ) ;
  }
}
//-----------------------------------------------------------------
void ExtensibleSimulatedObject::removeAttribute( const Name& id ) 
{
  // Look for the attribute
  AttributeStore::iterator i = _attributes.find( id );
  if( i != _attributes.end() ) 
  {
    _attributes.erase( i ) ;
  }
  else 
  {
    OMTRACEID( OMK_DEBUG_OMK_ATTR, 
      "Error to remove attribute to " << debugMsg( this ) << std::endl
      << ">>> :-( The attribute \"" << id.getString() << "\" cannot be find" ) ;
  }
}
//-----------------------------------------------------------------

---