OMKObjectDescriptor.h

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 
 *
 */
#ifndef OMKObjectDescriptorHEADER
#define OMKObjectDescriptorHEADER

#include "OMKFlowable.h"
#include "OMKName.h"
#include "OMKTracer.h"
#ifdef _OMK_MUTEX_
#  include "OMKCondition.h"
#  include "OMKMutexLock.h"
#endif
#ifndef _MSC_VER
   #include "pthread.h"
#endif
#include <list>

namespace OMK
{
  class Controller ;
  class ConfigurationParameterDescriptor ;
  class MultipleConfigurationParameter ;
  class SimulatedObject ;
  class ObjectHandle ;

class OMK_API ObjectDescriptor : public Flowable
{
public:   
   explicit ObjectDescriptor() ;

   enum Distribution
   {
     DEFAULT_OBJECT = 0,
     LOCAL_OBJECT,
     DUPLICATED_OBJECT
   } ;

   ObjectDescriptor( const ObjectDescriptor & ) ;

   ObjectDescriptor( const Name & objectName,
                     const Name & classId,
                     MultipleConfigurationParameter * schedulingParameters,
                     ConfigurationParameterDescriptor * configurationParameters,
                     ConfigurationParameterDescriptor * extensionParameters = 0 ) ;

   ObjectDescriptor( const Name & objectName,
                     const Name & classId,
                     const Frequency & frequency,
                     ConfigurationParameterDescriptor * configurationParameters,
                     ConfigurationParameterDescriptor * extensionParameters = 0,
                     Distribution distribution = DEFAULT_OBJECT ) ;

   ObjectDescriptor( const Name & objectName,
                     const Name & classId,
                     const Name & processId,
                     const Frequency & frequency,
                     ConfigurationParameterDescriptor * configurationParameters,
                     ConfigurationParameterDescriptor * extensionParameters = 0,
                     Distribution distribution = DEFAULT_OBJECT ) ;

   virtual ~ObjectDescriptor(); 

   virtual const Name & getName() const
   {
     return _objectName ;
   }

   virtual const Name & getClass() const
   {
     return _classId ;
   }

   virtual const Name & getProcess() const
   {
     return _processId ;
   }

   virtual const Frequency & getFrequency() const
   {
     return _frequency ;
   }

   virtual const Frequency & getOriginalFrequency() const
   {
     return _originalFrequency ;
   }

   virtual Distribution getDistribution() const
   {
     return _distribution ;
   }

   virtual const ConfigurationParameterDescriptor * getConfigurationParameters() const
   {
     return _configurationParameters ;
   }

   virtual ConfigurationParameterDescriptor * getConfigurationParameters( bool create = false ) ;

   virtual const ConfigurationParameterDescriptor * getExtensionsParameters() const
   {
     return _extensionsParameters ;
   }

   virtual ConfigurationParameterDescriptor * getExtensionsParameters( bool create = false ) ;

   virtual const MultipleConfigurationParameter * getOriginalSchedulingParameters() const
   {
     return _originalSchedulingParameters ;
   }

   virtual const MultipleConfigurationParameter * getSchedulingParameters() const
   {
     return _schedulingParameters ;
   }

   virtual void setProcess( const Name & newProcessName ) ; 


   virtual void setFrequency( const Frequency & newFrequency ) ; 

   virtual void setDistribution( Distribution newDistribution ) ; 

   virtual void deleteCachedData() ;

   virtual void unpack( IncomingSynchronisationMessage & in ) ;
   
   virtual void pack( OutgoingSynchronisationMessage & out ) const ;
   
   virtual void extract( std::istream & in ) ;

   virtual void insertInStream( std::ostream & out ) const ;



   virtual const ObjectDescriptor * getFathersObjectDescriptor() const
   {
     return _fathersDescription ;
   }

   virtual ObjectDescriptor * getFathersObjectDescriptor()
   {
     return _fathersDescription ;
   }

   typedef std::list< ObjectDescriptor * > SonsContainerType ;


   virtual SonsContainerType & getSons()
   {
     return _sonsContainer ;
   }

   virtual const std::list< ObjectDescriptor * > * getSons() const
   {
     return & _sonsContainer ;
   }

   virtual std::list< const ObjectDescriptor * > * getDescendants() const ;


   virtual std::list< const ObjectDescriptor * > * getDescendants( std::list< const ObjectDescriptor * > * resultList ) const ;


   virtual std::list< ObjectDescriptor * > * getDescendants() ;


   virtual std::list< ObjectDescriptor * > * getDescendants( std::list< ObjectDescriptor * > * resultList ) ;


