OMKObjectDescriptor.cpp

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 
 *
 */
#include "OMKObjectDescriptor.h"
#include "OMKCurrentActiveObject.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKSimulatedObject.h"
#include "OMKSimpleTypeT.inl"
#include "OMKUniqueConfigurationParameter.h"
#include "OMKUserException.h"

#include "OMKtokens.h"
#include "OMKgenericKernelParser.h"
#include "OMKKernelIstreamLexer.h"
#include "OMKTracer.h"

using namespace OMK ;
//------------------------------------------------------------------------------
ObjectDescriptor::ObjectDescriptor()
  : _pointerToSimulatedObject( 0 ),
    _destroySimulatedObject( false ),
    _configurationParameters( 0 ),
    _extensionsParameters( 0 ),
    _originalSchedulingParameters( 0 ),
    _schedulingParameters( 0 ),
    _fathersDescription( 0 ),
    _creatingObject( false ),
#ifndef _MSC_VER
    _creatingThread( 0 ),
#endif
    _frequency( 0 ),
    _distribution( DEFAULT_OBJECT ),
    _originalFrequency( 0 )
{
  // otherwise, the initial value of _creatingThread is inappropriate
#if !defined _MSC_VER && defined _OMK_MUTEX_
  OMASSERT( pthread_self() != 0 ) ;
#endif
}
//------------------------------------------------------------------------------
ObjectDescriptor::ObjectDescriptor( const ObjectDescriptor & orig )
  : _pointerToSimulatedObject( 0 ),
    _destroySimulatedObject( false ),
    _objectName( orig._objectName ),
    _classId( orig._classId ),
    _configurationParameters( 0 ),
    _extensionsParameters( 0 ),
    _originalSchedulingParameters( 0 ),
    _schedulingParameters( 0 ),
    _fathersDescription( 0 ),
    _creatingObject( false ),
    _processId( orig._processId ),
    _frequency( orig._frequency ),
    _distribution( orig._distribution ),
    _originalFrequency( orig._originalFrequency )
{
  _configurationParameters =
    orig._configurationParameters != 0 ?
    orig._configurationParameters->clone() : 0 ;

  _extensionsParameters =
    orig._extensionsParameters != 0 ?
    orig._extensionsParameters->clone() : 0 ;

  _originalSchedulingParameters =
    orig._originalSchedulingParameters != 0 ?
    static_cast< MultipleConfigurationParameter *>(
      orig._originalSchedulingParameters->clone() ) : 0 ;

  _schedulingParameters =
    orig._schedulingParameters != 0 ?
    static_cast< MultipleConfigurationParameter *>(
      orig._schedulingParameters->clone() ) : 0 ;

  // Only one descriptor by object. Assume descriptor is copied only before
  // the described object is created
  OMASSERT( orig._pointerToSimulatedObject == 0 ) ;
  OMASSERT( orig._destroySimulatedObject == false ) ;

  // copy the sons
  for( SonsContainerType::const_iterator i = orig._sonsContainer.begin() ;
       i != orig. _sonsContainer.end() ;
       ++i )
  {
    addSon( new ObjectDescriptor( *( *i ) ) ) ;
  }
}
//------------------------------------------------------------------------------
ObjectDescriptor::ObjectDescriptor(
  const Name & objectName,
  const Name & classId,
  const Name & processId,
  const Frequency & frequency,
  ConfigurationParameterDescriptor * configurationParameters,
  ConfigurationParameterDescriptor * extensionsParameters,
  Distribution distribution )
  : _pointerToSimulatedObject( 0 ),
    _destroySimulatedObject( false ),
    _objectName( objectName ),
    _classId( classId ),
    _configurationParameters( configurationParameters ),
    _extensionsParameters( extensionsParameters ),
    _originalSchedulingParameters( 0 ),
    _schedulingParameters( 0 ),
    _fathersDescription( 0 ),
    _creatingObject( false ),
#ifndef _MSC_VER
    _creatingThread( 0 ),
