---

PsObjectDescriptor.cxx

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 "PsObjectDescriptor.h"
#include "PsMultipleConfigurationParameter.h"
#include "PsUniqueConfigurationParameter.h"
#include "PsSimulatedObject.h"
#include "PsnCurrentActiveObject.h"

#include "tokens.h"
#include "genericKernelParser.h"
#include "KernelIstreamLexer.h"

const PsName & PsObjectDescriptor::getName () const  
{
  return _objectName ;
}

const PsName & PsObjectDescriptor::getClass () const 
{
  return _classId;
}

const PsName & PsObjectDescriptor::getProcess () const 
{
  return _processId ;
}

const PsFrequency & PsObjectDescriptor::getFrequency () const 
{
  return _frequency ;
}


const PsFrequency & PsObjectDescriptor::getOriginalFrequency () const 
{
  return _originalFrequency ;
}

const PsConfigurationParameterDescriptor * PsObjectDescriptor::getConfigurationParameters() const 
{
   return _configurationParameters ;
}

PsConfigurationParameterDescriptor * PsObjectDescriptor::getConfigurationParameters()
{
   return _configurationParameters ;
}

const PsMultipleConfigurationParameter * PsObjectDescriptor::getSchedulingParameters() const 
{
   return _schedulingParameters ;
}

PsMultipleConfigurationParameter * PsObjectDescriptor::getSchedulingParameters() 
{
   return _schedulingParameters ;
}

const PsMultipleConfigurationParameter * PsObjectDescriptor::getOriginalSchedulingParameters() const 
{
   return _originalSchedulingParameters ;
}



void PsObjectDescriptor::unpack (PsIncomingSynchronisationMessage & in) 
{
#ifdef _USESSTREAM
   // but much simpler to decode
   string messageBuffer ;

   in>>messageBuffer ;

   istringstream message ( messageBuffer );

   extract (message ) ;
#else
   // but much simpler to decode
   int messageSize ;

   in>>messageSize ;
   char * messageBuffer = new char [messageSize];
   in>>messageBuffer ;

   assert (messageBuffer[messageSize -1] == '\0' ) ; 

   istrstream message ( messageBuffer );
   extract (message ) ;
#endif
}



void PsObjectDescriptor::pack (PsOutgoingSynchronisationMessage & out) const 
{
   // packed in a quite inefficient way (unsing the string representation of the object descriptor), 
   // but much simpler to decode : therefore, use extract
#ifdef _USESSTREAM
   ostringstream char_out ;
   printToStream ( char_out, 0 ) ;
   out<<char_out.str() ;
#else
   ostrstream char_out ;
   printToStream ( char_out, 0 ) ;
   char_out.put ('\0') ;
   char * C_string = char_out.str() ;
   assert (C_string[char_out.pcount()-1] == '\0') ;
   out<<char_out.pcount() ;
   out<<C_string;
   delete C_string ;
#endif
}

void PsObjectDescriptor::extract (istream & in) 
{
   _sonsContainer.clear() ;
   
   KernelIstreamLexer<istream> inputStream (in) ;
   DLGLexer scan( & inputStream ) ;
   ANTLRTokenBuffer pipe ( & scan ) ;
   ANTLRTokenPtr aToken = new ANTLRToken() ;
   scan.setToken(mytoken(aToken)) ;
   genericKernelParser extractor  ( &pipe ) ;
   extractor.init() ;

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

   PsConfigurationParameterDescriptor * genericSubDescription = extractor.anonymousValue() ;
   PsMultipleConfigurationParameter * generalDescription = dynamic_cast<PsMultipleConfigurationParameter *> ( genericSubDescription );
   
   if ( generalDescription == NULL ) 
      {
         throw PsUserException("Unable to extract a name for an ObjectDescriptor from a stream") ;
      }


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

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

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

   genericSubDescription = generalDescription->getSubDescriptorByName ("Sons") ;
   generalDescription = dynamic_cast<PsMultipleConfigurationParameter *> (genericSubDescription) ;
   if (generalDescription != NULL)
      {
         interpretConfigurationParameterAsListOfSons ( _sonsContainer, generalDescription ) ;
      }
}


