---

PsObjectDescriptor.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 PsObjectDescriptorHEADER
#define PsObjectDescriptorHEADER

#include "PsFlowable.h"
#include "PsName.h"
#include "PsNumericType.h"
#include "PsnMutexLock.h"
#include "pthread.h"
#include <list>

class PsConfigurationParameterDescriptor ;
class PsMultipleConfigurationParameter ;
class PsSimulatedObject ;
class PsnObjectHandle ;

class PsObjectDescriptor : public PsFlowable 
{
public:   
   explicit PsObjectDescriptor () ;


   PsObjectDescriptor (const PsObjectDescriptor &) ;


   PsObjectDescriptor( const PsName & objectName, 
                       const PsName & classId, 
                       PsMultipleConfigurationParameter * schedulingParameters,
                       PsConfigurationParameterDescriptor * configurationParameters);
   

   PsObjectDescriptor( const PsName & objectName, 
                       const PsName & classId, 
                       const PsFrequency & frequency,
                       PsConfigurationParameterDescriptor * configurationParameters);
   

   PsObjectDescriptor( const PsName & objectName, 
                       const PsName & classId, 
                       const PsName & process,
                       const PsFrequency & frequency,
                       PsConfigurationParameterDescriptor * configurationParameters);
   

   virtual ~PsObjectDescriptor(); 
   

   virtual const PsName & getName () const ; 


   virtual const PsName & getClass () const ; 


   virtual const PsName & getProcess () const ; 


   virtual const PsFrequency & getFrequency () const ; 


   virtual const PsFrequency & getOriginalFrequency () const ; 


   virtual const PsConfigurationParameterDescriptor * getConfigurationParameters() const ;


   virtual PsConfigurationParameterDescriptor * getConfigurationParameters() ;


   virtual const PsMultipleConfigurationParameter * getOriginalSchedulingParameters() const ;


   virtual const PsMultipleConfigurationParameter * getSchedulingParameters() const ;


   virtual void setProcess ( const PsName & newProcessName ) ; 


   virtual void setFrequency ( const PsFrequency & newFrequency ) ; 


   virtual void deleteCachedData() ;

   virtual void unpack (PsIncomingSynchronisationMessage &) ;
   
   virtual void pack (PsOutgoingSynchronisationMessage &) const ;
   
   virtual void extract (istream & in) ;

   virtual void insertInStream (ostream & out) const ; 



   virtual const PsObjectDescriptor * getFathersObjectDescriptor() const ;
   

   virtual PsObjectDescriptor * getFathersObjectDescriptor() ;
   

   typedef list<PsObjectDescriptor *> SonsContainerType ;


   virtual SonsContainerType & getSons() ;


   virtual const list<PsObjectDescriptor *> * getSons() const ;


   virtual list<const PsObjectDescriptor *> * getDescendants() const ;


   virtual list<const PsObjectDescriptor *> * getDescendants(list<const PsObjectDescriptor *> * resultList) const ;


   virtual list<PsObjectDescriptor *> * getDescendants() ;


   virtual list<PsObjectDescriptor *> * getDescendants(list<PsObjectDescriptor *> * resultList) ;


   virtual void addSon(PsObjectDescriptor * newSon ) ;


   virtual void removeSon(PsObjectDescriptor * oldSon ) ;


   template <typename Type>
   list<const PsObjectDescriptor *> * listSonsOfType ( ) const ;


   template <typename Type> 
   list<const PsObjectDescriptor *> * listSonsOfType (list<const PsObjectDescriptor *> * resultList) const ;


   template <typename Type> 
   list<const PsObjectDescriptor *> * listDescendantsOfType ( ) const ;
   

   template <typename Type> 
   list<const PsObjectDescriptor *> * listDescendantsOfType (list<const PsObjectDescriptor *> * resultList ) const ;


   virtual const PsObjectDescriptor * findDescendantNamed(const PsName & name) const ;


   virtual PsObjectDescriptor * findDescendantNamed(const PsName & name) ;


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

   static PsObjectDescriptor * 
   interpretConfigurationParameterAsObjectDescription ( string objectName,
                                                        PsMultipleConfigurationParameter * ) ;
protected:
   friend class PsController ;


   friend class PsnObjectHandle ;

   friend class PsSimulatedObject ;

   virtual PsSimulatedObject * createDescribedObject( ) const ;   


   virtual void setFathersDescription (PsObjectDescriptor * newFather ) ;

   mutable PsSimulatedObject * _pointerToSimulatedObject ;           



   mutable bool _destroySimulatedObject ;


   void interpretSchedulingParameters (PsMultipleConfigurationParameter * schedulingParamters) ;

public:
   virtual PsMultipleConfigurationParameter * getSchedulingParameters();

protected:
   PsName _objectName ;         
   
   PsName _classId ; 
   
   PsConfigurationParameterDescriptor * _configurationParameters ;

   PsMultipleConfigurationParameter * _originalSchedulingParameters ;

   PsMultipleConfigurationParameter * _schedulingParameters ;

   PsObjectDescriptor * _fathersDescription ;


   SonsContainerType _sonsContainer ;

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


   mutable PsnMutexLock _dataLock ;

   mutable PsnCondition _createdCondition ;
 
   mutable bool _creatingObject ;

   mutable pthread_t _creatingThread ;
private:
   PsName _processId ;   
   
   PsFrequency _frequency ;     

   PsFrequency _originalFrequency ;     

};


// ---------------------------- implementation ---------------------------- /
template <typename Type>
list<const PsObjectDescriptor *> * 
PsObjectDescriptor::listSonsOfType ( ) const 
{
   return listSonsOfType< Type > ( new list<const PsObjectDescriptor *>() );  
}



template <typename Type> 
list<const PsObjectDescriptor *> * 
PsObjectDescriptor::listSonsOfType (list<const PsObjectDescriptor *> * resultList) const 
{
   for ( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         i != _sonsContainer.end() ;
         ++i )
      {
         if (dynamic_cast<Type *>( (*i)->createDescribedObject () ) != NULL)
            {
               resultList->push_back ( (*i) ) ;
            }
      }
   return resultList ;  
}



template <typename Type> 
list<const PsObjectDescriptor *> * 
PsObjectDescriptor::listDescendantsOfType ( ) const 
{
   return listDescendantsOfType<Type> ( new list<const PsObjectDescriptor *>() );  
}
   


template <typename Type> 
list<const PsObjectDescriptor *> * 
PsObjectDescriptor::listDescendantsOfType (list<const PsObjectDescriptor *> * resultList ) const 
{
   assert ( createDescribedObject () != NULL ) ;

   // test the current node
   if (dynamic_cast<Type *>( createDescribedObject () ) != NULL)
      {
         resultList->push_back ( this ) ;
      }

   //recurse through the sons
   for ( SonsContainerType::const_iterator i = _sonsContainer.begin() ;
         i != _sonsContainer.end() ;
         ++i )
      {
         assert ((*i)->getFathersObjectDescriptor() == this ) ; 
         (*i)->template listDescendantsOfType<Type> ( resultList ) ;
      }
   return resultList ;  
}

#endif
   
   

---