   virtual void addSon( ObjectDescriptor * newSon ) ;


   virtual void removeSon( ObjectDescriptor * oldSon ) ;


   template< typename type >
   std::list<const ObjectDescriptor *> * listSonsOfType() const ;


   template< typename type > 
   std::list<const ObjectDescriptor *> * listSonsOfType( std::list< const ObjectDescriptor * > * resultList ) const ;


   template< typename type > 
   std::list<const ObjectDescriptor *> * listDescendantsOfType() const ;
   

   template< typename type > 
   std::list<const ObjectDescriptor *> * listDescendantsOfType( std::list< const ObjectDescriptor * > * resultList ) const ;


   virtual const ObjectDescriptor * findDescendantNamed( const Name & name ) const ;


   virtual ObjectDescriptor * findDescendantNamed( const Name & name ) ;


   static void interpretConfigurationParameterAsListOfSons( SonsContainerType & listOfSons,
                                                            MultipleConfigurationParameter * sonsDescription ) ;

   static ObjectDescriptor * 
   interpretConfigurationParameterAsObjectDescription( std::string objectName,
                                                        MultipleConfigurationParameter * ) ;
protected:
  friend class Controller ;


  friend class ObjectHandle ;

   friend class SimulatedObject ;

   virtual SimulatedObject * createDescribedObject() const ;   


   virtual void setFathersDescription( ObjectDescriptor * newFather ) ;

   mutable SimulatedObject * _pointerToSimulatedObject ;


   mutable bool _destroySimulatedObject ;


   void interpretSchedulingParameters( MultipleConfigurationParameter * schedulingParameters ) ;

public:
   virtual MultipleConfigurationParameter * getSchedulingParameters()
   {
     return _schedulingParameters ;
   }

protected:
   Name _objectName ;         
   
   Name _classId ; 
   
   ConfigurationParameterDescriptor * _configurationParameters ;

   ConfigurationParameterDescriptor * _extensionsParameters ;

   MultipleConfigurationParameter * _originalSchedulingParameters ;

   MultipleConfigurationParameter * _schedulingParameters ;

   ObjectDescriptor * _fathersDescription ;


   SonsContainerType _sonsContainer ;

   virtual void printToStream( std::ostream & out, int currentOffset ) const ;


#ifdef _OMK_MUTEX_

   mutable OMKMutexLock _dataLock ;

   mutable OMKCondition _createdCondition ;
#endif

   mutable bool _creatingObject ;

#ifndef _MSC_VER

   mutable pthread_t _creatingThread ;
#endif

private:
   Name _processId ;   
   
   Frequency _frequency ;     

   Distribution _distribution ;     

   Frequency _originalFrequency ;     

};


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


template< typename Type >
std::list< const ObjectDescriptor * > *
ObjectDescriptor::listSonsOfType() const
{
  return listSonsOfType< Type >( new std::list< const ObjectDescriptor * >() );
}
//------------------------------------------------------------------------------
template< typename Type > 
std::list< const ObjectDescriptor * > *
ObjectDescriptor::listSonsOfType(
  std::list< const ObjectDescriptor * > * resultList ) const
{
  for( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
       i != _sonsContainer.end() ;
       ++i )
  {
    if( dynamic_cast< Type * >( ( *i )->createDescribedObject() ) != 0 )
    {
      resultList->push_back( *i ) ;
    }
  }
  return resultList ;
}
//------------------------------------------------------------------------------
template< typename Type > 
std::list< const ObjectDescriptor * > *
ObjectDescriptor::listDescendantsOfType() const
{
  return listDescendantsOfType< Type >(
    new std::list< const ObjectDescriptor * >() );
}
//------------------------------------------------------------------------------
template< typename Type > 
std::list< const ObjectDescriptor * > *
ObjectDescriptor::listDescendantsOfType(
  std::list< const ObjectDescriptor * > * resultList ) const
{
  OMASSERTM( createDescribedObject(), "Unable to create descriptor" ) ;

  // test the current node
  if( dynamic_cast< Type * >( createDescribedObject() ) != 0 )
  {
    resultList->push_back( this ) ;
  }
  //recurse through the sons
  for( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
       i != _sonsContainer.end() ;
       ++i )
  {
    OMASSERTM( ( *i )->getFathersObjectDescriptor() == this,
               "The father is not the good one" ) ;
    ( *i )->template listDescendantsOfType< Type >( resultList ) ;
  }
  return resultList ;
}
//------------------------------------------------------------------------------

}// namespace OMK

//typedef OMK::ObjectDescriptor ObjectDescriptor ;

#endif // OMKObjectDescriptorHEADER

---