void PsObjectDescriptor::printToStream (ostream & out, int offset) const
{
   //suppose any needed offset has allready been printed
   out<<getName()<<endl;
   printTabToStream(out,offset+2) ;
   out<<"{"<<endl;
   printTabToStream(out,offset+4) ;
   out<<"Class "<<getClass()<<endl; 
   if ( getSchedulingParameters() != NULL )
      {
         printTabToStream(out,offset+4) ;
         out<<"Scheduling " ;
         getSchedulingParameters()->printToStream(out,offset+6) ;
         out<<endl;
      }
   if ( getConfigurationParameters() != NULL )
      {
         printTabToStream(out,offset+4) ;
         out<<"UserParams " ;
         getConfigurationParameters()->printToStream(out,offset+6) ;
         out<<endl;
      }
   if ( _sonsContainer.size() != 0 )
      {
         printTabToStream(out,offset+4) ;
         out<<"Sons"<<endl;
         printTabToStream(out,offset+6) ;
         out<<"{"<<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<<"}"<<endl;         
      }
   printTabToStream(out,offset+2) ;
   out<<"}"<<endl;
}



void PsObjectDescriptor::insertInStream (ostream & out) const 
{
   printToStream ( out, 0 ) ;
} 



void PsObjectDescriptor::setProcess (const PsName & newProcessName) 
{
   _processId = newProcessName ;
   PsUniqueConfigurationParameter * description = dynamic_cast<PsUniqueConfigurationParameter *>(_schedulingParameters->getSubDescriptorByName ("Process") );
   if ( description != NULL )
      {
         description->changeConfigurationParameter (newProcessName.getCString() ) ;
      }
   else
      {
         _schedulingParameters->appendSubDescriptorNamed ("Process", 
                                                          new PsUniqueConfigurationParameter (newProcessName.getCString() ) ) ;
         
      }
}
void PsObjectDescriptor::setFrequency (const PsFrequency & newFrequency) 
{
   _frequency = newFrequency ;
   
   PsUniqueConfigurationParameter * description = dynamic_cast<PsUniqueConfigurationParameter *>(_schedulingParameters->getSubDescriptorByName ("Frequency") );

   if ( description != NULL )
      {
#ifdef _USESSTREAM
         ostringstream freq ;
         freq << newFrequency ;
         description->changeConfigurationParameter ( freq.str() ) ;
#else
         ostrstream freq ;
         freq << newFrequency ;
         freq.put ('\0') ;
         description->changeConfigurationParameter ( freq.str() ) ;
         delete freq.str() ;
#endif
      }
   else
      {
#ifdef _USESSTREAM
         ostringstream freq ;
         freq << newFrequency ;
         _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                          new PsUniqueConfigurationParameter (freq.str() ) ) ;
#else
         ostrstream freq ;
         freq << newFrequency ;
         freq.put ('\0') ;
         _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                          new PsUniqueConfigurationParameter (freq.str() ) ) ;
         delete freq.str() ;
#endif
      }
}

void PsObjectDescriptor::interpretSchedulingParameters (PsMultipleConfigurationParameter * schedulingParameters)
{
   if ( (_schedulingParameters != NULL) && (_schedulingParameters != schedulingParameters ) ) delete _schedulingParameters ;

   _schedulingParameters = schedulingParameters ;
      
   if ( _schedulingParameters == NULL )
      {
         _schedulingParameters = new PsMultipleConfigurationParameter() ;
      } 

   const PsConfigurationParameterDescriptor * description ;
   description = _schedulingParameters->getSubDescriptorByName ("Frequency") ;

   if ( description != NULL )
      {
         _frequency = atoi (description->getAssociatedString().c_str() ) ;
      }
   else
      {
         _frequency = 0 ;
         _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                          new PsUniqueConfigurationParameter ("0") ) ;
      }

   if ( _originalSchedulingParameters != NULL ) 
      {
         delete _originalSchedulingParameters ;
      }
   _originalSchedulingParameters = dynamic_cast<PsMultipleConfigurationParameter *> ( _schedulingParameters->clone () ) ;
   assert ( _originalSchedulingParameters != NULL ) ; 

   _originalFrequency = _frequency ;
   
   description = _schedulingParameters->getSubDescriptorByName ("Process") ;
   
   if ( description != NULL )
      {
         _processId = description->getAssociatedString() ;
      }
}