#endif
    _processId( processId ),
    _frequency( frequency ),
    _distribution( distribution ),
    _originalFrequency( frequency )
{
#if !defined _MSC_VER && defined _OMK_MUTEX_
  OMASSERT( pthread_self() != 0 ) ;
#endif
  _schedulingParameters = new MultipleConfigurationParameter() ;
  std::ostringstream freq ;
  freq << frequency ;
  _schedulingParameters->appendSubDescriptorNamed(
    "Frequency",
    new UniqueConfigurationParameter( freq.str() ) ) ;
  _schedulingParameters->appendSubDescriptorNamed(
    "Process",
    new UniqueConfigurationParameter( processId.getString() ) ) ;
  _originalSchedulingParameters = static_cast< MultipleConfigurationParameter *>(
    _schedulingParameters->clone() ) ;
}
//------------------------------------------------------------------------------
ObjectDescriptor::ObjectDescriptor(
  const Name & objectName,
  const Name & classId,
  const Frequency & frequency,
  ConfigurationParameterDescriptor * configurationParameters,
  ConfigurationParameterDescriptor * extensionsParameters,
  Distribution distribution )
  : _pointerToSimulatedObject( 0 ),
    _destroySimulatedObject( false ),
    _objectName( objectName ),
    _classId( classId ),
    _configurationParameters( configurationParameters ),
    _extensionsParameters( extensionsParameters ),
    _originalSchedulingParameters( 0 ),
    _schedulingParameters( 0 ),
    _fathersDescription( 0 ),
    _creatingObject( false ),
#ifndef _MSC_VER
    _creatingThread( 0 ),
#endif
    _frequency( frequency ),
    _distribution( distribution ),
    _originalFrequency( frequency )
{
#if !defined _MSC_VER && defined _OMK_MUTEX_
  OMASSERT( pthread_self() != 0 ) ;
#endif

  _schedulingParameters = new MultipleConfigurationParameter() ;
  std::ostringstream freq ;
  freq << frequency ;
  _schedulingParameters->appendSubDescriptorNamed(
    "Frequency", 
    new UniqueConfigurationParameter( freq.str() ) ) ;
  _originalSchedulingParameters = static_cast< MultipleConfigurationParameter *>(
    _schedulingParameters->clone() ) ;
}
//------------------------------------------------------------------------------
ObjectDescriptor::ObjectDescriptor(
  const Name & objectName,
  const Name & classId,
  MultipleConfigurationParameter * schedulingParameters,
  ConfigurationParameterDescriptor * configurationParameters,
  ConfigurationParameterDescriptor * extensionsParameters )
  : _pointerToSimulatedObject( 0 ),
    _destroySimulatedObject( false ),
    _objectName( objectName ),
    _classId( classId ),
    _configurationParameters( configurationParameters ),
    _extensionsParameters( extensionsParameters ),
    _originalSchedulingParameters( 0 ),
    _schedulingParameters( schedulingParameters ),
    _fathersDescription( 0 ),
    _creatingObject( false )
#if !defined _MSC_VER && defined _OMK_MUTEX_
    ,_creatingThread( 0 )
#endif
{
#if !defined _MSC_VER && defined _OMK_MUTEX_
  OMASSERT( pthread_self() != 0 ) ;
#endif

  interpretSchedulingParameters( schedulingParameters ) ;
}
//------------------------------------------------------------------------------
ObjectDescriptor::~ObjectDescriptor() 
{
  if( _destroySimulatedObject )
  {
    if( _pointerToSimulatedObject == 0 )
    {
      OMERROR( "ObjectDescriptor::~ObjectDescriptor() destroying "
               << getName() << " in incooherant state" << std::endl ) ;
    }
    delete _pointerToSimulatedObject ;
  }

  if( _fathersDescription != 0 )
  {
    _fathersDescription->removeSon( this ) ;
  }

  delete _originalSchedulingParameters ;
  delete _schedulingParameters ;
  delete _configurationParameters ;
  delete _extensionsParameters ;

  if( !_sonsContainer.empty() )
  {
    OMTRACEID( OMK_DEBUG_OMK_OBJ, "ObjectDescriptor with "
               << _sonsContainer.size()
               << " remaining sons deleted. Sons not deleted" << std::endl ) ;
  }
}
//------------------------------------------------------------------------------