PsObjectDescriptor::PsObjectDescriptor () :
   _configurationParameters (NULL),
   _originalSchedulingParameters (NULL),
   _schedulingParameters (NULL),
   _fathersDescription (NULL),
   _frequency(0),
   _originalFrequency ( 0 ),
   _creatingObject (false ),
   _creatingThread (0),
   _destroySimulatedObject (false ),
   _pointerToSimulatedObject (NULL)
{
   // otherwise, the initial value of _creatingThread is inappropriate
   assert (pthread_self() != 0) ;
}

PsObjectDescriptor::PsObjectDescriptor ( const PsObjectDescriptor & orig ) :
   _pointerToSimulatedObject (NULL ),
   _destroySimulatedObject ( false ),
   _objectName (orig._objectName),
   _classId ( orig._classId),
   _fathersDescription ( NULL ),
   _processId ( orig._processId),
   _frequency ( orig._frequency ),
   _originalFrequency ( orig._originalFrequency ),
   _creatingObject ( false )
{
   if ( orig._configurationParameters != NULL )
      {
         _configurationParameters = orig._configurationParameters->clone() ;
      }
   else
      {
         _configurationParameters = NULL ;
      }
   if ( orig._originalSchedulingParameters != NULL )
      {
         _originalSchedulingParameters = dynamic_cast<PsMultipleConfigurationParameter *> (orig._originalSchedulingParameters->clone() ) ;
         assert ( _originalSchedulingParameters != NULL ) ;
      }
   else
      {
         _originalSchedulingParameters = NULL ;
      }
   if ( orig._schedulingParameters != NULL )
      {
         _schedulingParameters = dynamic_cast<PsMultipleConfigurationParameter *> (orig._schedulingParameters->clone()) ;
         assert ( _schedulingParameters != NULL ) ;
      }
   else
      {
         _schedulingParameters = NULL ;
      }

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

   // copy the sons
     for ( SonsContainerType::const_iterator i = orig._sonsContainer.begin() ;
         i != orig. _sonsContainer.end() ;
         ++i )
      {
         addSon ( new PsObjectDescriptor (*(*i)) ) ;
      }
}

PsObjectDescriptor::PsObjectDescriptor (const PsName & objectName,
                                        const PsName & classId,
                                        const PsName & processId,
                                        const PsFrequency & frequency,
                                        PsConfigurationParameterDescriptor * configurationParameters) : 
   _objectName ( objectName ), 
   _classId ( classId ), 
   _processId ( processId ), 
   _frequency ( frequency ),
   _originalFrequency ( frequency ),
   _configurationParameters ( configurationParameters ),
   _pointerToSimulatedObject( NULL ),
   _destroySimulatedObject ( false ),
   _fathersDescription ( NULL ),
   _creatingObject (false),
   _creatingThread ( 0 )
{
   assert (pthread_self() != 0) ;
   _schedulingParameters = new PsMultipleConfigurationParameter () ;
#ifdef _USESSTREAM
   ostringstream freq ;
   freq << frequency ;
   _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                    new PsUniqueConfigurationParameter (freq.str() ) ) ;
#else
   ostrstream freq ;
   freq << frequency ;
   freq.put('\0') ;
   _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                    new PsUniqueConfigurationParameter (freq.str() ) ) ;
   delete freq.str() ;
#endif
   _schedulingParameters->appendSubDescriptorNamed ("Process", 
                                                   new PsUniqueConfigurationParameter (processId.getCString() ) ) ;
   _originalSchedulingParameters = dynamic_cast<PsMultipleConfigurationParameter * >(_schedulingParameters->clone ()) ;
   assert (_originalSchedulingParameters != NULL ) ;
}



PsObjectDescriptor::PsObjectDescriptor (const PsName & objectName,
                                        const PsName & classId,
                                        const PsFrequency & frequency,
                                        PsConfigurationParameterDescriptor * configurationParameters) : 
   _objectName ( objectName ), 
   _classId ( classId ), 
   _frequency ( frequency ),
   _originalFrequency ( frequency ),
   _configurationParameters ( configurationParameters ),
   _pointerToSimulatedObject( NULL ),
   _destroySimulatedObject ( false ),
   _fathersDescription ( NULL ),
   _creatingObject (false),
   _creatingThread ( 0 )
{
   assert (pthread_self() != 0) ;
   _schedulingParameters = new PsMultipleConfigurationParameter () ;
#ifdef _USESSTREAM
   ostringstream freq ;
   freq << frequency ;
   _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                   new PsUniqueConfigurationParameter (freq.str() ) ) ;
#else   
   ostrstream freq ;
   freq << frequency ;
   freq.put('\0') ;
   _schedulingParameters->appendSubDescriptorNamed ("Frequency", 
                                                   new PsUniqueConfigurationParameter (freq.str() ) ) ;
   delete freq.str() ;
#endif
   _originalSchedulingParameters = dynamic_cast<PsMultipleConfigurationParameter * >(_schedulingParameters->clone ()) ;
   assert (_originalSchedulingParameters != NULL ) ;
}



PsObjectDescriptor::PsObjectDescriptor (const PsName & objectName,
                                        const PsName & classId,
                                        PsMultipleConfigurationParameter * schedulingParameters,
                                        PsConfigurationParameterDescriptor * configurationParameters) :
   _objectName ( objectName ), 
   _classId ( classId ), 
   _configurationParameters ( configurationParameters ),
   _schedulingParameters ( schedulingParameters ),
   _pointerToSimulatedObject( NULL ),
   _destroySimulatedObject ( false ),
   _fathersDescription ( NULL ),
   _originalSchedulingParameters (NULL),
   _creatingObject (false),
   _creatingThread ( 0 )
{
   assert (pthread_self() != 0) ;
   interpretSchedulingParameters (schedulingParameters) ;
}



PsObjectDescriptor::~PsObjectDescriptor() 
{
   if ( _destroySimulatedObject )
      {
         assert (_pointerToSimulatedObject != NULL) ;
         delete _pointerToSimulatedObject ;
      }

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

   if ( _originalSchedulingParameters != NULL ) delete _originalSchedulingParameters ;
   if ( _schedulingParameters != NULL ) delete _schedulingParameters ;
   if ( _configurationParameters != NULL ) delete _configurationParameters ;

   if (! _sonsContainer.empty() ) 
      {
         cout<<"PsObjectDescriptor with "<<_sonsContainer.size()<<" remaining sons deleted. Sons not deleted"<<endl;
      }
}

void PsObjectDescriptor::setFathersDescription ( PsObjectDescriptor * newFather )
{
   assert (newFather != NULL) ;
   if ( _fathersDescription != NULL )
      {
         _fathersDescription->removeSon (this) ;
      }
   
   if ( newFather->findDescendantNamed ( getName() ) != NULL )
      {
         //cannot add the object : do nothing
#ifdef _USESSTREAM
         ostringstream warningMessage ;
         warningMessage<<"PsObjectDescriptor::setFathersDescription of object named "<<getName()
                       <<" failed because descendant with the same name allready exists for object named "
                       <<newFather->getName()<<"\n";
         PsController::warning ( warningMessage.str() , PsController::SomeWarnings) ;
#else
         ostrstream warningMessage ;
         warningMessage<<"PsObjectDescriptor::setFathersDescription of object named "<<getName()
                       <<" failed because descendant with the same name allready exists for object named "
                       <<newFather->getName()<<"\n";
         warningMessage.put('\0') ;
         PsController::warning ( warningMessage.str() , PsController::SomeWarnings) ;
         delete warningMessage.str() ;
#endif
      }
   else 
      {
         newFather->addSon ( this ) ;
      }
}