ConfigurationParameterDescriptor * ObjectDescriptor::getConfigurationParameters(
  bool create )
{
  if( create && !_configurationParameters )
  {
    _configurationParameters = new MultipleConfigurationParameter() ;
  }
  return _configurationParameters ;
}
//------------------------------------------------------------------------------
ConfigurationParameterDescriptor * ObjectDescriptor::getExtensionsParameters(
  bool create )
{
  if( create && !_extensionsParameters )
  {
    _extensionsParameters = new MultipleConfigurationParameter() ;
  }
  return _extensionsParameters ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::unpack( IncomingSynchronisationMessage & in )
{
  std::string messageBuffer ;
  in >> messageBuffer ;
  std::istringstream message( messageBuffer );
  extract(message ) ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::pack( OutgoingSynchronisationMessage & out ) const
{
  // packed in a quite inefficient way (unsing the string representation of the
  // object descriptor), 
  // but much simpler to decode : therefore, use extract
  std::ostringstream char_out ;
  printToStream( char_out, 0 ) ;
  out << char_out.str() ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::extract( std::istream & in )
{
  _sonsContainer.clear() ;
   
  KernelIstreamLexer< std::istream > inputStream( in ) ;
  DLGLexer scan( & inputStream ) ;
  ANTLRTokenBuffer pipe( & scan ) ;
  ANTLRTokenPtr aToken = new ANTLRToken() ;
  scan.setToken( mytoken( aToken ) ) ;
  genericKernelParser extractor( &pipe ) ;
  extractor.init() ;

  std::string stringName;
  extractor.key( stringName ) ;
  _objectName = stringName ;

  ConfigurationParameterDescriptor *genericSubDescription =
    extractor.anonymousValue() ;
  MultipleConfigurationParameter * generalDescription =
    dynamic_cast< MultipleConfigurationParameter * >( genericSubDescription );
  if( generalDescription == 0 )
  {
    throw UserException( "Unable to extract a name for an ObjectDescriptor from a stream" ) ;
  }

  genericSubDescription = generalDescription->getSubDescriptorByName( "Class" ) ;
  if( genericSubDescription == 0 ) 
  {
    throw UserException( "Unable to extract a class for an ObjectDescriptor from a stream") ;
  }
  _classId = genericSubDescription->getAssociatedString() ;

  delete _configurationParameters ;
  _configurationParameters =
    generalDescription->getSubDescriptorByName( "UserParams" ) ;

  delete _extensionsParameters ;
  _extensionsParameters =
    generalDescription->getSubDescriptorByName( "Extensions" ) ;

  genericSubDescription =
    generalDescription->getSubDescriptorByName( "Scheduling" ) ;
  if( genericSubDescription !=0 )
  {
    interpretSchedulingParameters(
      dynamic_cast< MultipleConfigurationParameter * >( genericSubDescription ) ) ;
  }
  else
  {
    interpretSchedulingParameters( 0 ) ;
  }

  genericSubDescription = generalDescription->getSubDescriptorByName( "Sons" ) ;
  generalDescription =
    dynamic_cast< MultipleConfigurationParameter * >( genericSubDescription ) ;
  if( generalDescription != 0 )
  {
    interpretConfigurationParameterAsListOfSons( _sonsContainer, generalDescription ) ;
  }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::printToStream( std::ostream & out, int offset ) const
{
  //suppose any needed offset has allready been printed
  out << getName() << std::endl ;
  printTabToStream( out,offset + 2 ) ;
  out << "{" << std::endl ;
  printTabToStream( out, offset + 4 ) ;
  out << "Class " << getClass() << std::endl ;
  if( getSchedulingParameters() != 0 )
  {
    printTabToStream( out, offset + 4 ) ;
    out << "Scheduling " ;
    getSchedulingParameters()->printToStream( out, offset + 6 ) ;
    out << std::endl ;
  }
  if( getConfigurationParameters() != 0 )
  {
    printTabToStream( out, offset + 4 ) ;
    out << "UserParams " ;
    getConfigurationParameters()->printToStream( out, offset + 6 ) ;
    out << std::endl ;
  }
  if( getExtensionsParameters() != 0 )
  {
    printTabToStream( out, offset + 4 ) ;
    out << "Extensions " ;
    getExtensionsParameters()->printToStream( out, offset + 6 ) ;
    out << std::endl ;
  }
  if( _sonsContainer.size() != 0 )
  {
    printTabToStream( out, offset + 4 ) ;
    out << "Sons" << std::endl ;
    printTabToStream( out, offset + 6 ) ;
    out << "{" << std::endl ;
    for( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         i != _sonsContainer.end() ;
         ++i )
    {
      printTabToStream( out, offset + 8 ) ;
      ( *i )->printToStream( out, offset + 8 ) ;
    }
    printTabToStream( out, offset + 6 ) ;
    out << "}" << std::endl ; 
  }
  printTabToStream( out, offset + 2 ) ;
  out << "}" << std::endl ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::insertInStream( std::ostream & out ) const 
{
  printToStream( out, 0 ) ;
} 
//------------------------------------------------------------------------------
void ObjectDescriptor::setProcess( const Name & newProcessName )
{
  _processId = newProcessName ;
  UniqueConfigurationParameter * description =
    dynamic_cast< UniqueConfigurationParameter * >(
      _schedulingParameters->getSubDescriptorByName( "Process" ) );
  if( description != 0 )
  {
    description->changeConfigurationParameter( newProcessName.getCString() ) ;
  }
  else
  {
    _schedulingParameters->appendSubDescriptorNamed(
      "Process", 
      new UniqueConfigurationParameter( newProcessName.getCString() ) ) ;
  }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::setFrequency( const Frequency & newFrequency ) 
{
  _frequency = newFrequency ;
   
  UniqueConfigurationParameter *description =
    dynamic_cast< UniqueConfigurationParameter * >(
      _schedulingParameters->getSubDescriptorByName( "Frequency" ) );
  if( description != 0 )
  {
    std::ostringstream freq ;
    freq << newFrequency ;
    description->changeConfigurationParameter( freq.str() ) ;
  }
  else
  {
    std::ostringstream freq ;
    freq << newFrequency ;
    _schedulingParameters->appendSubDescriptorNamed(
      "Frequency",
      new UniqueConfigurationParameter( freq.str() ) ) ;
  }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::setDistribution( Distribution newDistribution )
{
  _distribution = newDistribution ;
   UniqueConfigurationParameter *description =
     dynamic_cast< UniqueConfigurationParameter * >(
       _schedulingParameters->getSubDescriptorByName( "Distribution" ) ) ;
   if( description != 0 )
   {
     description->changeConfigurationParameter(
       ( newDistribution == DUPLICATED_OBJECT ) ? "Duplicated" :
       ( ( newDistribution == LOCAL_OBJECT ) ? "Local" : "Default" ) ) ;
   }
   else
   {
     _schedulingParameters->appendSubDescriptorNamed(
       "Distribution", 
       new UniqueConfigurationParameter(
         ( newDistribution == DUPLICATED_OBJECT ) ? "Duplicated" :
         ( ( newDistribution == LOCAL_OBJECT ) ? "Local" : "Default" ) ) ) ;
   }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::interpretSchedulingParameters(
  MultipleConfigurationParameter *schedulingParameters )
{
  if( _schedulingParameters != schedulingParameters )
  {
    delete _schedulingParameters ;
  }

  _schedulingParameters = schedulingParameters ;    
  if( _schedulingParameters == 0 )
  {
    _schedulingParameters = new MultipleConfigurationParameter() ;
  } 

  const ConfigurationParameterDescriptor *description =
    _schedulingParameters->getSubDescriptorByName( "Frequency" ) ;
  if( description != 0 )
  {
    std::istringstream strValue( description->getAssociatedString() ) ;
    strValue >> _frequency ;
  }
  else
  {
    _frequency = 0 ;
    _schedulingParameters->appendSubDescriptorNamed(
      "Frequency",
      new UniqueConfigurationParameter( "0" ) ) ;
  }

  delete _originalSchedulingParameters ;

  _originalSchedulingParameters =
    static_cast< MultipleConfigurationParameter *>(
      _schedulingParameters->clone() ) ;

  _originalFrequency = _frequency ;

  description = _schedulingParameters->getSubDescriptorByName( "Process" ) ; 
  if( description != 0 )
  {
    _processId = description->getAssociatedString() ;
  }
  else
  {
    OMTRACEID( OMK_DEBUG_PVM, "No Process parameter for OSO" << _objectName );
  }

  _distribution = DEFAULT_OBJECT ;
  description = _schedulingParameters->getSubDescriptorByName( "Distribution" ) ;
  if( description != 0 )
  {
    std::string value( description->getAssociatedString() ) ;
    if( value == "Local" )
    {
      _distribution = LOCAL_OBJECT ;
    }
    else if( value == "Duplicated" )
    {
      _distribution = DUPLICATED_OBJECT ;
    }
  }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::setFathersDescription( ObjectDescriptor *newFather )
{
  OMASSERT( newFather != 0 ) ;
  if( _fathersDescription != 0 )
  {
    _fathersDescription->removeSon( this ) ;
  }

  if( newFather->findDescendantNamed( getName() ) != 0 )
  {
    //cannot add the object : do nothing
    OMTRACEID( OMK_DEBUG_OMK_OBJ,
               "ObjectDescriptor::setFathersDescription of object named \""
               << getName()
               << "\" failed because descendant with the same name allready exists for object named \""
               << newFather->getName() << "\"" );
  }
  else 
  {
    newFather->addSon( this ) ;
  }
}
//------------------------------------------------------------------------------
SimulatedObject * ObjectDescriptor::createDescribedObject() const
{
#if !defined _MSC_VER && defined _OMK_MUTEX_
  //here, use mutual exclusion, to avoid
  // 1 - recursive creation loops
  // 2 - simultaneous creations
  // 3 - recursive creation loops during simultaneous creations!
  //therefore, only allow one thread to do creation at a time (share the
  // creatingThread exclusion lock, and test to see if we're in a recursive loop)

  _dataLock.protect() ;

  SimulatedObject *result( _pointerToSimulatedObject ) ;

  if( _pointerToSimulatedObject == 0 )
  {
    if( _creatingObject && ( _creatingThread == pthread_self() ) )
    {
      // recursive creation loop : return null is the best that can be done
      _dataLock.unprotect() ;
    }
    else
    {
      // the object needs creating : here the question is whether an other
      // thread is creating it or not
      if( _creatingObject )
      {
        //other thread is creating the object : wait for it to finish creation
        _createdCondition.waitForChange( _dataLock ) ;
      }
      else 
      {
        //no thread is creating the object, 
        //therefore this thread takes responsability for creation
        _creatingObject = true ;
        _creatingThread = pthread_self() ;
        _dataLock.unprotect() ;

        //here, we can garantie that we are the only creating thread,
        //and that 
        // 1 - any recursive creation loop is a non-blocking creation
        // 2 - other threads creating the object are waiting on the condition

        //attempt object creation
        SimulatedObject *father( 0 ) ;
        const ObjectDescriptor *fathersDescription( _fathersDescription ) ;

        // as creation can happen during a paralel simulation,
        // it can happen at a time where getCurrentActiveObject returns the
        // object whose request triggered instance creation.
        // Therefore, the current active object is temporarly set to null,
        // so as to mimic creation phase.
        // If it is set to the controller, changing a controlparameter
        // triggers the sending of a valueEvent by the controller, which
        // might not have it's objectHandle initialized in order to avoid
        // being scheduled by itself
        CurrentActiveObject context( 0 ) ;
         
        while( fathersDescription != 0 )
        {
          father = fathersDescription->createDescribedObject() ;
          if( father != 0 )
          {
            OMTRACEID( OMK_DEBUG_OMK_OBJ,
                       "Creating object of type \"" << getClass() << "\"" ) ;
            SimulatedObject *result(
              SimulatedObjectFactory::getInstance().create( getClass() )(
                father->getController() , *this ) ) ;
            OMTRACEID( OMK_DEBUG_OMK_OBJ,
                       "Creating object of type \"" << getClass() << "\" done" ) ;

            //result = father -> createInstanceOfEncapsulatedClass( *this );
            _dataLock.protect() ;
            _pointerToSimulatedObject = result ;
            _dataLock.unprotect() ;
            if( _pointerToSimulatedObject != 0 )
            {
              _destroySimulatedObject = true ;
              fathersDescription = 0 ;
            }
            else 
            {
              fathersDescription = fathersDescription->getFathersObjectDescriptor() ;
            }
          }
          else 
          {
            fathersDescription = 0 ;
          }
        }
      }
      if( _pointerToSimulatedObject == 0 )
      {
        OMTRACEID( OMK_DEBUG_OMK_OBJ,
                   "ObjectDescriptor::createDescribedObject: unable to create \""
                   << getName() << "\" of class " << getClass() ) ;
      }
      _dataLock.protect() ;
      _creatingObject = false ;
      _creatingThread = 0 ;
      _dataLock.unprotect() ;
      //wathever the result, unblock other waiting threads
      _createdCondition.signalChange() ;
    }
  }
  else
  {
    _dataLock.unprotect() ;
  }
  return result ;

#else // _MSC_VER || ! _OMK_MUTEX_
  SimulatedObject *result( _pointerToSimulatedObject ) ;
  if( _pointerToSimulatedObject == 0 )
  {
    //no thread is creating the object, 
    _creatingObject = true ;
         
    //here, we can garantie that we are the only creating thread,
    //and that 
    // 1 - any recursive creation loop is a non-blocking creation
    // 2 - other threads creating the object are waiting on the condition

    //attempt object creation
    SimulatedObject *father( 0 ) ;
    const ObjectDescriptor *fathersDescription( _fathersDescription ) ;
         
    // as creation can happen during a paralel simulation, (not here : no multi
    // threading in MSC version) it can happen at a time where
    // getCurrentActiveObject returns the object whose request triggered
    // instance creation.
    // Therefore, the current active object is temporarly set to null, so as to
    // mimic creation phase. If it is set to the controller, changing a
    // controlparameter triggers the sending of a valueEvent by the controller,
    // which might not have it's objectHandle initialized in order to avoid
    // being scheduled by itself
    
    while( fathersDescription != 0 )
    {
      father = fathersDescription->createDescribedObject() ;
      if( father != 0 )
      {
        OMTRACEID( OMK_DEBUG_OMK_OBJ, "Creating object of type \""
                   << getClass() << "\"" ) ;
        result = OMK::SimulatedObjectFactory::getInstance().create(
          getClass() )( father->getController() , *this ) ;
        OMTRACEID( OMK_DEBUG_OMK_OBJ,
                   "Creating object of type \"" << getClass()
                   << "\" done " << result ) ;
        //result = father -> createInstanceOfEncapsulatedClass (*this);
        _pointerToSimulatedObject = result ;
        if( _pointerToSimulatedObject != 0 )
        {
          _destroySimulatedObject = true ;
          fathersDescription = 0 ;
        }
        else 
        {
          fathersDescription = fathersDescription->getFathersObjectDescriptor() ;
        }
      }
      else 
      {
        fathersDescription = 0 ;
      }
    }
  }

  if( _pointerToSimulatedObject == 0 )
  {
    OMTRACEID( OMK_DEBUG_OMK_OBJ,
               "ObjectDescriptor::createDescribedObject: unable to create \""
               << getName() << "\" of class " << getClass() ) ;
  }
  _creatingObject = false ;

  return result ;

#endif // _MSC_VER
}
//------------------------------------------------------------------------------
void ObjectDescriptor::deleteCachedData()
{
  if( _destroySimulatedObject )
  {
    OMASSERT( _pointerToSimulatedObject != 0 ) ;
    delete _pointerToSimulatedObject ;
    _pointerToSimulatedObject = 0 ;
  }
  _destroySimulatedObject = false ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::addSon( ObjectDescriptor *newSon ) 
{
   OMASSERT( newSon != 0 ) ;
   const ObjectDescriptor *duplicate = findDescendantNamed( newSon->getName() ) ;
   if( duplicate == 0 )
   {
     _sonsContainer.push_back( newSon ) ;
     newSon->_fathersDescription = this ;
   }
   else
   {
     OMTRACEID( OMK_DEBUG_OMK_OBJ,
                "ObjectDescriptor::addSon named \"" << newSon->getName()
                << "\" failed because descendant with the same name allready exists for object named \""
                << getName() << "\"" ) ;
     // as respnsability is transfered and the son is not added, delete it
     delete newSon ;
   }
}
//------------------------------------------------------------------------------
void ObjectDescriptor::removeSon( ObjectDescriptor *oldSon )
{
  _sonsContainer.remove( oldSon ) ;
}
//------------------------------------------------------------------------------
std::list< const ObjectDescriptor * > * ObjectDescriptor::getDescendants() const 
{
  std::list< const ObjectDescriptor * > *result =
    new std::list< const ObjectDescriptor * >() ;
  return getDescendants( result ) ;
}
//------------------------------------------------------------------------------
std::list< const ObjectDescriptor * > * ObjectDescriptor::getDescendants(
  std::list< const ObjectDescriptor * > * resultList ) const
{
  for( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
       i != _sonsContainer.end() ;
       ++i )
  {
    resultList->push_back( *i ) ;
    ( *i )->getDescendants( resultList ) ;
  }
  return resultList ;
}
//------------------------------------------------------------------------------
std::list< ObjectDescriptor * > * ObjectDescriptor::getDescendants()
{
  std::list< ObjectDescriptor * > *result = new std::list< ObjectDescriptor * >() ;
  return getDescendants( result ) ;
}
//------------------------------------------------------------------------------
std::list< ObjectDescriptor * > * ObjectDescriptor::getDescendants(
  std::list< ObjectDescriptor * > *resultList )
{
  for( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
       i != _sonsContainer.end() ;
       ++i )
  {
    resultList->push_back( *i ) ;
    ( *i )->getDescendants( resultList ) ;
  }
  return resultList ;
}
//------------------------------------------------------------------------------
const ObjectDescriptor *
ObjectDescriptor::findDescendantNamed( const Name & name ) const 
{
  const ObjectDescriptor *resul( 0 ) ;  
  if( name == getName() )
  {
    resul = this ;
  }
  else
  {
    SonsContainerType::const_iterator i = _sonsContainer.begin() ;
    while( ( resul == 0 ) && ( i != _sonsContainer.end() ) )
    {
      resul = ( *i )->findDescendantNamed( name ) ;
      ++i ;
    }
  }
  return resul ;
}
//------------------------------------------------------------------------------
ObjectDescriptor *
ObjectDescriptor::findDescendantNamed( const Name & name )
{
  ObjectDescriptor *resul( 0 ) ;
  if( name == getName() )
  {
    resul = this ;
  }
  else
  {
    SonsContainerType::iterator i = _sonsContainer.begin() ;
    while( ( resul == 0 ) && ( i != _sonsContainer.end() ) )
    {
      resul = ( *i )->findDescendantNamed( name ) ;
      ++i ;
    }
  }
  return resul ;
}
//------------------------------------------------------------------------------
void ObjectDescriptor::interpretConfigurationParameterAsListOfSons(
  SonsContainerType & listOfSons,
  MultipleConfigurationParameter * sonsDescription )
{
  if( sonsDescription != 0 )
  {
    int nbSons = sonsDescription->getNumberOfSubItems() ;
    std::string sonName ;
    for( int i = 0 ; i < nbSons ; ++i )
    {
      ConfigurationParameterDescriptor * aGenericSonsDescription ;
      aGenericSonsDescription = sonsDescription->getSubDescriptorByPosition( i ) ;
      sonName = sonsDescription->getNameOfSubDescriptor( i ) ;
      MultipleConfigurationParameter * aSonsDescription ;
      aSonsDescription = dynamic_cast< MultipleConfigurationParameter * >(
        aGenericSonsDescription ) ;
      if( aSonsDescription != 0 )
      {
        ObjectDescriptor * descriptionOfSon =
          interpretConfigurationParameterAsObjectDescription(
            sonName, aSonsDescription ) ;
        listOfSons.push_back( descriptionOfSon );
      }
    }
  }
}
//------------------------------------------------------------------------------
ObjectDescriptor * ObjectDescriptor::interpretConfigurationParameterAsObjectDescription(
  std::string objectName,
  MultipleConfigurationParameter *generalDescription ) 
{
  OMASSERT( generalDescription != 0 ) ;

  ConfigurationParameterDescriptor *genericSubDescription =
    generalDescription->getSubDescriptorByName( "Class" ) ;

  if( genericSubDescription == 0 ) 
  {
    throw UserException( "Unable to extract a class for an ObjectDescriptor from a stream" ) ;
  }

  std::string classId = genericSubDescription->getAssociatedString() ;

  ConfigurationParameterDescriptor *configurationParameters =
    generalDescription->getSubDescriptorByName( "UserParams" ) ;


  ConfigurationParameterDescriptor *extensionsParameters =
    generalDescription->getSubDescriptorByName( "Extensions" ) ;


  MultipleConfigurationParameter *schedulingParameters =
    dynamic_cast< MultipleConfigurationParameter * >(
      generalDescription->getSubDescriptorByName( "Scheduling" ) ) ;

  ObjectDescriptor *result = new ObjectDescriptor( Name( objectName ),
                                                   Name( classId ),
                                                   schedulingParameters,
                                                   configurationParameters,
                                                   extensionsParameters ) ;

  genericSubDescription = generalDescription->getSubDescriptorByName( "Sons" ) ;
  generalDescription =
    dynamic_cast< MultipleConfigurationParameter * >( genericSubDescription ) ;
  if( generalDescription != 0 )
  {
    interpretConfigurationParameterAsListOfSons(
      result->_sonsContainer, generalDescription ) ;
    //for all the sons, connect to their father, only known here
    for( SonsContainerType::const_iterator i = result->_sonsContainer.begin() ;
         i != result->_sonsContainer.end() ;
         ++i )
    {
      ( *i )->_fathersDescription = result ;
    }
  }
  return result ;
}

---