PsSimulatedObject * PsObjectDescriptor::createDescribedObject() const
{
   //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() ;

   PsSimulatedObject * result = _pointerToSimulatedObject ;
   
   if ( _pointerToSimulatedObject == NULL )
      {
         
         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
                     PsSimulatedObject * father = NULL ;
                     const PsObjectDescriptor * 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 controlparamter 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
                     PsnCurrentActiveObject context ( NULL ) ;
                     
                     while ( fathersDescription != NULL )
                        {
                           father = fathersDescription->createDescribedObject() ;
                           if ( father != NULL )
                              {
                                 result = father -> createInstanceOfEncapsulatedClass (*this);
                                 _dataLock.protect() ;
                                 _pointerToSimulatedObject = result ;
                                 _dataLock.unprotect() ;
                                 if ( _pointerToSimulatedObject != NULL )
                                    {
                                       _destroySimulatedObject = true ;
                                       fathersDescription = NULL ;
                                    }
                                 else 
                                    {
                                       fathersDescription = fathersDescription->getFathersObjectDescriptor() ;
                                    }
                              }
                           else 
                              {
                                 fathersDescription = NULL ;
                              }
                        }
                  }
               if ( _pointerToSimulatedObject == NULL )
                  {
#ifdef _USESSTREAM
                     ostringstream warningMessage;
                     warningMessage<<"PsController::createReferenceObject: unable to create "<<getName()
                                   <<" of class "<<getClass()<<endl;
                     
                     PsController::warning ( warningMessage.str() , PsController::SomeWarnings ) ;
#else
                     ostrstream warningMessage;
                     warningMessage<<"PsController::createReferenceObject: unable to create "<<getName()
                                   <<" of class "<<getClass()<<endl;
                     
                     warningMessage.put('\0') ;
                     PsController::warning ( warningMessage.str() , PsController::SomeWarnings ) ;
                     delete warningMessage.str() ;
#endif
                  }
               _dataLock.protect() ;
               _creatingObject = false ;
               _creatingThread = 0 ;
               _dataLock.unprotect() ;
               //wathever the result, unblock other waiting threads
               _createdCondition.signalChange() ;
            }
      }
   else
      {
         _dataLock.unprotect() ;
      }
   return result ;
}   



const PsObjectDescriptor * PsObjectDescriptor::getFathersObjectDescriptor() const 
{
   return _fathersDescription ;
}


PsObjectDescriptor * PsObjectDescriptor::getFathersObjectDescriptor() 
{
   return _fathersDescription ;
}



void PsObjectDescriptor::deleteCachedData()
{
   if ( _destroySimulatedObject )
      {
         assert (_pointerToSimulatedObject != NULL) ;
         delete _pointerToSimulatedObject ;
         _pointerToSimulatedObject = NULL ;
      }
   _destroySimulatedObject = false ; 
}



const list<PsObjectDescriptor *> * PsObjectDescriptor::getSons() const 
{
   return & _sonsContainer ;
}

PsObjectDescriptor::SonsContainerType & PsObjectDescriptor::getSons()
{
   return _sonsContainer ;
}


void PsObjectDescriptor::addSon(PsObjectDescriptor * newSon ) 
{
   assert ( newSon != NULL ) ;
   const PsObjectDescriptor * duplicate = findDescendantNamed (newSon->getName() ) ;
   if ( duplicate == NULL )
      {
         _sonsContainer.push_back ( newSon ) ;
         newSon->_fathersDescription = this ;
      }
   else
      {
#ifdef _USESSTREAM
         ostringstream warningMessage ;
         warningMessage<<"PsObjectDescriptor::addSon named "<<newSon->getName()
                       <<" failed because descendant with the same name allready exists for object named "
                       <<getName()<<"\n";
         PsController::warning ( warningMessage.str() , PsController::SomeWarnings) ;
#else
         ostrstream warningMessage ;
         warningMessage<<"PsObjectDescriptor::addSon named "<<newSon->getName()
                       <<" failed because descendant with the same name allready exists for object named "
                       <<getName()<<"\n";
         warningMessage.put('\0') ;
         PsController::warning ( warningMessage.str() , PsController::SomeWarnings) ;
         delete warningMessage.str() ;
#endif
         // as respnsability is transfered and the son is not added, delete it
         delete newSon ;
      }
}



void PsObjectDescriptor::removeSon(PsObjectDescriptor * oldSon )
{
   _sonsContainer.remove (oldSon) ;
}



list<const PsObjectDescriptor *> * PsObjectDescriptor::getDescendants() const 
{
   list<const PsObjectDescriptor *> * result = new list<const PsObjectDescriptor *> () ;
   return getDescendants (result) ;
}


list<const PsObjectDescriptor *> * PsObjectDescriptor::getDescendants(list<const PsObjectDescriptor *> * resultList) const 
{
   for ( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         i != _sonsContainer.end() ;
         ++i )
      {
         resultList->push_back( (*i) ) ;
         (*i)->getDescendants ( resultList ) ;
      }
   return resultList ;
}


list<PsObjectDescriptor *> * PsObjectDescriptor::getDescendants()
{
   list<PsObjectDescriptor *> * result = new list<PsObjectDescriptor *> () ;
   return getDescendants (result) ;
}



list< PsObjectDescriptor *> * PsObjectDescriptor::getDescendants(list<PsObjectDescriptor *> * resultList)
{
   for ( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         i != _sonsContainer.end() ;
         ++i )
      {
         resultList->push_back( (*i) ) ;
         (*i)->getDescendants ( resultList ) ;
      }
   return resultList ;
}



const PsObjectDescriptor * 
PsObjectDescriptor::findDescendantNamed(const PsName & name) const 
{
   const PsObjectDescriptor * resul = NULL ;
   
   if ( name == getName() )
      {
         resul = this ;
      }
   else
      {
         SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         while ( (resul == NULL) &&
                 (i != _sonsContainer.end() ) )
            {
               resul = (*i)->findDescendantNamed ( name ) ;
               ++i ;
            } 
      }
   return resul ;  
}   



PsObjectDescriptor * 
PsObjectDescriptor::findDescendantNamed(const PsName & name) 
{
   PsObjectDescriptor * resul = NULL ;
   
   if ( name == getName() )
      {
         resul = this ;
      }
   else
      {
         SonsContainerType::iterator i = _sonsContainer.begin() ;
         while ( (resul == NULL) &&
                 (i != _sonsContainer.end() ) )
            {
               resul = (*i)->findDescendantNamed ( name ) ;
               ++i ;
            } 
      }
   return resul ;  
}   

void PsObjectDescriptor::interpretConfigurationParameterAsListOfSons (SonsContainerType & listOfSons,
                                                                      PsMultipleConfigurationParameter * sonsDescription )
{
   if ( sonsDescription != NULL )
      {
         int nbSons = sonsDescription->getNumberOfSubItems() ;
         string sonName ;
         for ( int i = 0 ; i < nbSons ; ++i )
            {
               PsConfigurationParameterDescriptor * aGenericSonsDescription ;
               aGenericSonsDescription = sonsDescription->getSubDescriptorByPosition(i) ;
               sonName = sonsDescription->getNameOfSubDescriptor (i) ;
               PsMultipleConfigurationParameter * aSonsDescription ;
               aSonsDescription = dynamic_cast<PsMultipleConfigurationParameter *> ( aGenericSonsDescription ) ;
               if ( aSonsDescription != NULL )
                  {
                     PsObjectDescriptor * descriptionOfSon ;
                     descriptionOfSon = interpretConfigurationParameterAsObjectDescription ( sonName,
                                                                                             aSonsDescription ) ;
                     listOfSons.push_back ( descriptionOfSon );
                  }
            }
      }
}

PsObjectDescriptor * PsObjectDescriptor::interpretConfigurationParameterAsObjectDescription ( string objectName,
                                                                                              PsMultipleConfigurationParameter * generalDescription ) 
{
   assert (generalDescription != NULL) ;

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

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

   string classId = genericSubDescription->getAssociatedString() ;


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


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


   PsObjectDescriptor * result = new PsObjectDescriptor (PsName (objectName), 
                                                         PsName (classId), 
                                                         schedulingParameters, 
                                                         configurationParameters) ;


   genericSubDescription = generalDescription->getSubDescriptorByName ("Sons") ;
   generalDescription = dynamic_cast<PsMultipleConfigurationParameter *> (genericSubDescription) ;
   if (generalDescription != NULL)
      {
         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 ;
}

---