./src/Container/Makefile \
./src/DSC/Makefile \
./src/DSC/DSC_Basic/Makefile \
+ ./src/DSC/DSC_User/Makefile \
./src/GenericObj/Makefile \
./src/HDFPersist/Makefile \
./src/KERNEL_PY/Makefile \
--- /dev/null
+lib_LTLIBRARIES = libSalomeDSCSupervBasic.la
+
+libSalomeDSCSupervBasic_la_SOURCES = basic_port_factory.cxx data_short_port_uses.cxx data_short_port_provides.cxx
+libSalomeDSCSupervBasic_la_CXXFLAGS = -I$(top_srcdir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_Basic\
+ -I$(top_builddir)/src/DSC_User \
+ -I@KERNEL_ROOT_DIR@/include/salome \
+ -I$(top_builddir)/idl \
+ @OMNIORB_INCLUDES@
+
+##################################################################################################################
+
+include_HEADERS = basic_port_factory.hxx data_short_port_provides.hxx data_short_port_uses.hxx
+
+CLEANFILES = *.hh *SK.cc
--- /dev/null
+// André Ribes - EDF R&D 2006
+//
+
+#include "basic_port_factory.hxx"
+
+basic_port_factory::basic_port_factory() {}
+
+basic_port_factory::~basic_port_factory() {}
+
+provides_port *
+basic_port_factory::create_data_servant(string type) {
+ provides_port * rtn_port = NULL;
+ if (type == "short") {
+ rtn_port = new data_short_port_provides();
+ }
+ return rtn_port;
+}
+
+uses_port *
+basic_port_factory::create_data_proxy(string type) {
+ uses_port * rtn_port = NULL;
+ if (type == "short")
+ rtn_port = new data_short_port_uses();
+ return rtn_port;
+}
--- /dev/null
+// André Ribes - EDF R&D 2006
+//
+
+#ifndef _BASIC_PORT_FACTORY_HXX_
+#define _BASIC_PORT_FACTORY_HXX_
+
+#include "data_short_port_provides.hxx"
+#include "data_short_port_uses.hxx"
+
+using namespace std;
+
+class basic_port_factory
+{
+ public:
+ basic_port_factory();
+ virtual ~basic_port_factory();
+
+ virtual provides_port * create_data_servant(string type);
+ virtual uses_port * create_data_proxy(string type);
+};
+
+#endif
+
--- /dev/null
+// André Ribes EDF R&D - 2006
+//
+#include "data_short_port_provides.hxx"
+
+data_short_port_provides::data_short_port_provides() {
+ _val = 0;
+}
+
+data_short_port_provides::~data_short_port_provides() {}
+
+void
+data_short_port_provides::put(CORBA::Short data) {
+ _val = data;
+}
+
+CORBA::Short
+data_short_port_provides::get() {
+ return _val;
+}
+
+CORBA::Short
+data_short_port_provides::get_local() {
+ return _val;
+}
+
+Ports::Port_ptr
+data_short_port_provides::get_port_ref() {
+ return this->_this();
+}
--- /dev/null
+// André Ribes EDF R&D - 2006
+//
+
+#ifndef _DATA_SHORT_PORT_PROVIDES_HXX_
+#define _DATA_SHORT_PORT_PROVIDES_HXX_
+
+#include <iostream>
+#include "SALOME_Ports.hh"
+#include "provides_port.hxx"
+
+class data_short_port_provides :
+ public virtual POA_Ports::Data_Short_Port,
+ public virtual provides_port
+{
+ public :
+ data_short_port_provides();
+ virtual ~data_short_port_provides();
+
+ virtual void put(CORBA::Short data);
+ virtual CORBA::Short get();
+ virtual CORBA::Short get_local();
+
+ virtual Ports::Port_ptr get_port_ref();
+
+ private :
+ CORBA::Short _val;
+};
+
+#endif
--- /dev/null
+// André Ribes EDF R&D - 2006
+//
+
+#include "data_short_port_uses.hxx"
+#include <iostream>
+using namespace std;
+
+data_short_port_uses::data_short_port_uses() {
+ _my_port = Ports::Data_Short_Port::_nil();
+ _my_ports = NULL;
+}
+
+data_short_port_uses::~data_short_port_uses() {}
+
+const char *
+data_short_port_uses::get_repository_id() {
+ return "IDL:Ports/Data_Short_Port:1.0";
+}
+
+bool
+data_short_port_uses::set_port(Ports::Port_ptr port) {
+ _my_port = Ports::Data_Short_Port::_narrow(port);
+}
+
+void
+data_short_port_uses::put(CORBA::Short data) {
+// if (!CORBA::is_nil(_my_port))
+// _my_port->put(data);
+ if (!_my_ports)
+ cerr << "data_short_port_uses::put is NULL" << endl;
+ else
+ {
+ for(int i = 0; i < _my_ports->length(); i++)
+ {
+ Ports::Data_Short_Port_ptr port = Ports::Data_Short_Port::_narrow((*_my_ports)[i]);
+ port->put(data);
+ }
+ }
+}
+
+void
+data_short_port_uses::uses_port_changed(Engines::DSC::uses_port * new_uses_port,
+ const Engines::DSC::Message message)
+{
+ if (_my_ports)
+ delete _my_ports;
+
+ cerr << "data_short_port_uses::uses_port_changed" << endl;
+ _my_ports = new Engines::DSC::uses_port(*new_uses_port);
+}
--- /dev/null
+// André Ribes EDF R&D - 2006
+//
+
+#ifndef _DATA_SHORT_PORT_USES_HXX_
+#define _DATA_SHORT_PORT_USES_HXX_
+
+#include "uses_port.hxx"
+#include "SALOME_Ports.hh"
+
+class data_short_port_uses :
+ public virtual uses_port
+{
+ public :
+ data_short_port_uses();
+ virtual ~data_short_port_uses();
+
+ virtual const char * get_repository_id();
+ virtual bool set_port(Ports::Port_ptr port);
+
+ virtual void put(CORBA::Short data);
+
+ virtual void uses_port_changed(Engines::DSC::uses_port * new_uses_port,
+ const Engines::DSC::Message message);
+
+ private :
+ Ports::Data_Short_Port_ptr _my_port;
+ Engines::DSC::uses_port * _my_ports;
+};
+
+#endif
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-24 16:30:34 +0100 (mer, 24 jan 2007) $
+// Id : $Id$
+
+
+#ifndef _ADJACENT_FUNCTOR_HXX_
+#define _ADJACENT_FUNCTOR_HXX_
+
+#include "ConstTraits.hxx"
+// Pour affichage
+#include "DisplayPair.hxx"
+//
+
+// Suppose que le container est trié
+template < typename T > struct AdjacentFunctor {
+
+ typedef typename ConstTrait<T>::NonConstType TNoConst;
+ const T & _minValue;
+ T _maxValue;
+ TNoConst _max;
+ TNoConst _min;
+ bool _minFound,_maxFound,_equal;
+
+ AdjacentFunctor(const T& value):_minValue(value),_maxValue(value),
+ _minFound(false),_maxFound(false),
+ _equal(false) {}
+
+ // Suppose que les valeurs passées en paramètres sont triées par ordre croissant
+ bool operator()(const T &v1) {
+ if ( v1 < _minValue) {
+ std::cout << "EE1: _min : " << _min << std::endl;
+ _min=v1;_minFound=true;
+ std::cout << "AdjacentFunctor: _minFound : " <<_min << ", _minValue " << _minValue << std::endl;
+ } else if ( v1 > _maxValue ) {
+ _max=v1;_maxFound=true;
+ std::cout << "AdjacentFunctor: _maxFound : " <<_max << ", _maxValue " << _maxValue << std::endl;
+ } else {
+ _equal= true;
+ std::cout << "AdjacentFunctor: _equal : " << v1<< ", _minValue " << _minValue << ", _maxValue " << _maxValue << std::endl;
+ return true;
+ } // end if
+
+ std::cout << "AdjacentFunctor: _minFound : " <<_min << ", _maxFound " << _max << std::endl;
+ return ( _minFound && _maxFound );
+ }
+
+ void setMaxValue(const T & value) {_maxValue = value;}
+ bool isEqual() const { return _equal;}
+ bool isBounded() const { return _minFound && _maxFound;}
+ bool getBounds(TNoConst & min, TNoConst & max) const {
+ std::cout << "_minFound : " <<_minFound << ", _maxFound " << _maxFound << std::endl;
+ if (_minFound && _maxFound ) { min=_min; max=_max; return true; }
+ return false;
+ }
+ void reset() { _minFound = false; _maxFound = false; _equal = false; };
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef __ADJACENT_PREDICATE__
+#define __ADJACENT_PREDICATE__
+
+#include <functional>
+#include <utility>
+#include "DisplayPair.hxx"
+
+template < typename T >
+struct AdjacentPredicate : public std::binary_function < T, T, bool >
+{
+ T _value;
+ AdjacentPredicate(const T& value):_value(value){}
+ bool operator()(const T &v1, const T& v2) const {
+ return (v1 <= _value ) && (_value < v2) ;
+ }
+};
+
+// Pour les MAPs avec une clef sous forme de pair
+template <typename T1, typename T2, typename T3>
+struct AdjacentPredicate< std::pair<const std::pair<T1,T2>, T3 > > :
+ public std::binary_function < std::pair<const std::pair<T1,T2>, T3 >,
+ std::pair<const std::pair<T1,T2>, T3 >, bool >
+{
+ std::pair<T1,T2> _value;
+ AdjacentPredicate(const std::pair<T1,T2> & value):_value(value){
+ std::cout << "1-Initializing with value " << _value << std::endl;
+ }
+ bool operator()( const std::pair<const std::pair<T1,T2>, T3 > & v1,
+ const std::pair<const std::pair<T1,T2>, T3 > v2) const {
+ std::cout << "1-> :" << v1 << "," << v2 << " " << std::endl;
+ return (v1.first <= _value ) && (_value < v2.first) ;
+ }
+};
+
+template <typename T1, typename T2>
+struct AdjacentPredicate< std::pair<T1,T2> > : public std::binary_function < std::pair<T1,T2>, std::pair<T1,T2>, bool >
+{
+ T1 _value;
+ AdjacentPredicate(const T1 & value):_value(value){
+ std::cout << "2-Initializing with value " << _value << std::endl;
+ }
+ bool operator()( const std::pair<T1,T2> & v1, const std::pair<T1,T2>& v2) const {
+ std::cout << "2-> :" << &(v1.first) << "," << &(v2.first) << " " << std::endl;
+ return (v1.first <= _value ) && (_value < v2.first) ;
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate$
+// Id : $Id$
+
+#include "calcium.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+// Interface C de SalomeCalcium
+
+typedef int InfoType;
+typedef int bool;
+
+// INTERFACES DE LECTURE
+
+
+// Definition des méthodes calcium étendues
+// permettant le 0 copy.
+//const char * nomvar
+#define CALCIUM_EXT_LECT_INTERFACE_C_(_name,_timeType,_type,_typeName,_qual) \
+ InfoType ecp_##_name (void * component, int mode, \
+ _timeType * ti, _timeType * tf, int * i, \
+ char * nomvar, int bufferLength, \
+ int * nRead, _type _qual ** data ) { \
+ size_t _nRead; \
+ long _i=*i; \
+ \
+ /* std::cerr << "-------- CalciumInterface(C Part) MARK 1 ------------------" << std::endl; */ \
+ InfoType info = ecp_lecture_##_typeName (component, mode, ti, tf, &_i, \
+ nomvar, bufferLength, &_nRead, \
+ data ); \
+ /* std::cout << "-------- CalciumInterface(C Part), Valeur de data : " << std::endl; */ \
+ /* std::cout << "Ptr :" << *data << std::endl; */ \
+ /* for (int j=0; j<_nRead;++j) */ \
+ /* printf("--- Valeur de data[%d] : %d \n",j,(*data)[j]); */ \
+ /* std::cout << "Ptr :" << *data << std::endl; */ \
+ /* */ \
+ /* std::cerr << "-------- CalciumInterface(C Part) MARK 2 ------------------" << std::endl; */ \
+ *i = _i; \
+ *nRead=_nRead; \
+ /* std::cerr << "-------- CalciumInterface(C Part) MARK 3 ------------------" << std::endl; */ \
+ \
+ return info; \
+ }; \
+ void ecp_##_name##_free ( _type _qual * data) { \
+ ecp_lecture_##_typeName##_free(data); \
+ };
+
+CALCIUM_EXT_LECT_INTERFACE_C_(len,float,int,int,);
+CALCIUM_EXT_LECT_INTERFACE_C_(lre,float,float,float,);
+CALCIUM_EXT_LECT_INTERFACE_C_(ldb,double,double,double,);
+CALCIUM_EXT_LECT_INTERFACE_C_(llo,float,bool,bool,);
+CALCIUM_EXT_LECT_INTERFACE_C_(lcp,float,float,cplx,);
+#define STAR *
+// CALCIUM_EXT_LECT_INTERFACE_C_(lch,float,char,STAR[]);
+// La signature n'est pas la même pour les chaines de caractères il y a aussi
+// la taille des chaines
+
+//const char * nomvar
+
+#define CALCIUM_LECT_INTERFACE_C_(_name,_timeType,_type,_typeName,_qual) \
+ InfoType cp_##_name (void * component, int mode, \
+ _timeType * ti, _timeType * tf, int * i, \
+ char * nomvar, int bufferLength, \
+ int * nRead, _type _qual * data ) { \
+ size_t _nRead; \
+ long _i=*i; \
+ \
+ if ( (data == NULL) || (bufferLength < 1) ) return CPNTNULL; \
+ \
+ InfoType info = ecp_lecture_##_typeName (component, mode, ti, tf, &_i, \
+ nomvar, bufferLength, &_nRead, \
+ &data ); \
+ *i = _i; \
+ *nRead=_nRead; \
+ \
+ return info; \
+ }; \
+ void cp_##_name##_free ( _type _qual * data) { \
+ ecp_lecture_##_typeName##_free(data); \
+ };
+
+
+// Definition des méthodes calcium standard
+
+CALCIUM_LECT_INTERFACE_C_(len,float,int,int,);
+CALCIUM_LECT_INTERFACE_C_(lre,float,float,float,);
+CALCIUM_LECT_INTERFACE_C_(ldb,double,double,double,);
+CALCIUM_LECT_INTERFACE_C_(llo,float,bool,bool,);
+CALCIUM_LECT_INTERFACE_C_(lcp,float,float,cplx,);
+#define STAR *
+// CALCIUM_LECT_INTERFACE_C_(lch,float,char,STAR);
+
+
+// INTERFACES DE DÉBUT ET DE FIN DE COUPLAGE
+
+InfoType cp_cd (void * component, char * instanceName) {
+ /* TODO : Trouver le nom de l'instance SALOME*/
+ if (instanceName) strcpy(instanceName,"UNDEFINED");
+ return CPOK;
+}
+InfoType cp_fin (void * component, int code) {
+ /* TODO : gérer avec les callbacks des ports DSC */
+
+ InfoType info = ecp_fin_(component,code);
+
+ return info;
+}
+
+
+
+#define CALCIUM_ECR_INTERFACE_C_(_name,_timeType,_type,_typeName,_qual) \
+ InfoType cp_##_name (void * component, int mode, \
+ _timeType t, int i, \
+ char * nomvar, int nbelem, \
+ _type _qual * data ) { \
+ \
+ /*long _i=i;*/ \
+ if ( (data == NULL) || (nbelem < 1) ) return CPNTNULL; \
+ printf("cp_name : Valeur de nomvar %s\n",nomvar); \
+ \
+ InfoType info = ecp_ecriture_##_typeName (component, mode, &t, i, \
+ nomvar, nbelem, \
+ data ); \
+ \
+ return info; \
+ }; \
+
+
+// Definition des méthodes calcium standard
+
+CALCIUM_ECR_INTERFACE_C_(een,float,int,int,);
+CALCIUM_ECR_INTERFACE_C_(ere,float,float,float,);
+CALCIUM_ECR_INTERFACE_C_(edb,double,double,double,);
+CALCIUM_ECR_INTERFACE_C_(elo,float,bool,bool,);
+CALCIUM_ECR_INTERFACE_C_(ecp,float,float,cplx,);
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#include "CalciumCouplingPolicy.hxx"
+
+CalciumCouplingPolicy::CalciumCouplingPolicy():_dependencyType(CalciumTypes::UNDEFINED_DEPENDENCY),
+ _storageLevel(CalciumTypes::UNLIMITED_STORAGE_LEVEL),
+ _dateCalSchem(CalciumTypes::TI_SCHEM),
+ _interpolationSchem(CalciumTypes::L1_SCHEM),
+ _extrapolationSchem(CalciumTypes::UNDEFINED_EXTRA_SCHEM),
+ _alpha(0.0),_deltaT(CalciumTypes::EPSILON),
+ _disconnectDirective(CalciumTypes::UNDEFINED_DIRECTIVE){};
+
+void CalciumCouplingPolicy::setDependencyType (CalciumTypes::DependencyType dependencyType) {_dependencyType=dependencyType;}
+CalciumTypes::DependencyType CalciumCouplingPolicy::getDependencyType () const { return _dependencyType;}
+
+void CalciumCouplingPolicy::setStorageLevel (size_t storageLevel) {
+ if ( storageLevel < 1 )
+ throw DATASTREAM_EXCEPTION(LOC("Un niveau < 1 n'est pas autorisé"));
+ _storageLevel = storageLevel;
+}
+size_t CalciumCouplingPolicy::getStorageLevel () const {return _storageLevel;}
+void CalciumCouplingPolicy::setDateCalSchem (CalciumTypes::DateCalSchem dateCalSchem) {
+ if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
+ throw DATASTREAM_EXCEPTION(LOC("Il est impossible de positionner un schéma temporel sur un port en dépendance itérative"));
+ _dateCalSchem = dateCalSchem;
+}
+
+CalciumTypes::DateCalSchem CalciumCouplingPolicy::getDateCalSchem () const {
+ if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
+ throw DATASTREAM_EXCEPTION(LOC("Un schéma temporel sur un port en dépendance itérative n'a pas de sens"));
+ return _dateCalSchem;
+}
+
+void CalciumCouplingPolicy::setAlpha(double alpha) {
+ if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
+ throw DATASTREAM_EXCEPTION(LOC("Il est impossible de positionner alpha sur un port en dépendance itérative"));
+
+ if ( 0 <= alpha <= 1 ) _alpha = alpha;
+ else
+ throw DATASTREAM_EXCEPTION(LOC("Le paramètre alpha doit être compris entre [0,1]"));
+}
+
+double CalciumCouplingPolicy::getAlpha() const {
+ if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
+ throw DATASTREAM_EXCEPTION(LOC("Le paramètre alpha sur un port en dépendance itérative n'a pas de sens"));
+ return _alpha;
+}
+
+void CalciumCouplingPolicy::setDeltaT(double deltaT ) {
+ if ( 0 <= deltaT <= 1 ) _deltaT = deltaT;
+ else
+ throw(DATASTREAM_EXCEPTION(LOC("Le paramètre deltaT doit être compris entre [0,1]")));
+}
+double CalciumCouplingPolicy::getdeltaT() const {return _deltaT;}
+
+void CalciumCouplingPolicy::setInterpolationSchem (CalciumTypes::InterpolationSchem interpolationSchem) {_interpolationSchem=interpolationSchem;}
+void CalciumCouplingPolicy::setExtrapolationSchem (CalciumTypes::ExtrapolationSchem extrapolationSchem) {_extrapolationSchem=extrapolationSchem;}
+
+
+CalciumCouplingPolicy::TimeType
+CalciumCouplingPolicy::getEffectiveTime(CalciumCouplingPolicy::TimeType ti,
+ CalciumCouplingPolicy::TimeType tf) {
+ if ( _dateCalSchem == CalciumTypes::TI_SCHEM ) return ti;
+ if ( _dateCalSchem == CalciumTypes::TF_SCHEM ) return tf;
+
+ //CalciumTypes::ALPHA_SCHEM
+ return tf*_alpha + ti*(1-_alpha);
+}
+
+void CalciumCouplingPolicy::disconnect(bool provideLastGivenValue) {
+ if (provideLastGivenValue) {
+ std::cout << "-------- CalciumCouplingPolicy::disconnect CP_CONT ------------------" << std::endl;
+ _disconnectDirective = CalciumTypes::CONTINUE;
+ } else {
+ std::cout << "-------- CalciumCouplingPolicy::disconnect CP_ARRET ------------------" << std::endl;
+ _disconnectDirective = CalciumTypes::STOP;
+ }
+}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef __CALCIUM_COUPLING_POLICY__
+#define __CALCIUM_COUPLING_POLICY__
+
+#include <vector>
+#include <map>
+#include "DisplayPair.hxx"
+#include "CouplingPolicy.hxx"
+#include "AdjacentFunctor.hxx"
+#include "lambda.hpp"
+#include "CalciumTypes.hxx"
+#include "DSC_Exception.hxx"
+typedef DSC_Exception DATASTREAM_EXCEPTION;
+
+class CalciumCouplingPolicy : public CouplingPolicy {
+ template <typename T_TIME, typename T_TAG > class InternalDataIdContainer;
+ template <typename T_TIME, typename T_TAG > friend class InternalDataIdContainer;
+ template <typename DataManipulator > friend class BoundedDataIdProcessor;
+ template <typename DataManipulator > friend class EraseDataIdProcessor;
+ template <typename DataManipulator > friend class DisconnectProcessor;
+
+
+public:
+
+ typedef CalciumTypes::DependencyType DependencyType;
+ typedef CalciumTypes::DateCalSchem DateCalSchem;
+ typedef CalciumTypes::InterpolationSchem InterpolationSchem;
+ typedef CalciumTypes::ExtrapolationSchem ExtrapolationSchem;
+ typedef CalciumTypes::DisconnectDirective DisconnectDirective;
+
+private:
+ DependencyType _dependencyType;
+ size_t _storageLevel;
+ DateCalSchem _dateCalSchem;
+ InterpolationSchem _interpolationSchem;
+ ExtrapolationSchem _extrapolationSchem;
+ double _alpha;
+ double _deltaT;
+ DisconnectDirective _disconnectDirective;
+
+public:
+ CalciumCouplingPolicy();
+
+ void setDependencyType (DependencyType dependencyType);
+ DependencyType getDependencyType () const;
+
+ void setStorageLevel (size_t storageLevel);
+ size_t getStorageLevel () const;
+
+ void setDateCalSchem (DateCalSchem dateCalSchem);
+ DateCalSchem getDateCalSchem () const;
+
+ void setAlpha(double alpha);
+ double getAlpha() const ;
+
+ void setDeltaT(double deltaT );
+ double getdeltaT() const ;
+
+ void setInterpolationSchem (InterpolationSchem interpolationSchem);
+ void setExtrapolationSchem (ExtrapolationSchem extrapolationSchem);
+
+ // Classe DataId rassemblant les paramètres de la méthode PORT::put
+ // qui identifient l'instance d'une donnée pour Calcium
+ // Rem : Le DataId doit pouvoir être une key dans une map stl
+ // typedef CORBA::Double TimeType;
+ // typedef CORBA::Long TagType;
+ typedef double TimeType;
+ typedef long TagType;
+ typedef std::pair< TimeType , TagType > DataId;
+ typedef InternalDataIdContainer < TimeType , TagType > DataIdContainer;
+ typedef std::vector< DataId >::iterator iterator;
+
+ template <typename T_TIME, typename T_TAG >
+ struct InternalDataIdContainer;
+
+ inline TimeType getTime(const DataId &dataId) const { return dataId.first;}
+ inline TagType getTag (const DataId &dataId) const { return dataId.second;}
+
+ // TODO : Vérifier l'application pour tous les types de données
+ template <typename DataManipulator> struct BoundedDataIdProcessor;
+ template <typename DataManipulator> struct EraseDataIdProcessor;
+ template <typename DataManipulator> struct DisconnectProcessor;
+
+ // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
+ // - l'itérateur wDataIt1 pointe alors sur ce dataId
+ // Renvoie isBounded si le dataId attendu n'est pas trouvé mais encadrable et
+ // que la politique de couplage gére ce cas de figure
+ // - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
+ // Le container doit être associatif
+ template < typename AssocContainer >
+ bool isDataIdConveniant( AssocContainer & storedDatas,
+ const typename AssocContainer::key_type & expectedDataId,
+ bool & isEqual, bool & isBounded,
+ typename AssocContainer::iterator & wDataIt1) const;
+
+ TimeType getEffectiveTime(TimeType ti, TimeType tf);
+
+ void disconnect(bool provideLastGivenValue);
+
+}; //Fin de CalciumCouplingPolicy
+
+
+
+//************* DEFINITION DES METHODES ET OBJETS TEMPLATES *************//
+
+
+
+// Définition du container de DataId pour répondre au concept
+// de mode de couplage
+template <typename T_TIME, typename T_TAG >
+struct CalciumCouplingPolicy::InternalDataIdContainer : public std::vector< std::pair< T_TIME,T_TAG> > {
+ typedef std::vector < DataId > DataIdVect;
+
+ InternalDataIdContainer(const DataId & dataId,
+ const CalciumCouplingPolicy & policy
+ ):std::vector< std::pair< T_TIME,T_TAG> >() {
+ // Ignore les paramètres qui ne sont pas en rapport avec le type de dépendance
+ switch (policy._dependencyType) {
+ case CalciumTypes::TIME_DEPENDENCY:
+ push_back(DataId(dataId.first,0));
+ break;
+ case CalciumTypes::ITERATION_DEPENDENCY:
+ push_back(DataId(0,dataId.second));
+ break;
+ default:
+ throw(DATASTREAM_EXCEPTION(LOC("The dependency type must be set by setDependencyType before calling DataIdContainer contructor")));
+ break;
+ }
+ };
+};
+
+
+// TODO : Vérifier l'application pour tous les types de données
+// DESACTIVER POUR ?BOOL? et CHAR *
+template <typename DataManipulator>
+struct CalciumCouplingPolicy::BoundedDataIdProcessor{
+
+ CalciumCouplingPolicy _couplingPolicy;
+
+ BoundedDataIdProcessor(CalciumCouplingPolicy couplingPolicy):
+ _couplingPolicy(couplingPolicy) {};
+
+ // Méthode implémentant l'interpolation temporelle
+ template < typename MapIterator >
+ void inline apply (typename iterator_t<MapIterator>::value_type & data,
+ const DataId & dataId, const MapIterator & it1) {
+
+ typedef typename iterator_t<MapIterator>::value_type value_type;
+ typedef typename DataManipulator::InnerType InnerType;
+ typedef typename DataManipulator::Type Type;
+
+ MapIterator it2=it1; ++it2;
+ size_t dataSize1 = DataManipulator::size(it1->second);
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId1 : " << dataSize1 << std::endl;
+
+ // Gérer dans calcium la limite de la taille du buffer donnée par
+ // l'utilisateur.
+ size_t dataSize2 = DataManipulator::size(it2->second);
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId2 : " << dataSize2 << std::endl;
+
+ size_t dataSize = std::min< size_t >( dataSize1, dataSize2 );
+ DataId dataId2 = it2->first;
+ DataId dataId1 = it1->first;
+ TimeType t2 = dataId2.first;
+ TimeType t1 = dataId1.first;
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t1 : " << t1 << std::endl;
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t2 : " << t2 << std::endl;
+ TimeType t = dataId.first;
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t : " << t << std::endl;
+ TimeType timeDiff = t2-t1;
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de timeDiff : " << timeDiff << std::endl;
+ TimeType coeff = (t2-t)/timeDiff;
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de coeff : " << coeff << std::endl;
+
+ InnerType const * const InIt1 = DataManipulator::getPointer(it1->second);
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t1 : " << std::endl;
+ std::copy(InIt1,InIt1+dataSize1,std::ostream_iterator<InnerType>(std::cout," "));
+ std::cout << std::endl;
+ InnerType const * const InIt2 = DataManipulator::getPointer(it2->second);
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t2 : " << std::endl;
+ std::copy(InIt2,InIt2+dataSize2,std::ostream_iterator<InnerType>(std::cout," "));
+ std::cout << std::endl;
+ Type dataOut = DataManipulator::create(dataSize);
+ InnerType * const OutIt = DataManipulator::getPointer(dataOut);
+
+ if ( timeDiff == 0.0 || _couplingPolicy._interpolationSchem == CalciumTypes::L0_SCHEM ) {
+ std::copy(InIt1,InIt1+dataSize,OutIt);
+ } else {
+
+ boost::lambda::placeholder1_type _1;
+ boost::lambda::placeholder2_type _2;
+ // REM : Pour des buffers de type int
+ // le compilo indiquera warning: converting to `long int' from `Double'
+ std::transform(InIt1,InIt1+dataSize,InIt2,OutIt,
+ ( _1 - _2 ) * coeff + _2 );
+ }
+ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données calculées à t : " << std::endl;
+ std::copy(OutIt,OutIt+dataSize,std::ostream_iterator<InnerType>(std::cout," "));
+ std::cout << std::endl;
+ data = dataOut;
+
+ }
+};
+
+// Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
+// - l'itérateur wDataIt1 pointe alors sur ce dataId
+// Renvoie isBounded si le dataId attendu n'est pas trouvé mais encadrable et
+// que la politique de couplage gére ce cas de figure
+// - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
+// Le container doit être associatif
+template < typename AssocContainer >
+bool CalciumCouplingPolicy::isDataIdConveniant( AssocContainer & storedDatas, const typename AssocContainer::key_type & expectedDataId,
+ bool & isEqual, bool & isBounded, typename AssocContainer::iterator & wDataIt1) const {
+
+ // Rem : le type key_type == DataId
+ typedef typename AssocContainer::key_type key_type;
+ AdjacentFunctor< key_type > af(expectedDataId);
+ if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
+ af.setMaxValue(key_type(expectedDataId.first*(1.0-_deltaT),0));
+ isBounded = false;
+
+ // Rem 1 :
+ // L'algo adjacent_find ne peut être utilisé avec l'AdjacentPredicate
+ // - si la table contient un seul élément l'algorithme adjacent_find retourne end()
+ // que se soit l'élément attendu ou non
+ // - si la table contient deux éléments dont le dernier est celui recherché
+ // l'algorithme adjacent_find retourne end() aussi
+ // d'ou la necessité d'effectuer un find avant ou d'écrire un algorithme ad hoc
+
+ // Rem 2 :
+ //
+ // L'algo find_if ne peut être utilisé car il recopie l'AdjacentFunctor
+ // qui ne peut alors pas mémoriser ses états précédents
+ //
+
+ // Un codage en reverse serait plus efficace
+ typename AssocContainer::iterator prev = storedDatas.begin();
+ typename AssocContainer::iterator current = prev;
+ while ( (current != storedDatas.end()) &&
+ !af(current->first) ) {
+ // if ( af(current->first) ) break;
+ prev = current++;
+ }
+
+ isEqual = af.isEqual();
+
+ // On considère qu'il n'est pas possible d'encadrer en dépendance itérative,
+ // on se veut pas calculer d'interpolation.
+ if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY) isBounded = af.isBounded();
+
+ if ( isEqual ) wDataIt1 = current;
+ else
+ if (isBounded) wDataIt1 = prev;
+ else
+ wDataIt1 = storedDatas.end();
+
+ std::cout << "-------- isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
+
+ return isEqual || isBounded;
+}
+
+
+// Supprime les DataId et les données associées
+// du container associative quand le nombre
+// de données stockées dépasse le niveau CALCIUM.
+// Cette méthode est appelée de GenericPort::Get
+// TODO : Elle devrait également être appelée dans GenericPort::Put
+// mais il faut étudier les interactions avec GenericPort::Get et GenericPort::next
+template < typename DataManipulator >
+struct CalciumCouplingPolicy::EraseDataIdProcessor {
+
+ CalciumCouplingPolicy _couplingPolicy;
+
+ EraseDataIdProcessor(CalciumCouplingPolicy couplingPolicy):
+ _couplingPolicy(couplingPolicy) {};
+
+ template < typename Container >
+ void apply(Container & storedDatas,
+ typename Container::iterator & wDataIt1 ) const {
+
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+
+ std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl;
+
+ if ( _couplingPolicy._storageLevel == CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return;
+
+ size_t storedDatasSize = storedDatas.size();
+ long s = storedDatasSize - _couplingPolicy._storageLevel;
+ if (s > 0 ) {
+ size_t dist=distance(storedDatas.begin(),wDataIt1);
+ for (int i=0; i<s; ++i) {
+ DataManipulator::delete_data((*storedDatas.begin()).second);
+ storedDatas.erase(storedDatas.begin());
+ }
+ // Si l'itérateur pointait sur une valeur que l'on vient de supprimer
+ if (dist < s ) {
+ throw(DATASTREAM_EXCEPTION(LOC(OSS()<< "La gestion du niveau CALCIUM "
+ << _couplingPolicy._storageLevel <<
+ " vient d'entraîner la suppression de la donnée à renvoyer")));
+ }
+ }
+ std::cout << "-------- CalciumCouplingPolicy::eraseDataId, new storedDatasSize : " << storedDatas.size() << std::endl;
+ return;
+
+ }
+};
+
+
+// Lorsque cette méthode est appelée l'expectedDataId n'a pas été trouvé
+// et n'est pas non plus encadrée (en mode temporel)
+// Si l'on effectue pas de traitement particulier la méthode renvoie false
+// Si le port a reçu une directive STOP une exception est levée
+// Si le port a reçu une directive CONTINUE, on localise l'expected
+template < typename DataManipulator >
+struct CalciumCouplingPolicy::DisconnectProcessor {
+
+ CalciumCouplingPolicy _couplingPolicy;
+
+ DisconnectProcessor(CalciumCouplingPolicy couplingPolicy):
+ _couplingPolicy(couplingPolicy) {};
+
+ template < typename Container, typename DataId >
+ bool apply(Container & storedDatas,
+ const DataId & expectedDataId,
+ typename Container::iterator & wDataIt1 ) const {
+
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+
+ // Pas de traitement particulier a effectuer
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK1 --------" << std::endl;
+ if ( _couplingPolicy._disconnectDirective == CalciumTypes::UNDEFINED_DIRECTIVE ) return false;
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor, CP_CONT : " << (*wDataIt1).first << std::endl;
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK2 --------" << std::endl;
+ throw(DATASTREAM_EXCEPTION(LOC(OSS()<< "La directive CP_ARRET"
+ << " provoque l'interruption de toute lecture de données")));
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK3 --------" << std::endl;
+
+ // S'il n'y a plus de données indique que l'on a pas pu effectuer de traitement
+ if ( storedDatas.empty() )
+ throw(DATASTREAM_EXCEPTION(LOC(OSS()<< "La directive CP_CONT"
+ << " est active mais aucune donnée n'est disponible.")));
+
+ // expectedDataId n'a ni été trouvé dans storedDataIds ni encadré mais il se peut
+ // qu'en mode itératif il ne soit pas plus grand que le plus grand DataId stocké auquel
+ // cas on doit renvoyer une expection car on n'est plus connecté et on ne pourra jamais
+ // fournir de données pour ce dataId.
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK4 --------" << std::endl;
+
+ iterator it1 = storedDatas.lower_bound(expectedDataId);
+ if (it1 != storedDatas.end())
+ throw(DATASTREAM_EXCEPTION(LOC(OSS()<< "La directive CP_CONT"
+ << " est active mais le dataId demandé est inférieur ou égal au dernier reçu.")));
+
+
+ wDataIt1 = storedDatas.end();
+ --wDataIt1;
+ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor, CP_CONT : " << (*wDataIt1).first << std::endl;
+
+ return true;
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-03-01 13:40:26 +0100 (jeu, 01 mar 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_GENERIC_PROVIDES_PORT_HXX_
+#define _CALCIUM_GENERIC_PROVIDES_PORT_HXX_
+
+//include utile ? :
+#include "Calcium_Ports.hh"
+
+#include "provides_port.hxx"
+
+#include "GenericPort.hxx"
+#include "CalciumCouplingPolicy.hxx"
+
+// TODO: Creer un trait qui à partir de CorbaInterface déduit CorbaDataManipulator
+// et simplifier la classe
+
+//
+// Avant d'utiliser la macro : template <typename CorbaInterface, typename CorbaDataManipulator >
+//
+// utilisation de __VA_ARGS__ au lieu de CorbaDataManipulator car à l'appel de la
+// macro le token du troisième argument contient une virgule qui est considéré comme
+// séparateur d'argument par le PP
+#define CALCIUM_GENERIC_PROVIDES_PORT(specificPortName,CorbaInterface,...) \
+ class specificPortName : public virtual CorbaInterface , \
+ public virtual provides_port, \
+ public GenericPort< __VA_ARGS__ , CalciumCouplingPolicy > { \
+ public : \
+ typedef __VA_ARGS__ DataManipulator; \
+ typedef DataManipulator::Type CorbaDataType; \
+ typedef GenericPort< DataManipulator , \
+ CalciumCouplingPolicy > Port; \
+ \
+ virtual ~ specificPortName (); \
+ \
+ inline void disconnect(bool provideLastGivenValue) { \
+ Port::disconnect(provideLastGivenValue); \
+ } \
+ \
+ inline void put( DataManipulator::CorbaInType data, \
+ CORBA::Double time, CORBA::Long tag) { \
+ Port::put(data, time, tag); \
+ } \
+ \
+ inline Ports::Port_ptr get_port_ref() { \
+ return _this(); \
+ } \
+ }; \
+
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_GENERIC_USES_PORT_HXX_
+#define _CALCIUM_GENERIC_USES_PORT_HXX_
+
+#include "GenericUsesPort.hxx"
+#include "calcium_uses_port.hxx"
+
+template <typename DataManipulator, typename CorbaPortType, char * repositoryName >
+class CalciumGenericUsesPort : public GenericUsesPort<DataManipulator,CorbaPortType, repositoryName,
+ calcium_uses_port >
+{
+public :
+ virtual ~CalciumGenericUsesPort() {};
+ void disconnect(bool provideLastGivenValue);
+
+};
+
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName >
+void
+CalciumGenericUsesPort< DataManipulator,CorbaPortType, repositoryName >::disconnect(bool provideLastGivenValue ) {
+
+ typedef typename CorbaPortType::_ptr_type CorbaPortTypePtr;
+
+ if (!_my_ports)
+ throw DSC_Exception(LOC("There is no connected provides port to communicate with."));
+
+ for(int i = 0; i < _my_ports->length(); i++) {
+ CorbaPortTypePtr port = CorbaPortType::_narrow((*_my_ports)[i]);
+ try {
+ std::cerr << "-------- CalciumGenericUsesPort<>::disconnect"<< std::endl;
+
+ port->disconnect(provideLastGivenValue);
+ } catch(const CORBA::SystemException& ex){
+ throw DSC_Exception(LOC(OSS() << "Impossible d'invoquer la méthode disconnect sur le port provide n°"
+ << i << "( i>= 0)"));
+ }
+ }
+
+}
+
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-03-01 13:27:58 +0100 (jeu, 01 mar 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_INTERFACE_HXX_
+#define _CALCIUM_INTERFACE_HXX_
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include "Superv_Component_i.hxx"
+#include "DatastreamException.hxx"
+#include "CalciumTypes.hxx"
+#include "CalciumGenericUsesPort.hxx"
+#include "Copy2UserSpace.hxx"
+#include "Copy2CorbaSpace.hxx"
+#include "CalciumPortTraits.hxx"
+
+#include <stdio.h>
+
+
+// Déplacer cette information dans CorbaTypeManipulator
+// Gérer en même temps la recopie profonde.
+
+template <typename T1, typename T2>
+struct IsSameType {
+ static const bool value = false;
+};
+template <typename T1>
+struct IsSameType<T1,T1> {
+ static const bool value = true;
+};
+
+
+
+
+class CalciumInterface {
+public :
+
+
+ static void
+ ecp_fin (Superv_Component_i & component, bool provideLastGivenValue)
+ {
+ std::vector<std::string> usesPortNames;
+ std::vector<std::string>::const_iterator it;
+ component.get_uses_port_names(usesPortNames);
+
+ //récupérer le type de réel su port est un peu difficile
+ //car l'interface nous donne aucune indication
+ uses_port *myUsesPort;
+
+ for (it=usesPortNames.begin(); it != usesPortNames.end(); ++it) {
+ try {
+ component.Superv_Component_i::get_port(myUsesPort,(*it).c_str());
+ calcium_uses_port* myCalciumUsesPort=
+ dynamic_cast<calcium_uses_port*>(myUsesPort);
+ std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|"<< *it <<"|----"<<
+ typeid(myUsesPort).name() <<"-------------" <<
+ typeid(myCalciumUsesPort).name() <<"-------------" << std::endl;
+ if ( !myCalciumUsesPort )
+ throw Superv_Component_i::BadCast(LOC(OSS()<<"Impossible de convertir le port "
+ << *it << " en port de type calcium_uses_port." ));
+ myCalciumUsesPort->disconnect(provideLastGivenValue);
+ } catch ( const Superv_Component_i::PortNotDefined & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPNMVR,ex));
+ } catch ( const Superv_Component_i::PortNotConnected & ex) {
+ std::cerr << ex.what() << std::endl;;
+ throw (DatastreamException(CalciumTypes::CPLIEN,ex));
+ } catch ( const Superv_Component_i::BadCast & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPTPVR,ex));
+ } // Laisse passer les autres exceptions.
+ }
+ }
+
+
+ // Uniquement appelé par l'utilisateur s'il a passé un pointeur de données NULL
+ // à l'appel de ecp_lecture (demande de 0 copie)
+ template <typename T1 > static void
+ ecp_free ( T1 * dataPtr )
+ {
+ ecp_free<T1,T1> ( dataPtr );
+ }
+
+ template <typename T1,typename T2 > static void
+ ecp_free ( T1 * dataPtr )
+ {
+
+ typedef typename ProvidesPortTraits<T2>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::Type DataType; // Attention != T
+ typedef typename DataManipulator::InnerType InnerType;
+
+ DeleteTraits<IsSameType<T1,InnerType>::value >::apply(dataPtr);
+
+ }
+
+ template <typename T1 > static void
+ ecp_lecture ( Superv_Component_i & component,
+ CalciumTypes::DependencyType dependencyType,
+ double & ti,
+ double const & tf,
+ long & i,
+ const string & nomVar,
+ size_t bufferLength,
+ size_t & nRead,
+ T1 * &data )
+ {
+ ecp_lecture<T1,T1> (component,dependencyType,ti,tf,
+ i,nomVar,bufferLength,nRead,data);
+
+ }
+
+ template <typename T1, typename T2 > static void
+ ecp_lecture ( Superv_Component_i & component,
+ CalciumTypes::DependencyType dependencyType,
+ double & ti,
+ double const & tf,
+ long & i,
+ const string & nomVar,
+ size_t bufferLength,
+ size_t & nRead,
+ T1 * &data )
+ {
+
+ assert(&component);
+
+ typedef typename ProvidesPortTraits<T2>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::Type CorbaDataType; // Attention != T
+ typedef typename DataManipulator::InnerType InnerType;
+
+ CorbaDataType corbaData;
+ long ilong;
+
+ std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl;
+
+ if (nomVar.empty())
+ throw DatastreamException(CalciumTypes::CPNMVR,
+ LOC("Le nom de la variable est <nul>"));
+ PortType * port;
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 2 ------------------" << std::endl;
+
+ try {
+ port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 3 ------------------" << std::endl;
+ } catch ( const Superv_Component_i::PortNotDefined & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPNMVR,ex));
+ } catch ( const Superv_Component_i::PortNotConnected & ex) {
+ std::cerr << ex.what() << std::endl;;
+ throw (DatastreamException(CalciumTypes::CPLIEN,ex));
+ // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
+ } catch ( const Superv_Component_i::BadCast & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPTPVR,ex));
+ }
+
+ // mode == mode du port
+ CalciumTypes::DependencyType portDependencyType;
+ try {
+ portDependencyType = port->getDependencyType();
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 4 ------------------" << std::endl;
+ } catch ( const DSC_Exception & ex ) {
+ std::cerr << ex.what() << std::endl;;
+ throw (DatastreamException(CalciumTypes::CPIT,ex));
+ }
+
+ if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
+ throw DatastreamException(CalciumTypes::CPIT,
+ LOC(OSS()<<"Le mode de dépendance de la variable "
+ << nomVar << " est indéfini."));
+
+ if ( ( portDependencyType != dependencyType ) &&
+ ( dependencyType != CalciumTypes::SEQUENCE_DEPENDENCY ) )
+ throw DatastreamException(CalciumTypes::CPITVR,
+ LOC(OSS()<<"Le mode de dépendance de la variable "
+ << nomVar << " ne correspond pas au mode demandé."));
+
+
+ if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
+ corbaData = port->get(ti,tf, 0);
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
+ }
+ else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
+ corbaData = port->get(0, i);
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
+ } else {
+ // Lecture en séquence
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
+ corbaData = port->next(ti,i);
+ }
+
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl;
+ size_t corbaDataSize = DataManipulator::size(corbaData);
+ std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl;
+
+ // Vérifie si l'utilisateur demande du 0 copie
+ if ( data == NULL ) {
+ if ( bufferLength != 0 ) {
+ MESSAGE("bufferLength devrait valoir 0 pour l'utilisation du mode sans copie (data==NULL)");
+ }
+ nRead = corbaDataSize;
+ // Si les types T et InnerType sont différents, il faudra effectuer tout de même une recopie
+ if (!IsSameType<T1,InnerType>::value) data = new T1[nRead];
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl;
+ // On essaye de faire du 0 copy si les types T et InnerType sont les mêmes
+ Copy2UserSpace< IsSameType<T1,InnerType>::value >::apply(data,corbaData,nRead);
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl;
+ // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
+ // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
+ // old : Dans les deux cas la structure CORBA n'est plus utile
+ // old : Si !IsSameType<T1,InnerType>::value l'objet CORBA est détruit avec son contenu
+ // old : Dans l'autre cas seul la coquille CORBA est détruite
+ // tjrs correct : Dans les deux cas l'utilisateur devra appeler ecp_free (version modifiée)
+ // DataManipulator::delete_data(corbaData);
+ } else {
+ nRead = std::min < size_t > (corbaDataSize,bufferLength);
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl;
+ Copy2UserSpace<false>::apply(data,corbaData,nRead);
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl;
+ // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
+ // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
+ // DataManipulator::delete_data(corbaData);
+ }
+ std::cout << "-------- CalciumInterface(ecp_lecture), Valeur de data : " << std::endl;
+ std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
+ std::cout << "Ptr :" << data << std::endl;
+
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl;
+
+
+ return;
+ }
+
+
+ template <typename T1> static void
+ ecp_ecriture ( Superv_Component_i & component,
+ CalciumTypes::DependencyType dependencyType,
+ double const & t,
+ long const & i,
+ const string & nomVar,
+ size_t bufferLength,
+ T1 & data ) {
+ ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data);
+ }
+
+ template <typename T1, typename T2> static void
+ ecp_ecriture ( Superv_Component_i & component,
+ CalciumTypes::DependencyType dependencyType,
+ double const & t,
+ long const & i,
+ const string & nomVar,
+ size_t bufferLength,
+ T1 & data )
+ {
+
+ assert(&component);
+
+ //typedef typename StarTrait<TT>::NonStarType T;
+ typedef typename UsesPortTraits<T2>::PortType PortType;
+ typedef typename ProvidesPortTraits<T2>::PortType ProvidesPortType;
+ typedef typename ProvidesPortType::DataManipulator DataManipulator;
+ // Verifier que l'on peut définir UsesPortType::DataManipulator
+ // typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::Type CorbaDataType; // Attention != T1
+ typedef typename DataManipulator::InnerType InnerType;
+
+ std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
+ if ( nomVar.empty() ) throw DatastreamException(CalciumTypes::CPNMVR,
+ LOC("Le nom de la variable est <nul>"));
+ PortType * port;
+ std::cout << "-------- CalciumInterface(ecriture) MARK 2 ------------------" << std::endl;
+
+ try {
+ port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
+ std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl;
+ } catch ( const Superv_Component_i::PortNotDefined & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPNMVR,ex));
+ } catch ( const Superv_Component_i::PortNotConnected & ex) {
+ std::cerr << ex.what() << std::endl;;
+ throw (DatastreamException(CalciumTypes::CPLIEN,ex));
+ // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
+ } catch ( const Superv_Component_i::BadCast & ex) {
+ std::cerr << ex.what() << std::endl;
+ throw (DatastreamException(CalciumTypes::CPTPVR,ex));
+ }
+
+ // mode == mode du port
+ // On pourrait créer la méthode CORBA dans le mode de Couplage CALCIUM.
+ // et donc ajouter cette cette méthode uniquement dans l'IDL calcium !
+
+// CalciumTypes::DependencyType portDependencyType;
+// try {
+// portDependencyType = port->getDependencyType();
+// std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
+// } catch ( const DSC_Exception & ex ) {
+// std::cerr << ex.what() << std::endl;;
+// throw (DatastreamException(CalciumTypes::CPIT,ex));
+// }
+
+ if ( dependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
+ throw DatastreamException(CalciumTypes::CPIT,
+ LOC(OSS()<<"Le mode de dépendance demandé pour la variable "
+ << nomVar << " est indéfini."));
+
+ if ( dependencyType == CalciumTypes::SEQUENCE_DEPENDENCY )
+ throw DatastreamException(CalciumTypes::CPIT,
+ LOC(OSS()<<"Le mode de dépendance SEQUENCE_DEPENDENCY pour la variable "
+ << nomVar << " est impossible en écriture."));
+
+ // Il faudrait que le port provides génère une exception si le mode donnée n'est pas
+ // le bon. La seule façon de le faire est d'envoyer -1 en temps si on n'est en itération
+ // et vice-versa pour informer les provides port du mode dans lequel on est. Sinon il faut
+ // modifier l'interface IDL pour y ajouter un mode de dépendance !
+ // ---->
+// if ( portDependencyType != dependencyType )
+// throw DatastreamException(CalciumTypes::CPITVR,
+// LOC(OSS()<<"Le mode de dépendance de la variable "
+// << nomVar << " ne correspond pas au mode demandé."));
+
+
+ if ( bufferLength < 1 )
+ throw DatastreamException(CalciumTypes::CPNTNULL,
+ LOC(OSS()<<"Le buffer a envoyer est de taille nulle "));
+
+
+ std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
+ CorbaDataType corbaData;
+
+
+ // Si les types Utilisateurs et CORBA sont différents
+ // il faut effectuer une recopie sinon on utilise directement le
+ // buffer data pour constituer la séquence
+ // TODO :
+ // - Attention en mode asynchrone il faudra eventuellement
+ // faire une copie des données même si elles sont de même type.
+ // - En cas de collocalisation (du port provide et du port uses)
+ // il est necessaire d'effectuer une recopie du buffer car la
+ // séquence est envoyée au port provide par une référence sur
+ // la séquence locale. Or la méthode put récupère le buffer directement
+ // qui est alors le buffer utilisateur. Il pourrait alors arrivé que :
+ // * Le recepteur efface le buffer emetteur
+ // * Le port lui-même efface le buffer de l'ulisateur !
+ // Cette copie est effectuée dans GenericPortUses::put
+ // en fonction de la collocalisation ou non.
+ // - En cas de connection multiples d'un port uses distant vers plusieurs port provides
+ // collocalisés les ports provides partagent la même copie de la donnée !
+ // Il faut effectuer une copie dans le port provides.
+ // Cette copie est effectuée dans GenericPortUses::put
+ // en fonction de la collocalisation ou non.
+ Copy2CorbaSpace<IsSameType<T1,InnerType>::value >::apply(corbaData,data,bufferLength);
+
+ //TODO : GERER LES EXCEPTIONS ICI : ex le port n'est pas connecté
+ if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
+ port->put(*corbaData,t, -1);
+ //Le -1 peut être traité par le cst DataIdContainer et transformé en 0
+ //Etre obligé de mettre une étoile ds (*corbadata) va poser des pb pour les types <> seq
+ std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
+ }
+ else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
+ port->put(*corbaData,-1, i);
+ std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl;
+ }
+
+
+ std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl;
+ for (int i = 0; i < corbaData->length(); ++i)
+ cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << endl;
+
+ // if ( !IsSameType<T1,InnerType>::value ) delete corbaData;
+ // Supprime l'objet CORBA avec eventuellement les données qu'il contient (case de la recopie)
+ delete corbaData;
+
+ std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
+
+ return;
+ }
+
+};
+
+// Interface C/C++
+
+// En CALCIUM l'utilisation de données de type double
+// implique des dates de type double, pour les autres
+// types de données les dates sont de type float
+template <class T> struct CalTimeType {
+ typedef float TimeType;
+};
+
+template <> struct CalTimeType<double> {
+ typedef double TimeType;
+};
+
+extern "C" CalciumTypes::InfoType
+ecp_fin_ (void * component, int code) {
+
+ Superv_Component_i * _component = static_cast<Superv_Component_i *>(component);
+
+ bool provideLastGivenValue = false;
+ if (code == CalciumTypes::CP_CONT ) provideLastGivenValue = true;
+
+ try {
+ CalciumInterface::ecp_fin( *_component,
+ provideLastGivenValue);
+ } catch ( const DatastreamException & ex) { //tester l'arrêt par exception
+ std::cerr << ex.what() << std::endl;
+ return ex.getInfo();
+ }
+ return CalciumTypes::CPOK;
+};
+
+
+#define CALCIUM_C2CPP_INTERFACE_(_name,_type,_qual) \
+ extern "C" CalciumTypes::InfoType ecp_lecture_##_name (void * component, int dependencyType, \
+ CalTimeType< _type _qual >::TimeType * ti, \
+ CalTimeType< _type _qual >::TimeType * tf, long * i, \
+ const char * const nomvar, size_t bufferLength, \
+ size_t * nRead, _type _qual ** data ) { \
+ Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); \
+ double _ti=*ti; \
+ double _tf=*tf; \
+ size_t _nRead=0; \
+ size_t _bufferLength=bufferLength; \
+ \
+ if ( IsSameType< _name , cplx >::value ) _bufferLength*=2; \
+ std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" << std::endl; \
+ try { \
+ CalciumInterface::ecp_lecture< _type, _name >( *_component, \
+ static_cast<CalciumTypes::DependencyType>(dependencyType), \
+ _ti, _tf, *i, \
+ nomvar, \
+ _bufferLength, _nRead, *data); \
+ } catch ( const DatastreamException & ex) { \
+ std::cerr << ex.what() << std::endl; \
+ return ex.getInfo(); \
+ } \
+ if ( IsSameType< _name , cplx >::value ) { *nRead=_nRead/2; \
+ std::cout << "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" << std::endl; \
+ std::cout << "-------- CalciumInterface(lecture Inter Part) _nRead : " << _nRead << std::endl; \
+ std::cout << "-------- CalciumInterface(lecture Inter Part) *nRead : " << *nRead << std::endl; \
+ } else *nRead = _nRead; \
+ *ti=(CalTimeType< _type _qual >::TimeType)(_ti); \
+ std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \
+ for (int i=0; i<_nRead;++i) \
+ printf("-------- CalciumInterface(lecture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,(*data)[i]); \
+ std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \
+ return CalciumTypes::CPOK; \
+ }; \
+ extern "C" void ecp_lecture_##_name##_free ( _type _qual * data) { \
+ CalciumInterface::ecp_free< _type, _name >(data); \
+ }; \
+ extern "C" CalciumTypes::InfoType ecp_ecriture_##_name (void * component, int dependencyType, \
+ CalTimeType< _type _qual >::TimeType *t, \
+ long i, \
+ const char * const nomvar, size_t bufferLength, \
+ _type _qual * data ) { \
+ Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); \
+ /* Je ne sais pas pourquoi, je n'arrive pas à passer t par valeur : corruption de la pile*/ \
+ double _t=*t; \
+ size_t _bufferLength=bufferLength; \
+ if ( IsSameType< _name , cplx >::value ) _bufferLength=_bufferLength*2; \
+ std::cout << "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" << std::endl; \
+ try { \
+ printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar); \
+ std::string essai(nomvar); \
+ std::cout << "----------->-" << nomvar << std::endl; \
+ CalciumInterface::ecp_ecriture< _type, _name >( *_component, \
+ static_cast<CalciumTypes::DependencyType>(dependencyType), \
+ _t,i,nomvar,_bufferLength,*data); \
+ } catch ( const DatastreamException & ex) { \
+ std::cerr << ex.what() << std::endl; \
+ return ex.getInfo(); \
+ } \
+ std::cout << "-------- CalciumInterface(ecriture Inter Part), Valeur de data : " << std::endl; \
+ std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(1) :" << data << std::endl; \
+ for (int i=0; i<_bufferLength;++i) \
+ printf("-------- CalciumInterface(ecriture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,data[i]); \
+ std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(2) :" << data << std::endl; \
+ return CalciumTypes::CPOK; \
+ }; \
+
+
+
+#define STAR *
+CALCIUM_C2CPP_INTERFACE_(int,int,);
+CALCIUM_C2CPP_INTERFACE_(float,float, );
+CALCIUM_C2CPP_INTERFACE_(double,double,);
+CALCIUM_C2CPP_INTERFACE_(bool,bool,);
+CALCIUM_C2CPP_INTERFACE_(cplx,float,);
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _PORT_TRAITS_HXX_
+#define _PORT_TRAITS_HXX_
+
+#include "Superv_Component_i.hxx"
+
+
+struct UnknownPortType {};
+template <class T> struct ProvidesPortTraits {
+ typedef UnknownPortType PortType;
+};
+template <> struct ProvidesPortTraits<int> {
+ typedef calcium_integer_port_provides PortType;
+};
+template <> struct ProvidesPortTraits<long> {
+ typedef calcium_integer_port_provides PortType;
+};
+template <> struct ProvidesPortTraits<float> {
+ typedef calcium_real_port_provides PortType;
+};
+template <> struct ProvidesPortTraits<double> {
+ typedef calcium_double_port_provides PortType;
+};
+template <> struct ProvidesPortTraits<char *> {
+ typedef calcium_string_port_provides PortType;
+};
+template <> struct ProvidesPortTraits<bool> {
+ typedef calcium_logical_port_provides PortType;
+};
+
+// Définition du type cplx pour disciminer ce type de port
+// de celui du float
+struct cplx {};
+template <> struct ProvidesPortTraits<cplx> {
+ typedef calcium_complex_port_provides PortType;
+};
+
+template < typename T > struct StarTrait { typedef T NonStarType; };
+template < typename T > struct StarTrait< T * > { typedef T NonStarType; };
+
+template <class T> struct UsesPortTraits {
+ typedef UnknownPortType PortType;
+};
+template <> struct UsesPortTraits<int> {
+ typedef calcium_integer_port_uses PortType;
+};
+template <> struct UsesPortTraits<long> {
+ typedef calcium_integer_port_uses PortType;
+};
+template <> struct UsesPortTraits<float> {
+ typedef calcium_real_port_uses PortType;
+};
+template <> struct UsesPortTraits<double> {
+ typedef calcium_double_port_uses PortType;
+};
+template <> struct UsesPortTraits<char *> {
+ typedef calcium_string_port_uses PortType;
+};
+template <> struct UsesPortTraits<bool> {
+ typedef calcium_logical_port_uses PortType;
+};
+template <> struct UsesPortTraits<cplx> {
+ typedef calcium_complex_port_uses PortType;
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef __CALCIUM_TYPES__
+#define __CALCIUM_TYPES__
+
+namespace CalciumTypes {
+
+
+ const float EPSILON = 1.e-6;
+
+
+ /* Type de dependance des variables */
+ const int CP_TEMPS = 40;
+ const int CP_ITERATION = 41;
+ const int CP_SEQUENTIEL = 42;
+ /* Mode de dependance inconnu */
+ const int CPIT = 6;
+
+ /* Directive de continuation d'une instance */
+ const int CP_CONT = 20;
+ const int CP_ARRET = 21;
+
+ /* Type d'interpolation */
+ const int CP_LINEAIRE = 100;
+ const int CP_ESCALIER = 101;
+
+
+ /* Repere dans cycle de temps */
+ const int TI = 110;
+ const int TF = 111;
+
+
+ /* Niveaux */
+ const int CP_ILLIMITE = -70;
+ const int CP_AUTESP = -71;
+
+
+
+ typedef int InfoType ;
+ const int UNLIMITED_STORAGE_LEVEL = CP_ILLIMITE;
+ typedef enum {UNDEFINED_DEPENDENCY=CPIT,TIME_DEPENDENCY=CP_TEMPS,
+ ITERATION_DEPENDENCY=CP_ITERATION,
+ SEQUENCE_DEPENDENCY =CP_SEQUENTIEL } DependencyType;
+ typedef enum {TI_SCHEM=TI,TF_SCHEM=TF,ALPHA_SCHEM} DateCalSchem;
+ typedef enum {L0_SCHEM=CP_ESCALIER,L1_SCHEM=CP_LINEAIRE} InterpolationSchem;
+ typedef enum {UNDEFINED_EXTRA_SCHEM,E0_SCHEM,E1_SCHEM} ExtrapolationSchem;
+ typedef enum {UNDEFINED_DIRECTIVE,CONTINUE=CP_CONT,STOP=CP_ARRET} DisconnectDirective;
+
+ /* Codes d'erreur */
+
+ /* Pas d'erreur */
+ const int CPOK = 0;
+
+ /* Emetteur inconnu */
+ const int CPERIU = 1;
+
+ /* Nom de variable inconnu */
+ const int CPNMVR = 2;
+
+ /* Type entree/sortie incompatible */
+ const int CPIOVR = 3;
+
+ /* Type inconnu */
+ const int CPTP = 4;
+
+ /* Type de variable incompatible */
+ const int CPTPVR = 5;
+
+ /* Mode de dependance inconnu */
+ // Déclaré au dessus
+ // const int CPIT = 6;
+
+ /* Mode dependance incompatible */
+ const int CPITVR = 7;
+
+ /* Requete non autorisee */
+ const int CPRENA = 8;
+
+ /* Type de deconnexion incorrect */
+ const int CPDNTP = 9;
+
+ /* Directive de deconnexion incorrecte */
+ const int CPDNDI = 10;
+
+ /* Nom de code inconnu */
+ const int CPNMCD = 11;
+
+ /* Nom d'instance inconnu */
+ const int CPNMIN = 12;
+
+ /* Attente */
+ const int CPATTENTE = 13;
+
+ /* Blocage */
+ const int CPBLOC = 14;
+
+ /* Nombre de valeurs transmises egal a zero */
+ const int CPNTNULL = 15;
+
+ /* Longueur de variable insuffisante */
+ const int CPLGVR = 16;
+
+ /* L'instance doit s'arreter */
+ const int CPSTOP = 17;
+
+ /* Arret anormal */
+ const int CPATAL = 18;
+
+ /* Coupleur absent */
+ const int CPNOCP = 19;
+
+ /* Variable sortante non connectee */
+ const int CPCTVR = 20;
+
+ /* Nombre de pas a executer egal a zero */
+ const int CPPASNULL = 21;
+
+ /* Machine inconnue */
+ const int CPMACHINE = 22;
+
+ /* COUPLAGE_GROUPE non positionnee */
+ const int CPGRNU = 23;
+
+ /* Groupe d'instances incorrect */
+ const int CPGRIN = 24;
+
+ /* Fin du fichier d'entree */
+ const int CPFINFICH = 25;
+
+ /* Erreur de format dans un fichier */
+ const int CPERRFICH = 26;
+
+ /* Requete d'avance de n pas annulee */
+ /* par passage en mode NORMAL */
+ const int CPNORERR = 27;
+
+ /* Coupleur en mode NORMAL pour une */
+ /* requete RUN_N_PAS ou DEF_* */
+ const int CPRUNERR = 28;
+
+ /* Option inconnue */
+ const int CPOPT = 29;
+
+ /* Valeur d'option inconnue */
+ const int CPVALOPT = 30;
+
+ /* Ecriture impossible par effacement */
+ const int CPECREFF = 31;
+
+ /* Lecture d'une variable non connectee */
+ /* ou n'appartenant pas a un lien VAS */
+ /* ou VAV s'il s'agit d'une sortante */
+ const int CPLIEN = 32;
+
+ /* Lecture d'une variable d'une instance*/
+ /* deconnectee avec directive CP_ARRET */
+ const int CPINARRET = 33;
+
+ /* Les lectures sequentielles ne pourront plus */
+ /* etre satisfaites : instance productrice arretee */
+ const int CPSTOPSEQ = 34;
+
+ /* Erreur dans la chaine de declaration */
+ const int CPDECL = 35;
+
+ /* Erreur dans l'execution de l'instance ajoutee */
+ const int CPINEXEC = 36;
+
+ /* Erreur PVM */
+ // const int CPPVM = 37;
+ // const int CPCOM = 37;
+ /* Erreur detectee au niveau de l'int CPERRINST = 38;
+ /* Mode d'execution non defini */
+ const int CPMODE = 39;
+
+ /* Instance deconnectee */
+ const int CPINSTDEC = 40;
+
+}
+#endif
--- /dev/null
+#ifndef _CALCIUM_TYPES_MANIPULATOR_HXX_
+#define _CALCIUM_TYPES_MANIPULATOR_HXX_
+
+//Cette classe n'est pas necessaire pour l'instant.
+#include "Calcium_Ports.hh"
+
+template <typename PortType> struct CalciumTypesManipulator :
+ public seq_u_manipulation<Ports::Calcium_Ports::seq_complex,
+ Ports::Calcium_Ports::Complex> {
+ static bool needInterpolation=true;
+}
+
+template <POA_Ports::Calcium_Ports::Calcium_Complex_Port> struct CalciumTypesManipulator :
+ public seq_u_manipulation<Ports::Calcium_Ports::seq_complex,
+ Ports::Calcium_Ports::Complex> {
+ static bool needInterpolation=true;
+}
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-07 18:26:44 +0100 (mer, 07 fév 2007) $
+// Id : $Id$
+
+#ifndef _COPY_TO_CORBA_SPACE_HXX_
+#define _COPY_TO_CORBA_SPACE_HXX_
+
+#include <string>
+#include <iostream>
+#include "CalciumPortTraits.hxx"
+
+template <bool zerocopy>
+struct Copy2CorbaSpace {
+
+ template <class T1, class T2>
+ static void apply( T1 * & corbaData, T2 & data, size_t nRead){
+
+ typedef typename ProvidesPortTraits<T2>::PortType PortType;
+ //typedef typename UsesPortTraits<T2>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::InnerType InnerType;
+
+ std::cerr << "-------- Copy2CorbaSpace<true> MARK 1 ------------------" << std::endl;
+ // Crée le type corba à partir du data sans lui en donner la propriété
+ corbaData = DataManipulator::create(nRead,&data,false);
+ std::cerr << "-------- Copy2CorbaSpace<true> MARK 2 --(dataPtr : "
+ << DataManipulator::getPointer(corbaData,false)<<")----------------" << std::endl;
+
+ }
+};
+
+// Cas ou il faut effectuer une recopie
+template <> struct
+Copy2CorbaSpace<false> {
+
+ template <class T1, class T2>
+ static void apply( T1 * & corbaData, T2 & data, size_t nRead){
+
+ typedef typename ProvidesPortTraits<T2>::PortType PortType;
+ // typedef typename UsesPortTraits<T2>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::InnerType InnerType;
+
+ corbaData = DataManipulator::create(nRead);
+ InnerType * dataPtr = DataManipulator::getPointer(corbaData,false);
+
+ std::cerr << "-------- Copy2CorbaSpace<false> MARK 1 --(dataPtr : " <<
+ dataPtr<<")----------------" << std::endl;
+
+ std::copy(&data,&data+nRead,dataPtr);
+
+ std::cerr << "-------- Copy2CorbaSpace<false> MARK 2 --(nRead: "<<nRead<<")-------------" << std::endl;
+
+ std::cerr << "-------- Copy2CorbaSpace<false> MARK 3 : " ;
+ std::copy(dataPtr,dataPtr+nRead,std::ostream_iterator<InnerType>(std::cout," "));
+ std::cout << std::endl;
+ std::cerr << "-------- Copy2CorbaSpace<false> MARK 4 --(data : " <<data<<") :" ;
+ for (int i=0; i<nRead; ++i)
+ std::cerr << (*corbaData)[i] << " ";
+ std::cout << std::endl;
+
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-13 11:09:09 +0100 (mar, 13 fév 2007) $
+// Id : $Id$
+
+#ifndef _COPY_TO_USER_SPACE_HXX_
+#define _COPY_TO_USER_SPACE_HXX_
+
+#include <string>
+#include <iostream>
+#include "CalciumPortTraits.hxx"
+
+//Cas du zero copie
+template <bool zerocopy >
+struct Copy2UserSpace{
+
+ template <class T1, class T2>
+ static void apply( T1 * & data, T2 & corbaData, size_t nRead ){
+
+ typedef typename ProvidesPortTraits<T1>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::InnerType InnerType;
+
+ // Devient propriétaire des données contenues dans la structure CORBA
+ // (allouées par allocbuff() pour une séquence)
+ InnerType * dataPtr = DataManipulator::getPointer(corbaData,true);
+
+ // Cette ligne poserait uun problème dans la méthode appelante, si elle
+ // ne testait pas que les types utilisateurs et CORBA sont identiques :
+ // ex : InnerType == Corba::Long et d'un T == int
+ data = dataPtr;
+
+ // L'utilisateur a la charge de la desallocation
+ // il devra appeler la méthode ecp_free pour désallouer le contenu de la séquence CORBA
+ // La structure CORBA sera désallouer le cas échéant dans la méthode appelante
+ }
+};
+
+// Cas où il faut effectuer une recopie
+template <>
+struct Copy2UserSpace<false>{
+
+ //Recopie le contenu de la donnée CORBA dans le buffer utilisateur de longueur
+ //nRead
+ template <class T1, class T2>
+ static void apply( T1 * &data, T2 & corbaData, size_t nRead){
+
+ typedef typename ProvidesPortTraits<T1>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ typedef typename DataManipulator::InnerType InnerType;
+
+ size_t corbaDataSize = DataManipulator::size (corbaData);
+ // Récupère un pointeur sur les données contenues dans la structure CORBA sans en devenir propriétaire
+ InnerType * dataPtr = DataManipulator::getPointer(corbaData,false);
+
+ // Attention : Pour les chaines ou tout autre object complexe il faut utiliser une recopie profonde !
+ // Recopie des données dans le buffer allouée par l'utilisateur
+ // OU
+ // Recopie des données dans le buffer allouée la méthode appelante
+ // dans le cas d'une demande utilisateur 0 copie mais sur
+ // des types utilisateurs et CORBA incompatibles.
+ std::cerr << "-------- Copy2UserSpace<false> MARK 1 --(dataPtr : " <<dataPtr<<")----------------" << std::endl;
+
+ std::copy(dataPtr,dataPtr+nRead,data);
+
+ std::cerr << "-------- Copy2UserSpace<false> MARK 2 --(nRead: "<<nRead<<")-------------" << std::endl;
+
+ std::cerr << "-------- Copy2UserSpace<false> MARK 3 --(data : " <<data<<") :";
+ std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
+ std::cout << std::endl;
+
+ }
+};
+
+
+template <bool rel>
+struct DeleteTraits {
+ template <typename T>
+ static void apply(T * dataPtr) {
+
+ typedef typename ProvidesPortTraits<T>::PortType PortType;
+ typedef typename PortType::DataManipulator DataManipulator;
+ //typedef typename DataManipulator::Type DataType; // Attention != T
+
+ // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
+ // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
+ // DataManipulator::relPointer(dataPtr);
+ }
+};
+
+// Cas où une recopie avait été effectuée
+template <>
+struct DeleteTraits<false>{
+ template <typename T>
+ static void apply(T * dataPtr) {
+ delete[] dataPtr;
+ }
+};
+
+#endif
--- /dev/null
+BUILT_SOURCES = SALOME_Component.hh SALOME_Exception.hh
+
+%.hh : @KERNEL_ROOT_DIR@/idl/salome/%.idl
+ @IDL@ @IDLGENFLAGS@ -I@KERNEL_ROOT_DIR@/idl/salome $<
+
+AM_CXXFLAGS = -I$(top_srcdir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_User/Datastream \
+ -I$(top_srcdir)/src/DSC_Basic \
+ -I@KERNEL_ROOT_DIR@/include/salome \
+ -I$(top_builddir)/idl \
+ @OMNIORB_INCLUDES@
+
+noinst_LTLIBRARIES = libSalomeCalcium.la
+nodist_libSalomeCalcium_la_SOURCES = $(top_builddir)/idl/Calcium_PortsSK.cc
+libSalomeCalcium_la_SOURCES = calcium_port_factory.cxx \
+ calcium_uses_port.cxx \
+ calcium_repository_types.cxx \
+ CalciumCouplingPolicy.cxx \
+ calcium_destructors_port_provides.cxx \
+ calcium_destructors_port_uses.cxx
+libSalomeCalcium_la_LDFLAGS = -L@KERNEL_ROOT_DIR@/lib/salome/ -lOpUtil
+
+lib_LTLIBRARIES = libCalciumC.la
+libCalciumC_la_SOURCES = Calcium.c
+
+## TESTS ##
+
+noinst_PROGRAMS = test_DataIdContainer
+test_DataIdContainer_SOURCES = test_DataIdContainer.cxx
+test_DataIdContainer_LDADD = libSalomeCalcium.la
+
+## pas normal d'être obligé de linké à caus de __init___...thread
+test_DataIdContainer_LDFLAGS = -L@KERNEL_ROOT_DIR@/lib/salome
+test_DataIdContainer_LDFLAGS += @OMNIORB_LIBS@ -lomniORB4 -lomniDynamic4 -lCOS4 -lCOSDynamic4 -lomnithread
+
+#noinst_PROGRAMS += test_CalciumInterface
+#test_CalciumInterface_SOURCES = test_CalciumInterface.cxx
+#DSC_User = $(top_srcdir)/src/DSC_User
+#test_CalciumInterface_CXXFLAGS = -I$(DSC_User)/Basic \
+# -I$(DSC_User) \
+# -I$(top_srcdir)/src/DSC_Basic \
+# -I$(DSC_User)/Datastream \
+# -I$(DSC_User)/Datastream/Palm \
+# -I$(DSC_User)/Datastream/Calcium \
+# -I@KERNEL_ROOT_DIR@/include/salome \
+# -I$(top_builddir)/idl \
+# @OMNIORB_INCLUDES@
+
+## pas normal d'être obligé de linké à caus de __init___...thread
+#test_CalciumInterface_LDFLAGS = -L@KERNEL_ROOT_DIR@/lib/salome
+#test_CalciumInterface_LDFLAGS += -lomniORB4 -lomniDynamic4 -lCOS4 -lCOSDynamic4 -lomnithread
+#test_CalciumInterface_LDADD = -lOpUtil libSalomeCalcium.la $(DSC_User)/libSalomeDSCSuperv.la
+
+
+TESTS = test_DataIdContainer
+#test_CalciumInterface
+
+
+include_HEADERS = calcium_port_factory.hxx \
+ CalciumGenericProvidesPort.hxx \
+ calcium_uses_port.hxx CalciumGenericUsesPort.hxx \
+ calcium_port_provides.hxx \
+ calcium_integer_port_uses.hxx \
+ calcium_real_port_uses.hxx \
+ calcium_double_port_uses.hxx \
+ calcium_string_port_uses.hxx \
+ calcium_logical_port_uses.hxx \
+ calcium_complex_port_uses.hxx \
+ CalciumCouplingPolicy.hxx CalciumTypes.hxx CalciumInterface.hxx \
+ Copy2UserSpace.hxx Copy2CorbaSpace.hxx CalciumPortTraits.hxx
+include_HEADERS += calcium.h calciumP.h version.h calcium.hf
+CLEANFILES = *.hh *SK.cc
+
--- /dev/null
+/* Outils d'Aide au Couplage de Code de Calcul : $Id$ */
+
+#ifndef __CALCIUM_H
+#define __CALCIUM_H
+
+#include <version.h>
+#include <calciumP.h>
+
+#if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus)
+#define CPNeedPrototype 1
+#else
+#define CPNeedPrototype 0
+#endif
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/* */
+/* */
+/* Fonctions de connexion */
+/* */
+/* */
+extern int cp_cd(
+/* ----- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* S Nom de l instance appelante*/
+#endif
+);
+
+
+/* */
+/* */
+/* Fonction de deconnexion */
+/* */
+/* */
+extern int cp_fin(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Directive de continuation */
+ /* CP_CONT ou CP_ARRET */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions de lecture bloquante */
+/* */
+/* */
+extern int cp_len(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ int * /* S Tableau d'entiers pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_lre(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ float * /* S Tableau de flottants pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_ldb(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ double* /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ double* /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ double* /* S Tableau de doubles pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_lcp(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ float * /* S Tableau de flottants pour stocker les */
+ /* valeurs lues (dimension = 2 * le nombre */
+ /* de valeurs lues) */
+#endif
+);
+
+extern int cp_llo(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ int * /* S Tableau d 'entier pour stocker les */
+ /* valeurs lues (remplace le logiques) */
+#endif
+);
+
+extern int cp_lch(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ char *[]/* S Tableau de chaines pour stocker les */
+ /* valeurs lues (remplace le logiques) */,
+ int /* E Taille des chaines du tablaeu */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions de lecture non bloquantes */
+/* */
+/* */
+extern int cp_nlen(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ int * /* S Tableau d'entiers pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_nlre(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ float * /* S Tableau de flottants pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_nldb(
+/* ------- */
+
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ double */* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ double */* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ double* /* S Tableau de doubles pour stocker les */
+ /* valeurs lues */
+#endif
+);
+
+extern int cp_nlcp(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ float * /* S Tableau de flottants pour stocker les */
+ /* valeurs lues (dimension = 2 * le nombre */
+ /* de valeurs lues) */
+#endif
+);
+
+extern int cp_nllo(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ int * /* S Tableau d 'entier pour stocker les */
+ /* valeurs lues (remplace le logiques) */
+#endif
+);
+
+extern int cp_nlch(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance ou de lecture */
+ /* CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL */,
+ float * /* E/S Borne inf de l'intervalle de lecture */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ float * /* E Borne Sup de l'intervalle de lecture */,
+ int * /* E/S Pas d'iteration a lire */
+ /* Retourne le pas lu dans le cas de */
+ /* lecture sequentielle */,
+ char * /* E Nom de la variable a lire */,
+ int /* E Nombre max de valeurs a lire */,
+ int * /* S Nombre de valeurs rellement lues */,
+ char *[]/* S Tableau de chaines pour stocker les */
+ /* valeurs lues (remplace le logiques) */,
+ int /* E Taille des chaines du tablaeu */
+#endif
+);
+
+
+
+
+/* */
+/* */
+/* Fonctions d'ecriture */
+/* */
+/* */
+
+extern int cp_een(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ float /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ int * /* E Tableau d'entiers a ecrire */
+#endif
+);
+
+extern int cp_ere(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ float /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ float * /* E Tableau de flottants a ecrire */
+#endif
+);
+
+extern int cp_edb(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ double /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ double* /* E Tableau de doubles a ecrire */
+#endif
+);
+
+extern int cp_ecp(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ float /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ float * /* E Tableau de flottants a ecrire */
+ /* (dimension = 2 * le nombre de valeurs */
+ /* a ecrire */
+#endif
+);
+
+extern int cp_elo(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ float /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ int * /* E Tableau d'entiers a ecrire */
+#endif
+);
+
+extern int cp_ech(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Type de dependance */
+ /* CP_TEMPS, CP_ITERATION */,
+ float /* E Pas de temps a ecrire */,
+ int /* E Pas d'iteration a ecrire */,
+ char * /* E Nom de la variable a ecrire */,
+ int /* E Nombre de valeurs a ecrire */,
+ char *[]/* E Tableau de chaines a ecrire */,
+ int /* E Taille des chaines a ecrire */
+#endif
+);
+
+
+
+
+/* */
+/* */
+/* Fonctions de fin de pas */
+/* */
+/* */
+extern int cp_aufp(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */
+#endif
+);
+
+extern int cp_infp(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */
+#endif
+);
+
+extern int cp_fini(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Tous les pas <= a cette valeur */
+ /* seront oublies par le coupleur */
+#endif
+);
+
+extern int cp_fint(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ float /* E Tous les pas <= a cette valeur */
+ /* seront oublies par le coupleur */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions d'effacement */
+/* */
+/* */
+extern int cp_effi(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom de la variable a effacer */,
+ int /* E Tous les pas >= a cette valeurt */
+ /* seront effaces par le coupleur */
+#endif
+);
+
+
+extern int cp_efft(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom de la variable a effacer */,
+ float /* E Tous les pas >= a cette valeur */
+ /* seront effaces par le coupleur */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions de mode d'execution */
+/* */
+/* */
+extern int cp_pause(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */
+#endif
+);
+
+extern int cp_run(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */
+#endif
+);
+
+extern int cp_npas(
+/* ------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Nombre de pas a executer */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions de configuration dynamique */
+/* */
+/* */
+extern int cp_dfcode(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Declaration du code */
+#endif
+);
+
+extern int cp_dfinst(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Declaration de l'instance */
+#endif
+);
+
+extern int cp_dflien(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Declaration du lien */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions d'interrogation */
+/* */
+/* */
+extern int cp_ivers(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* S Repertoire ACCC */,
+ char * /* S Repertoire ACCC */
+#endif
+);
+
+
+extern int cp_icd(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Longueur du tableau passe en parametre */,
+ int * /* S Nombre de codes retournes */,
+ char *[]/* S Tableau contenant les noms des codes */
+#endif
+);
+
+extern int cp_iincd(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom du code dont on veut les instances */,
+ int /* E Longueur du tableau passe en parametre */,
+ int * /* S Nombre d'instances retournees */,
+ char *[]/* S Tableau contenant les noms des instances */
+#endif
+);
+
+extern int cp_ivr(
+/* ------ */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Longueur des tableaux passes en parametre */,
+ int * /* S Nombre de variables retournees */,
+ char *[]/* S Tableau contenant les noms des instances */,
+ char *[]/* S Tableau contenant les noms des variables */
+#endif
+);
+
+extern int cp_ivrcd(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom du code dont on veut les variables */,
+ int /* E Longueur des tableaux passes en parametre */,
+ int * /* S Nombre de variables retournees */,
+ char *[]/* S Tableau contenant les noms des variables */
+#endif
+);
+
+extern int cp_ivrin(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom de l'instance dont on veut la liste */
+ /* des variables */,
+ char * /* S Nom du code pere de l'instance */,
+ int /* E Longueur du tableau pour les variables */
+ /* entrantes */,
+ int /* E Longueur du tableau pour les variables */
+ /* sortantes */,
+ int * /* S Nombre de variables entrantes retournees */,
+ int * /* S Nombre de variables sortantes retournees */,
+ char *[]/* S Tableau contenant les noms des variables */
+ /* entrantes */,
+ char *[]/* S Tableau contenant les noms des variables */
+ /* sortantes */
+#endif
+);
+
+extern int cp_icavr(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom de l'instance contenant la variable */,
+ char * /* E Nom local de la variable */,
+ int * /* S Sens de la variable */,
+ int * /* S Dependance de la variable */,
+ int * /* S Type de la variable */,
+ int /* E Longueur des tableaux permettant de */
+ /* recueillir les pas de temps et d'iteration*/,
+ int * /* S Nombre de codes retournes */,
+ float * /* S Tableau contenant les pas de temps */,
+ int * /* S Tableau contenant les pas d'iterations */
+#endif
+);
+
+extern int cp_ilien(
+/* -------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ char * /* E Nom global de la variable */,
+ int /* E Longueur des tableaux pour les noms des */
+ /* instances et des variables */,
+ int * /* S Nombre de variables participant au lien */,
+ char *[]/* S Tableau contenant les noms des instances */,
+ char *[]/* S Tableau contenant les noms des variables */,
+ int * /* S Type du lien */,
+ int * /* S Niveau du lien */,
+ int * /* S Tableau des parametres d'interpolation */
+ /* des variables entrantes */,
+ float * /* S Tableau des valeurs de delta utilisees */
+ /* pour les variables entrantes */,
+ int * /* S Tableau des parametres d'extrapolation */
+ /* des variables entrantes */
+#endif
+);
+
+
+
+/* */
+/* */
+/* Fonctions de manipulation d'options */
+/* */
+/* */
+extern int cp_setopt(
+/* --------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Numero identifiant l'option a modifier */,
+ int /* E Valeur a donner a l'option */
+#endif
+);
+
+extern int cp_getopt(
+/* --------- */
+#if CPNeedPrototype
+ void * component /* Pointeur de type Superv_Component_i* sur le */
+ /* composant SALOME Supervisable */,
+ int /* E Numero identifiant l'option a consulter */,
+ int * /* S Valeur recupereee de l'option */
+#endif
+);
+
+
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+
+#endif
--- /dev/null
+COutils d'Aide au Couplage de Code de Calcul : $Id$
+
+ INTEGER CP_ENTIER, CP_REEL, CP_DREEL, CP_COMPLEXE,
+ . CP_LOGIQUE, CP_CHAINE,
+ . ENTIER,REEL,DREEL,COMPLEXE,LOGIQUE,CHAINE,
+ . CP_NORMALE, CP_ANORMALE,
+ . CP_CONT, CP_ARRET,
+ . CP_TEMPS, CP_ITERATION, CP_SEQUENTIEL,
+ . CP_IN, CP_OUT,
+ . IN, OUT,
+ . CP_ILLIMITE, CP_AUTESP,
+ . CP_LINEAIRE, CP_ESCALIER, CP_AUCUNE,
+ . CP_ROUTE, CP_ERREURS,
+ . CP_ROUTE_NORMAL, CP_ROUTE_DIRECT,
+ . CP_AUTO, CP_BLOCAGE, CP_MANUEL,
+ . CP_ATTENTE, CP_IMMEDIATE
+ INTEGER CPLVAV, CPLVAF, CPLVAS, CPLCAV, CPLFAV,
+ . VARIABLE_LEN, CODE_LEN, INSTANCE_LEN,
+ . CPOK, CPEIU, CPNMVR, CPIOVR, CPTP, CPTPVR,
+ . CPIT, CPITVR, CPRENA, CPDNTP, CPDNDI,
+ . CPNMCD, CPNMIN, CPATTENTE, CPBLOC, CPNTNULL,
+ . CPLGVR, CPSTOP, CPATAL, CPNOCP, CPCTVR,
+ . CPPASNULL, CPMACHINE, CPGRNU, CPGRIN,
+ . CPFINFICH, CPERRFICH, CPNORERR, CPRUNERR,
+ . CPOPT, CPVALOPT, CPECREFF, CPLIEN, CPINARRET,
+ . CPSTOPSEQ, CPDECL, CPINEXEC, CPPVM, CPERRINST
+
+ PARAMETER (VARIABLE_LEN = 144 ,
+ . CODE_LEN = 72 ,
+ . INSTANCE_LEN = 72)
+
+ PARAMETER (CP_NORMALE = 10, CP_ANORMALE = 11)
+
+ PARAMETER (CP_CONT = 20, CP_ARRET = 21)
+
+ PARAMETER (CP_ENTIER = 30, CP_REEL = 31,
+ . CP_DREEL = 32, CP_COMPLEXE = 33,
+ . CP_LOGIQUE = 34, CP_CHAINE = 35)
+
+ PARAMETER (ENTIER = 30, REEL = 31,
+ . DREEL = 32, COMPLEXE = 33,
+ . LOGIQUE = 34, CHAINE = 35)
+
+ PARAMETER (CP_TEMPS= 40, CP_ITERATION = 41,
+ . CP_SEQUENTIEL = 42)
+
+ PARAMETER (CP_IN = 50, CP_OUT = 51)
+ PARAMETER (IN = 50, OUT = 51)
+
+ PARAMETER (CP_ILLIMITE = -70, CP_AUTESP = -71)
+
+ PARAMETER (CP_LINEAIRE = 100, CP_ESCALIER = 101, CP_AUCUNE = 121)
+
+ PARAMETER (CP_ROUTE = 131, CP_ERREURS = 132)
+
+ PARAMETER (CP_ROUTE_NORMAL = 133, CP_ROUTE_DIRECT = 134)
+
+ PARAMETER (CP_AUTO = 135, CP_BLOCAGE = 136, CP_MANUEL = 137)
+
+ PARAMETER (CP_ATTENTE = 24, CP_IMMEDIATE = 141)
+
+ PARAMETER (CPLVAV = 151, CPLVAF = 152, CPLVAS = 153,
+ . CPLCAV = 154, CPLFAV = 155)
+
+ PARAMETER (CPOK = 0 , CPEIU = 1 , CPNMVR = 2,
+ . CPIOVR = 3 , CPTP = 4 , CPTPVR = 5,
+ . CPIT = 6 , CPITVR = 7 , CPRENA = 8,
+ . CPDNTP = 9 , CPDNDI = 10, CPNMCD = 11,
+ . CPNMIN = 12, CPATTENTE = 13, CPBLOC = 14,
+ . CPNTNULL = 15, CPLGVR = 16, CPSTOP = 17,
+ . CPATAL = 18, CPNOCP = 19, CPCTVR = 20,
+ . CPPASNULL = 21, CPMACHINE = 22, CPGRNU = 23,
+ . CPGRIN = 24, CPFINFICH = 25, CPERRFICH = 26,
+ . CPNORERR = 27, CPRUNERR = 28, CPOPT = 29,
+ . CPVALOPT = 30, CPECREFF = 31, CPLIEN = 32,
+ . CPINARRET = 33, CPSTOPSEQ = 34, CPDECL = 35,
+ . CPINEXEC = 36, CPPVM = 37, CPERRINST = 38)
+
--- /dev/null
+/* Outils d'Aide au Couplage de Code de Calcul : $Id$ */
+#ifndef __CONST_H
+#define __CONST_H
+
+#ifndef TrueOrFalse
+#define TrueOrFalse int
+#define TRUE 1
+#define FALSE 0
+#endif
+
+/* Definition d'un type de donnes pour le stockage du */
+/* des pas de temps */
+#ifdef CRAY
+#define Temps float
+#define FORMAT_TEMPS "%lf"
+#else
+#define Temps double
+#define FORMAT_TEMPS "%lg"
+#endif
+
+/* Precision relative pour tests d'egalite sur les temps */
+#define EPSILON 1.e-6
+
+/* Tailles utilisees lors des transmissions des noms */
+#define VERSION_LEN 144
+#define CODE_LEN 72
+#define VARIABLE_LEN 144
+#define INSTANCE_LEN 72
+#define DRIVER_LEN 72
+
+
+/* Tailles maximums */
+#define ARCHI_LEN 64
+#define ENV_VAR_LEN 256
+#define ACCC_LEN 256
+#define PVM_LEN 256
+#define USER_LEN 256
+#define MACHINE_LEN 256
+#define COMMAND_LEN 256
+#define MAX_LEN 256
+#define FICHIER_LEN 256
+
+/* Nombre de lignes dans une page du fichier erreur *
+ * de trace */
+#define NB_LIGNE_ERREUR 45
+#define NB_LIGNE_TRACE 45
+
+
+
+/* Type d'arret d'une instance */
+#define CP_NORMALE 10
+#define CP_ANORMALE 11
+
+/* Directive de continuation d'une instance */
+#define CP_CONT 20
+#define CP_ARRET 21
+
+/* Etat d'une instance */
+#define CP_INITIAL 22
+#define CP_NON_CONNECTE 23
+#define CP_ATTENTE 24
+#define CP_EXECUTION 25
+#define CP_DECONNECTE 26
+#define CP_TERMINE 27
+
+/* Type de variables */
+#define CP_ENTIER 30
+#define CP_REEL 31
+#define CP_DREEL 32
+#define CP_COMPLEXE 33
+#define CP_LOGIQUE 34
+#define CP_CHAINE 35
+
+/* Type de dependance des variables */
+#define CP_TEMPS 40
+#define CP_ITERATION 41
+#define CP_SEQUENTIEL 42
+
+/* Send des variables */
+#define CP_IN 50
+#define CP_OUT 51
+
+/* Type des instances */
+#define CP_NORMAL 60
+#define CP_ESPION 62
+
+/* Niveaux */
+#define CP_ILLIMITE -70
+#define CP_AUTESP -71
+
+/* Mode de trace */
+#define CP_SANS 80
+#define CP_SUCCINCT 81
+#define CP_DETAILLE 82
+
+
+/* Mode d'execution */
+/* La valeur CP_NORMAL definie pour les types */
+/* est aussi utilisee */
+#define CP_PAUSE 91
+
+
+/* Type d'interpolation */
+#define CP_LINEAIRE 100
+#define CP_ESCALIER 101
+
+
+/* Repere dans cycle de temps */
+#define TI 110
+#define TF 111
+
+/* Mode de nettoyage des donnees d'un lien */
+#define CP_TOUTES 120
+#define CP_AUCUNE 121
+#define CP_PAS 122
+
+/* Options configurables */
+#define CP_ROUTE 131
+#define CP_ERREURS 132
+
+/* Valeurs pour l'option CP_ROUTE */
+#define CP_ROUTE_NORMAL 133
+#define CP_ROUTE_DIRECT 134
+
+/* Valeurs pour l'option Comportement en cas d'erreur */
+#define CP_AUTO 135
+#define CP_BLOCAGE 136
+#define CP_MANUEL 137
+
+/* Type de requete de lecture */
+/* La valeur CP_ATTENTE define pour l'etat d'une */
+/* instance est aussi utilisee */
+#define CP_IMMEDIATE 141
+
+/* Definition des types de lien */
+#define CPLVAV 151
+#define CPLVAF 152
+#define CPLVAS 153
+#define CPLCAV 154
+#define CPLFAV 155
+
+/* Codes des entetes des messages (Evenemet *) */
+#define ERREUR 1000
+#define CONNEXION 1001
+#define EMISSION 1002
+#define DECONNEXION 1003
+#define LECTURE_VARIABLE 1004
+#define ECRITURE_VARIABLE 1005
+#define FIN_DE_PAS 1006
+#define AUIN_FIN_DE_PAS 1007
+#define EFFACEMENT 1008
+#define MODE_EXEC 1009
+#define RUN_N_PAS 1010
+#define DEF_CODE 1011
+#define DEF_INSTANCE 1012
+#define DEF_LIEN 1013
+#define DEM_VERSION 1014
+#define SET_OPTION 1015
+#define DEM_OPTION 1016
+#define DEM_CODES 1017
+#define DEM_INSTS_DE_CODE 1018
+#define DEM_VARIABLES 1019
+#define DEM_VARS_DE_CODE 1020
+#define DEM_VARS_DE_INST 1021
+#define DEM_CARS_DE_VARIABLE 1022
+#define DEM_CARS_DE_LIEN 1023
+#define ENV_VALEURS_VARIABLE 1024
+#define ENV_OPTION 1025
+#define ENV_CODES 1026
+#define ENV_INSTS_DE_CODE 1027
+#define ENV_VARIABLES 1028
+#define ENV_VARS_DE_CODE 1029
+#define ENV_VARS_DE_INST 1030
+#define ENV_CARS_DE_VARIABLE 1031
+#define ENV_CARS_DE_LIEN 1032
+#define ENV_TOPOLOGY 1033
+#define R_ENV_TOPOLOGY 1034
+#define ENV_MACHINE 1035
+#define R_ENV_MACHINE 1036
+#define ENV_CODE 1037
+#define R_ENV_CODE 1038
+#define ENV_INSTANCE 1039
+#define R_ENV_INSTANCE 1040
+#define ENV_VAR 1041
+#define R_ENV_VAR 1042
+#define ENV_LIEN 1043
+#define R_ENV_LIEN 1044
+#define ENV_ATTRIBUTS 1045
+#define R_ENV_ATTRIBUTS 1046
+#define ENV_VDATA 1047
+#define R_ENV_VDATA 1048
+
+
+
+
+
+
+
+
+
+/* Message PVM */
+#define P_HOST_DELETE 2000
+#define P_TASK_EXIT 2001
+
+
+
+
+
+/* Codes d'erreur */
+
+/* Pas d'erreur */
+#define CPOK 0
+
+/* Emetteur inconnu */
+#define CPERIU 1
+
+/* Nom de variable inconnu */
+#define CPNMVR 2
+
+/* Type entree/sortie incompatible */
+#define CPIOVR 3
+
+/* Type inconnu */
+#define CPTP 4
+
+/* Type de variable incompatible */
+#define CPTPVR 5
+
+/* Mode de dependance inconnu */
+#define CPIT 6
+
+/* Mode dependance incompatible */
+#define CPITVR 7
+
+/* Requete non autorisee */
+#define CPRENA 8
+
+/* Type de deconnexion incorrect */
+#define CPDNTP 9
+
+/* Directive de deconnexion incorrecte */
+#define CPDNDI 10
+
+/* Nom de code inconnu */
+#define CPNMCD 11
+
+/* Nom d'instance inconnu */
+#define CPNMIN 12
+
+/* Attente */
+#define CPATTENTE 13
+
+/* Blocage */
+#define CPBLOC 14
+
+/* Nombre de valeurs transmises egal a zero */
+#define CPNTNULL 15
+
+/* Longueur de variable insuffisante */
+#define CPLGVR 16
+
+/* L'instance doit s'arreter */
+#define CPSTOP 17
+
+/* Arret anormal */
+#define CPATAL 18
+
+/* Coupleur abscent */
+#define CPNOCP 19
+
+/* Variable sortante non connectee */
+#define CPCTVR 20
+
+/* Nombre de pas a executer egal a zero */
+#define CPPASNULL 21
+
+/* Machine inconnue */
+#define CPMACHINE 22
+
+/* COUPLAGE_GROUPE non positionnee */
+#define CPGRNU 23
+
+/* Groupe d'instances incorrect */
+#define CPGRIN 24
+
+/* Fin du fichier d'entree */
+#define CPFINFICH 25
+
+/* Erreur de format dans un fichier */
+#define CPERRFICH 26
+
+/* Requete d'avance de n pas annullee */
+/* par passage en mode NORMAL */
+#define CPNORERR 27
+
+/* Coupleur en mode NORMAL pour une */
+/* requete RUN_N_PAS ou DEF_* */
+#define CPRUNERR 28
+
+/* Option inconnue */
+#define CPOPT 29
+
+/* Valeur d'option inconnue */
+#define CPVALOPT 30
+
+/* Ecriture impossible par effacement */
+#define CPECREFF 31
+
+/* Lecture d'une variable non connectee */
+/* ou n'appartenant pas a un lien VAS */
+/* ou VAV s'il s'agit d'une sortante */
+#define CPLIEN 32
+
+/* Lecture d'une variable d'une instance*/
+/* deconnectee avec directive CP_ARRET */
+#define CPINARRET 33
+
+/* Les lectures sequentielles ne pourront plus */
+/* etre satisfaites : instance productrice arretee */
+#define CPSTOPSEQ 34
+
+/* Erreur dans la chaine de declaration */
+#define CPDECL 35
+
+/* Erreur dans l'execution de l'instance ajoutee */
+#define CPINEXEC 36
+
+/* Erreur PVM */
+#define CPPVM 37
+
+/* Erreur detectee au niveau de l'interface de couplage */
+#define CPERRINST 38
+
+
+/* IDM : les deux define suivants ont ete rajoutes a la main*/
+
+/* Erreur de mode d'execution non defini */
+#define CPMODE 39
+
+/* Erreur d'instance deconnectee */
+#define CPINSTDEC 40
+
+/* Codes des evenements pour le fichier de trace */
+
+/* Debut du couplage */
+#define DEBUT_COUPLAGE 0
+
+/* Fin du couplage */
+#define FIN_COUPLAGE 1
+
+/* Execution d'une instance par Oacc */
+#define EXEC 2
+
+/* Connexion d'une instance */
+#define CPCD 3
+
+/* Permission d'emettre accordee a l'instance */
+#define CPALLOW 4
+
+/* Requete d'ecriture */
+#define CPECRI 5
+
+/* Requete de lecture */
+#define DEB_LECT 6
+
+/* Envoi des donnees suite a une requete de lecture */
+#define FIN_LECT 7
+
+/* Deconnexion d'une instance */
+#define CPFIN 8
+
+/* Requete de fin de pas */
+#define CPFINP 9
+
+/* Requete d'autorisation de fin de pas */
+#define CPAUFP 10
+
+/* Requete d'interdiction de fin de pas */
+#define CPINFP 11
+
+/* Requete d'effacement */
+#define CPEFF 12
+
+/* Signal d'arret d'une instance */
+#define STOP 13
+
+/* Avis de blocage suite a une requete de lecture */
+#define BLOCAGE 14
+
+/* Requete de passage en mode pause */
+#define CPPAUSE 15
+
+/* Requete de passage en mode normal */
+#define CPNORMAL 16
+
+/* Requete d'execution de n pas */
+#define CPNPAS 17
+
+/* Requete de definition d'un code */
+#define CPADCD 18
+
+/* Requete de definition d'une instance */
+#define CPADINCD 19
+
+/* Requete de definition d'un lien */
+#define CPADLN 20
+
+/* Requete d'identification de version */
+#define CPIVERS 21
+
+/* Requete de demande de la liste des codes */
+#define CPICD 22
+
+/* Requete de demande des instances d'un code */
+#define CPIINCD 23
+
+/* Requete de demande de la liste des variables globales*/
+#define CPIVR 24
+
+/* Requete de demande des variables d'un code */
+#define CPIVRCD 25
+
+/* Requete de demande des variables d'une instance */
+#define CPIVRIN 26
+
+/* Requete de demande d'info sur une variable globale */
+#define CPICAVR 27
+
+/* Requete de demande des caracteristiques d'un lien */
+#define CPIILIEN 28
+
+/* Requete de modification d'une option */
+#define CPSETOPT 29
+
+/* Requete de consultation d'une option */
+#define CPGETOPT 30
+
+/* Terminaison d'une tache PVM */
+#define TASK_EXIT 31
+
+/* Deconnexion d'une machine */
+#define HOST_DELETE 32
+
+
+#ifdef PRG_MAIN
+/* Fichier principal de la bibliotheque de couplage */
+
+
+char * CPMESSAGE[] = {
+ "Pas d'erreur",
+ "Emetteur inconnu",
+ "Nom de la variable inconnu",
+ "Code entree/sortie differents dans le coupleur et dans le code",
+ "Type de variable inconnu",
+ "Types de variable differents dans le coupleur et dans le code",
+ "Mode de dependance inconnu",
+ "Modes de dependance differents dans le coupleur et dans le code",
+ "Requete non autorisee",
+ "Type de deconnexion incorrect",
+ "Directive de deconnexion incorrecte",
+ "Nom de code inconnu",
+ "Nom d'instance inconnu",
+ "Requete en attente",
+ "Cas de blocage",
+ "Nombre de valeurs transmises egal a zero",
+ "Longueur de variable insuffisante",
+ "L'instance doit s'arreter",
+ "Arret anormal d'une instance",
+ "Coupleur abscent, execution manuelle",
+ "Variable sortante non connectee",
+ "Nombre de pas a executer egal a zero",
+ "Machine non declaree",
+ "La variable d'environnement COUPLAGE_GROUPE n'est pas positionnee",
+ "Le groupe d'instances indique par COUPLAGE_GROUPE est incorrect",
+ "Fin du fichier d'entree",
+ "Erreur de format dans le fichier d'entree",
+ "Requete annulee a cause du passage en mode NORMAL",
+ "Le coupleur est en mode d'execution normal",
+ "Option inconnue",
+ "Valeur d'option incorrecte",
+ "Ecriture impossible a cause d'une requete d'effacement",
+ "Lecture d'une variable incorrectement connectee",
+ "Lecture d'une variable d'une instance deconnectee avec CP_ARRET",
+ "Lectures sequentielles plus satisfaites",
+ "Erreur dans la chaine de declaration",
+ "Erreur dans le lancement de l'instance ajoutee",
+ "Erreur PVM",
+ "Erreur detectee au niveau de l'instance",
+ };
+
+#else
+
+extern char * CPMESSAGE[];
+
+#endif
+
+
+/* Type de variables */
+#define ENTIER 30
+#define REEL 31
+#define DREEL 32
+#define COMPLEXE 33
+#define LOGIQUE 34
+#define CHAINE 35
+
+/* Macro minuscule majuscule */
+#define TOUPPER(string) \
+{\
+ int i, number = strlen(string);\
+ for (i = 0; i < number; i++) string[i] = toupper(string[i]); \
+}
+
+/* Macro inferieur */
+#define INF(a,b) (a <= b ? a : b)
+
+/* Macro superieur */
+#define SUP(a,b) (a >= b ? a : b)
+
+
+#endif
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_COMPLEX_PORT_USES_HXX_
+#define _CALCIUM_COMPLEX_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "GenericUsesPort.hxx"
+
+extern char _repository_Calcium_Complex_Port_name[];
+
+class calcium_complex_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_float,
+ CORBA::Float >,
+ Ports::Calcium_Ports::Calcium_Complex_Port,
+ _repository_Calcium_Complex_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_complex_port_uses();
+
+};
+
+#endif
--- /dev/null
+#include "calcium_port_provides.hxx"
+
+calcium_real_port_provides::~calcium_real_port_provides(void) {};
+calcium_double_port_provides::~calcium_double_port_provides(void) {};
+calcium_integer_port_provides::~calcium_integer_port_provides(void) {};
+calcium_logical_port_provides::~calcium_logical_port_provides(void) {};
+calcium_complex_port_provides::~calcium_complex_port_provides(void) {};
+calcium_string_port_provides::~calcium_string_port_provides(void) {};
--- /dev/null
+#include "calcium_integer_port_uses.hxx"
+#include "calcium_real_port_uses.hxx"
+#include "calcium_double_port_uses.hxx"
+#include "calcium_string_port_uses.hxx"
+#include "calcium_logical_port_uses.hxx"
+#include "calcium_complex_port_uses.hxx"
+
+calcium_real_port_uses::~calcium_real_port_uses(void) {};
+calcium_double_port_uses::~calcium_double_port_uses(void) {};
+calcium_integer_port_uses::~calcium_integer_port_uses(void) {};
+calcium_logical_port_uses::~calcium_logical_port_uses(void) {};
+calcium_complex_port_uses::~calcium_complex_port_uses(void) {};
+calcium_string_port_uses::~calcium_string_port_uses(void) {};
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_DOUBLE_PORT_USES_HXX_
+#define _CALCIUM_DOUBLE_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericUsesPort.hxx"
+
+extern char _repository_Calcium_Double_Port_name[];
+
+class calcium_double_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_double,
+ CORBA::Double >,
+ Ports::Calcium_Ports::Calcium_Double_Port,
+ _repository_Calcium_Double_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_double_port_uses();
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_INTEGER_PORT_USES_HXX_
+#define _CALCIUM_INTEGER_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericUsesPort.hxx"
+
+extern char _repository_Calcium_Integer_Port_name[];
+
+class calcium_integer_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_long,
+ CORBA::Long >,
+ Ports::Calcium_Ports::Calcium_Integer_Port,
+ _repository_Calcium_Integer_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_integer_port_uses();
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_LOGICAL_PORT_USES_HXX_
+#define _CALCIUM_LOGICAL_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericUsesPort.hxx"
+
+extern char _repository_Calcium_Logical_Port_name[];
+
+class calcium_logical_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_boolean,
+ CORBA::Boolean >,
+ Ports::Calcium_Ports::Calcium_Logical_Port,
+ _repository_Calcium_Logical_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_logical_port_uses();
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#include "calcium_port_factory.hxx"
+
+calcium_port_factory::calcium_port_factory() {}
+
+calcium_port_factory::~calcium_port_factory() {}
+
+provides_port *
+calcium_port_factory::create_data_servant(string type) {
+ provides_port * rtn_port = NULL;
+
+ if ( type == "integer")
+ rtn_port = new calcium_integer_port_provides();
+ if ( type == "real")
+ rtn_port = new calcium_real_port_provides();
+ if ( type == "double")
+ rtn_port = new calcium_double_port_provides();
+ if ( type == "string")
+ rtn_port = new calcium_string_port_provides();
+ if ( type == "logical")
+ rtn_port = new calcium_logical_port_provides();
+ if ( type == "complex")
+ rtn_port = new calcium_complex_port_provides();
+
+ return rtn_port;
+}
+
+uses_port *
+calcium_port_factory::create_data_proxy(string type) {
+ uses_port * rtn_port = NULL;
+
+ if ( type == "integer")
+ rtn_port = new calcium_integer_port_uses();
+ if ( type == "real")
+ rtn_port = new calcium_real_port_uses();
+ if ( type == "double")
+ rtn_port = new calcium_double_port_uses();
+ if ( type == "string")
+ rtn_port = new calcium_string_port_uses();
+ if ( type == "logical")
+ rtn_port = new calcium_logical_port_uses();
+ if ( type == "complex")
+ rtn_port = new calcium_complex_port_uses();
+
+ return rtn_port;
+}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-03-01 13:36:05 +0100 (jeu, 01 mar 2007) $
+// Id : $Id$
+
+
+#ifndef _CALCIUM_PORT_FACTORY_HXX_
+#define _CALCIUM_PORT_FACTORY_HXX_
+
+#include "uses_port.hxx"
+#include "provides_port.hxx"
+#include <string>
+
+#include "calcium_port_provides.hxx"
+
+#include "calcium_integer_port_uses.hxx"
+#include "calcium_real_port_uses.hxx"
+#include "calcium_double_port_uses.hxx"
+#include "calcium_string_port_uses.hxx"
+#include "calcium_logical_port_uses.hxx"
+#include "calcium_complex_port_uses.hxx"
+
+using namespace std;
+
+class calcium_port_factory
+{
+ public:
+ calcium_port_factory();
+ virtual ~calcium_port_factory();
+
+ virtual provides_port * create_data_servant(string type);
+ virtual uses_port * create_data_proxy(string type);
+};
+
+#endif
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-03-01 13:40:26 +0100 (jeu, 01 mar 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_PORT_PROVIDES_HXX_
+#define _CALCIUM_PORT_PROVIDES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericProvidesPort.hxx"
+#include "CalciumCouplingPolicy.hxx"
+
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_integer_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_Integer_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_long,CORBA::Long> ) \
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_real_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_Real_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_float,CORBA::Float> ) \
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_double_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_Double_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_double,CORBA::Double> ) \
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_complex_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_Complex_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_float,CORBA::Float> ) \
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_logical_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_Logical_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_boolean,CORBA::Boolean> ) \
+
+CALCIUM_GENERIC_PROVIDES_PORT(calcium_string_port_provides, \
+ POA_Ports::Calcium_Ports::Calcium_String_Port, \
+ seq_u_manipulation<Ports::Calcium_Ports::seq_string,char *> ) \
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_REAL_PORT_USES_HXX_
+#define _CALCIUM_REAL_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericUsesPort.hxx"
+
+
+extern char _repository_Calcium_Real_Port_name[];
+
+class calcium_real_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_float,
+ CORBA::Float >,
+ Ports::Calcium_Ports::Calcium_Real_Port,
+ _repository_Calcium_Real_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_real_port_uses();
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#include "calcium_integer_port_uses.hxx"
+#include "calcium_real_port_uses.hxx"
+#include "calcium_double_port_uses.hxx"
+#include "calcium_complex_port_uses.hxx"
+#include "calcium_logical_port_uses.hxx"
+#include "calcium_string_port_uses.hxx"
+
+char _repository_Calcium_Integer_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_Integer_Port:1.0";
+char _repository_Calcium_Real_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_Real_Port:1.0";
+char _repository_Calcium_Double_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_Double_Port:1.0";
+char _repository_Calcium_Complex_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_Complex_Port:1.0";
+char _repository_Calcium_Logical_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_Logical_Port:1.0";
+char _repository_Calcium_String_Port_name[]="IDL:Ports/Calcium_Ports/Calcium_String_Port:1.0";
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_STRING_PORT_USES_HXX_
+#define _CALCIUM_STRING_PORT_USES_HXX_
+
+#include "Calcium_Ports.hh"
+#include "CalciumGenericUsesPort.hxx"
+
+extern char _repository_Calcium_String_Port_name[];
+
+class calcium_string_port_uses :
+ public virtual CalciumGenericUsesPort< seq_u_manipulation<Ports::Calcium_Ports::seq_string,
+ char * >,
+ Ports::Calcium_Ports::Calcium_String_Port,
+ _repository_Calcium_String_Port_name
+ >
+{
+ public :
+
+ virtual ~calcium_string_port_uses();
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#include "calcium_uses_port.hxx"
+
+calcium_uses_port::calcium_uses_port() {}
+
+calcium_uses_port::~calcium_uses_port() {}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _CALCIUM_USES_PORT_HXX_
+#define _CALCIUM_USES_PORT_HXX_
+
+#include "uses_port.hxx"
+
+class calcium_uses_port : public uses_port
+{
+public :
+ calcium_uses_port();
+ virtual ~calcium_uses_port();
+ virtual void disconnect (bool provideLastGivenValue) {};
+};
+
+#endif
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#include "lambda.hpp"
+#include <vector>
+#include <algorithm>
+#include <iostream>
+
+struct MyRand {
+ static const double MAXVALUE = 150.0;
+ MyRand() { srand(getpid()); }
+ int operator()() const {
+ return 1+(int) ( MAXVALUE *rand()/(RAND_MAX +1.0));
+ }
+};
+
+int main() {
+
+ typedef double Type;
+ typedef double TimeType;
+ const int dataSize1=20;
+ const int dataSize2=30;
+ const int dataSize3=std::min< size_t >(dataSize1,dataSize2);
+ std::vector<Type> vect1(dataSize1),vect2(dataSize2),vect3(dataSize3);
+ MyRand myRand;
+
+ //TEST1
+ std::generate(vect1.begin(),vect1.end(),myRand);
+ std::cout << "Vecteur1 généré aléatoirement :" << std::endl;
+ copy(vect1.begin(),vect1.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+ std::generate(vect2.begin(),vect2.end(),myRand);
+ std::cout << "Vecteur2 généré aléatoirement :" << std::endl;
+ copy(vect2.begin(),vect2.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+ std::vector<Type>::iterator InIt1=vect1.begin(),InIt2=vect2.begin(),OutIt=vect3.begin();
+
+ TimeType t = 2.4;
+ TimeType t2 = 3.4;
+ TimeType t1 = 1.1;
+ TimeType deltaT = t2-t1;
+ TimeType coeff = (t2-t)/deltaT;
+
+ boost::lambda::placeholder1_type _1;
+ boost::lambda::placeholder2_type _2;
+
+ std::transform(InIt1,InIt1+dataSize3,InIt2,OutIt, ( _1 - _2 ) * coeff + _2 );
+
+ std::cout << "Vecteur3 calculé :" << std::endl;
+ copy(vect3.begin(),vect3.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+
+};
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-06 10:44:23 +0100 (mar, 06 fév 2007) $
+// Id : $Id$
+
+//Permet de vérifier la syntaxe du fichier .hxx à la compilation
+#include "CalciumInterface.hxx"
+
+int main(void) {
+ return 0;
+}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-03-01 15:07:46 +0100 (jeu, 01 mar 2007) $
+// Id : $Id$
+
+#include "CalciumCouplingPolicy.hxx"
+
+#include "calcium_port_provides.hxx"
+#include "DatastreamException.hxx"
+
+using namespace CalciumTypes;
+
+class TEST1 : public CalciumCouplingPolicy {
+public:
+ int ret;
+ TEST1() {
+
+ ret=0;
+
+ CORBA::Long time=1,tag=1;
+ typedef CalciumCouplingPolicy::DataIdContainer DataIdContainer;
+ typedef CalciumCouplingPolicy::DataId DataId;
+
+ DataId dataId(time,tag); //potentiellement avec un troisième paramètre
+ try {
+ DataIdContainer dataIds(dataId,*this);
+
+ DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ if (!dataIds.empty())
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+ std::cout << "(*dataIdIt) must be equal to given dataId parameter : " << *dataIdIt;
+ std::cout << " == " << dataId << " : " << (ret = (*dataIdIt == dataId)) << std::endl;
+ }
+ } catch(const DATASTREAM_EXCEPTION & ex) {
+ ret=1;
+ std::cout << ex.what() << std::endl;
+ }
+
+ }
+};
+
+class TEST2 : public CalciumCouplingPolicy {
+
+public:
+ int ret;
+ TEST2() {
+
+ // Doit filtrer le mode de dépendance temporel car le mode est
+ // défini itératif
+ ret=0;
+
+ CORBA::Long time=1,tag=1;
+ typedef CalciumCouplingPolicy::DataIdContainer DataIdContainer;
+ typedef CalciumCouplingPolicy::DataId DataId;
+
+ DataId dataId(time,tag); //potentiellement avec un troisième paramètre
+ setDependencyType(ITERATION_DEPENDENCY);
+ DataIdContainer dataIds(dataId,*this);
+
+
+ DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ if (!dataIds.empty())
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+ std::cout << "(*dataIdIt) must be equal to given dataId parameter : " << *dataIdIt ;
+ std::cout << " == " << DataId(0,tag) << " : " << (ret = (*dataIdIt == DataId(0,tag))) << std::endl;
+
+ }
+ }
+};
+
+
+class TEST3 : public CalciumCouplingPolicy {
+public:
+ int ret;
+
+ TEST3() {
+
+ // Doit filtrer le mode de dépendance temporel car le mode est
+ // défini itératif
+ ret=0;
+
+ CORBA::Long time=1,tag=1;
+ typedef CalciumCouplingPolicy::DataIdContainer DataIdContainer;
+ typedef CalciumCouplingPolicy::DataId DataId;
+
+ DataId dataId(time,tag); //potentiellement avec un troisième paramètre
+ setDependencyType(TIME_DEPENDENCY);
+ DataIdContainer dataIds(dataId,*this);
+
+
+ DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ if (!dataIds.empty())
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+ std::cout << "(*dataIdIt) must be equal to given dataId parameter : " << *dataIdIt ;
+ std::cout << " == " << DataId(time,0) << " : " << (ret = (*dataIdIt == DataId(time,0))) << std::endl;
+
+ }
+ }
+};
+
+int main() {
+ TEST1 test1;
+ TEST2 test2;
+ TEST3 test3;
+ return !test1.ret+!test2.ret+!test3.ret;
+};
+
--- /dev/null
+/* Outils d'Aide au Couplage de Code de Calcul : $Id$ */
+#ifndef __VERSION_H
+#define __VERSION_H
+
+/* Constantes servant a memoriser les repertoires des versions */
+/* de CALCIUM et de PVM ayant servi a la generation d'un */
+/* executable */
+
+#define ACCC_REP "/home/fayolle/CALCIUM3.0"
+#define PVM_REP "/home/fayolle/pvm3"
+
+#endif
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef _CONST_TRAITS_HXX_
+#define _CONST_TRAITS_HXX_
+
+template < typename T > struct ConstTrait { typedef T NonConstType; };
+template < typename T > struct ConstTrait < const T > { typedef T NonConstType; };
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-07 18:26:44 +0100 (mer, 07 fév 2007) $
+// Id : $Id$
+
+#ifndef _TYPE_MANIPULATION_HXX_
+#define _TYPE_MANIPULATION_HXX_
+
+#include <iostream>
+#include <CORBA.h>
+
+using namespace std;
+
+// Classes manipulation
+// -------------------
+//
+// Ces différentes classes permettent d'unifier la manipulation des
+// différents types de données dans un port datastream
+// Les données sont maniées par valeur ou par pointeur
+// pour éviter les recopies de gros volume de données
+
+// Les classes présentes quatre méthodes :
+// - clone
+// - get_data
+// - delete_data
+// - dump
+// et
+// deux type :
+// - Type : Le type CORBA de la donnée manipulée
+// - InType : Le mapping CORBA pour un paramètre IN du type manipulé
+
+
+// Cette classe permet de manipuler des types CORBA
+// any, struct, union et sequence (utiliser plutôt les seq_manipulator)
+// Ces types sont manipulés par pointeur.
+// Les données reçues de CORBA sont systématiquement
+// dupliquées pour être conservées.
+// Quelque soit le type de donnée, les données sont considérées
+// comme une donnée unique (retour de size() == 1)
+template <typename T >
+class user_type_manipulation
+{
+public:
+ typedef T * Type;
+ // correspond au mapping corba des type any, struct,
+ // union, séquence en paramètre IN
+ typedef const T & CorbaInType;
+ typedef T InnerType;
+
+ // Operation de recuperation des donnees venant de l'ORB et
+ // creation d'une copie (memoire spécialement allouee)
+ static inline Type get_data(CorbaInType data) {
+ return new T(data);
+ }
+
+ // Pb si ownerShip == True car appel par l'utilisateur de relPointer !
+ static inline InnerType * const getPointer(Type data, bool ownerShip = false) {
+ return data;
+ }
+
+ static inline void relPointer(InnerType * dataPtr) {
+ delete dataPtr;
+ }
+
+ // Operation de clonage : par defaut, creation d'une copie en memoire allouee pour l'occasion
+ static inline Type clone(Type data) {
+ return new T (* data);
+ }
+ static inline Type clone(CorbaInType data) {
+ return new T (data);
+ }
+
+ // Operation de création
+ static inline Type create (size_t size=1) {
+ return new T();
+ }
+
+ // Operation de destruction d'une donnee
+ static inline void delete_data(Type data) {
+ delete data;
+ }
+
+ // Renvoie la taille de la donnée
+ static inline size_t size(Type data) {
+ return 1;
+ }
+
+ // Dump de l'objet pour deboguage: neant car on ne connait pas sa structure
+ static inline void dump (CorbaInType data) {}
+};
+
+
+// Gére les types CORBA atomiques ('Int', 'Char', 'Float', ...)
+// Gére les types enums
+// Gére les références d'objets CORBA
+// Ces types sont manipulés par valeur
+// Les méthodes getPointer ... ne devrait pas être utilisée
+// pour ce types de données
+template <typename T>
+class atom_manipulation
+{
+public:
+ typedef T Type;
+ // correspond au mapping corba des types simples en paramètre IN
+ typedef T CorbaInType;
+ typedef T InnerType;
+
+
+ // Operation de recuperation des donnees venant de l'ORB : une copie par affectation simple
+ static inline Type get_data(CorbaInType data) {
+ return data;
+ }
+
+ static inline InnerType * const getPointer(Type & data, bool getOwnerShip = false) {
+// InnerType * ptr;
+// if (getOwnerShip) {
+// ptr =new InnerType[1];*ptr=data;
+// return ptr;
+// } else
+// return &data;
+ return &data;
+ }
+
+// static inline void relPointer(InnerType * dataPtr) {
+// return;
+// delete[] dataPtr;
+// }
+
+// Je ne sais pas comment l'implémenter sans faire
+// d'allocation heap
+//static inline InnerType * allocPointer(size_t size=1) {
+// return new InnerType[1];
+ //}
+
+ // Operation de clonage : une copie par affectation simple
+ static inline Type clone(Type data) {
+ return data;
+ }
+
+ // Inutile car Type == CorbaInType
+ // static inline Type clone(CorbaInType data) {
+ // return data;
+ // }
+
+ // Operation de création
+// static inline Type create(size_t size=1,InnerType * data=NULL,
+// bool giveOwnerShip=false) {
+// Type dummy;
+// if (dataPtr)
+// return *data;
+// else
+// return dummy;
+// }
+
+ // Operation de destruction d'une donnee: rien a faire car pas de memoire a liberer
+ static inline void delete_data(Type data) {}
+ // Renvoie la taille de la donnée
+
+ static inline size_t size(Type data) {
+ return 1;
+ }
+
+ // Dump de l'objet pour deboguage : Affiche la donnee
+ static void inline dump (CorbaInType data) {
+ cerr << "[atom_manipulation] Data : " << data << endl;
+ }
+};
+
+
+// Gére un type sequence de taille illimitee (Unbounded)
+// Ces types sont manipulés par pointeur
+template <typename seq_T,typename elem_T>
+class seq_u_manipulation {
+
+public:
+ typedef seq_T * Type;
+ // correspond au mapping corba de la séquence en paramètre IN
+ typedef const seq_T & CorbaInType;
+ typedef elem_T InnerType;
+
+
+ // Operation de recuperation des donnees venant de l'ORB
+ // Remarque : On a un paramètre d'entrée de type const seq_T &
+ // et en sortie un seq_T *
+ static inline Type get_data(CorbaInType data) {
+ CORBA::Long len = data.length();
+ CORBA::Long max = data.maximum();
+ // Récupère et devient propriétaire des données reçues dans la séquence.
+ // La séquence sera désalloué (mais pas le buffer) au retour
+ // de la méthode put (car mapping de type IN : const seq & )
+ // ATTENTION TESTER p184 si le pointeur est null
+ // ATTENTION TESTER Si le flag release si la sequence contient des chaines
+ // ou des object refs
+ std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1 ------------------" << std::endl;
+ InnerType * p_data = const_cast<seq_T &>(data).get_buffer(true);
+ std::cout << "----seq_u_manipulation::get_data(..)-- MARK 2 ------"<< p_data <<"------------" << std::endl;
+
+ // Crée une nouvelle sequence propriétaire des données du buffer (pas de recopie)
+ // Les données seront automatiquement désallouées par appel interne à la méthode freebuf
+ // lors de la destruction de l'objet par appel à delete_data.
+ return new seq_T (max, len, p_data, true);
+ }
+
+ static inline size_t size(Type data) {
+ return data->length();
+ }
+
+ // Operation de destruction d'une donnee
+ static inline void delete_data(Type data) {
+ delete data;
+ }
+
+ // Operation de clonage : par defaut creation d'une copie en memoire allouee pour l'occasion
+ // Utilisation du constructeur du type seq_T
+ static inline Type clone(Type data) {
+ return new seq_T (*data) ;
+ }
+ static inline Type clone(CorbaInType data) {
+ return new seq_T (data);
+ }
+
+ // Permet de désallouer le buffer dont on détient le pointeur par appel
+ // à la méthode getPointer avec ownerShip=True si la séquence contenante
+ // à été détruite.
+ static inline InnerType * const getPointer(Type data, bool ownerShip = false) {
+ InnerType * p_data;
+ if (ownerShip) {
+ p_data = data->get_buffer(true);
+ delete_data(data);
+ } else
+ p_data = data->get_buffer(false);
+ return p_data;
+ }
+
+ // Permet de désallouer le buffer dont on détient le pointeur par appel
+ // à la méthode getPointer avec ownerShip=True si la séquence contenante
+ // à été détruite.
+ static inline void relPointer(InnerType * dataPtr) {
+ seq_T::freebuf(dataPtr);
+ }
+
+ // Permet d'allouer un buffer pour la séquence
+ static inline InnerType * allocPointer(size_t size ) {
+ return seq_T::allocbuf(size);
+ }
+
+ // Operation de création du type corba soit
+ // - Vide et de taille size
+ // - Utilisant les données du pointeur *data de taille size
+ // (généralement pas de recopie qlq soit l'ownership )
+ // data doit avoir été alloué par allocPointer si giveOwnerShip = true
+ static inline Type create(size_t size, InnerType * const data = NULL,
+ bool giveOwnerShip = false ) {
+ Type tmp;
+ if (!data) {
+ tmp = new seq_T();
+ tmp->length(size);
+ } else {
+ tmp = new seq_T(size,size,data,giveOwnerShip);
+ }
+ return tmp;
+ }
+
+ // Dump de l'objet pour deboguage
+ static void inline dump (CorbaInType data) {
+ // Affiche la longueur des donnees
+ cerr << "[seq_u_manipulation] Data length: " << data.length() << endl;
+ // Affiche la longueur des donnees
+ cerr << "[seq_u_manipulation] Data max: " << data.maximum() << endl;
+ }
+};
+
+
+// Gére un type sequence de taille limitée (bounded)
+// Ces types sont manipulés par pointeur
+// Cette classe diffère de la seq_u_manipulation
+// par la signature du constructeur de la séquence
+// utilisé dans le methode get_data
+template <typename seq_T,typename elem_T>
+class seq_b_manipulation {
+
+public:
+ typedef seq_T * Type;
+ typedef const seq_T & CorbaInType;
+ typedef elem_T InnerType;
+
+
+ // Operation de recuperation des donnees venant de l'ORB
+ // Sans opération de notre part, ces données seraient perdues
+ // au retour de la méthode put de GenericPort.
+ // Remarque : On a un paramètre d'entrée de type const seq_T &
+ // et en sortie un seq_T *
+ static inline Type get_data(CorbaInType data) {
+ CORBA::Long len = data.length();
+ // Récupère et devient propriétaire des données reçues dans la séquence
+ // la séquence sera désalloué (mais pas le buffer)
+ // au retour de la méthode put (car mapping de type IN : const seq & )
+ InnerType * p_data = const_cast<seq_T &>(data).get_buffer(true);
+ // Crée une nouvelle sequence propriétaire des données du buffer (généralement pas de recopie)
+ // Les données seront automatiquement désallouées par appel interne à la méthode freebuf
+ // lors de la destruction de l'objet par appel à delete_data.
+ return new seq_T (len, p_data, true);
+ }
+
+ static inline size_t size(Type data) {
+ return data->length();
+ }
+
+ // Operation de clonage : par defaut creation d'une copie en memoire allouee pour l'occasion
+ // Utilisation du constructeur du type seq_T
+ static inline Type clone(Type data) {
+ return new seq_T (* data);
+ }
+ static inline Type clone(CorbaInType data) {
+ return new seq_T (data);
+ }
+
+ // Operation de destruction d'une donnee CORBA
+ static inline void delete_data(Type data) {
+ delete data;
+ }
+
+ // Récupère un pointeur sur les données de type InnerType contenue dans la séquence
+ // si ownership=True, l'utilisateur devra appeler relPointer
+ // si ownership=False, l'utilisateur devra appeler delete_data sur la séquence contenante
+ static inline InnerType * const getPointer(Type data, bool getOwnerShip = false) {
+ InnerType * p_data;
+ if (getOwnerShip) {
+ p_data = data->get_buffer(true);
+ delete_data(data);
+ } else
+ p_data = data->get_buffer(false);
+ return p_data;
+ }
+
+ // Permet de désallouer le buffer dont on détient le pointeur par appel
+ // à la méthode getPointer avec ownerShip=True si la séquence contenante
+ // à été détruite.
+ static inline void relPointer(InnerType * dataPtr) {
+ seq_T::freebuf(dataPtr);
+ }
+
+ // Permet d'allouer un buffer pour la séquence
+ static inline InnerType * allocPointer(size_t size ) {
+ return seq_T::allocbuf(size);
+ }
+
+ // Operation de création du type corba soit
+ // - Vide et de taille size
+ // - Utilisant les données du pointeur *data de taille size
+ // (généralement pas de recopie qlq soit l'ownership )
+ // data doit avoir été alloué par allocPointer si giveOwnerShip = true
+ static inline Type create(size_t size, InnerType * const data = NULL,
+ bool giveOwnerShip = false ) {
+ Type tmp;
+ if (!data) {
+ tmp = new seq_T();
+ tmp->length(size);
+ } else {
+ tmp = new seq_T(size,data,giveOwnerShip);
+ }
+ return tmp;
+ }
+
+
+ // Dump de l'objet pour deboguage
+ static inline void dump (CorbaInType data) {
+ // Affiche la longueur des donnees
+ cerr << "[seq_b_manipulation] Data length: " << data.length() << endl;
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _COUPLING_POLICY_HXX_
+#define _COUPLING_POLICY_HXX_
+
+#include "IteratorTraits.hxx"
+#include "FindKeyPredicate.hxx"
+#include <algorithm>
+#include <functional>
+#include <iterator>
+
+// La politique de couplage doit définir
+// 1) le type DataId qui identifie une instance de données
+// 2) Un container de DataId appelé DataIdContainer et son itérateur
+// 3) Un constructeur de DataIdContainer qui initialise le container à partir d'un DataId
+
+////////// Le DataId //////////////
+// COUPLING_POLICY::DataId
+// est construit par DataId(T1 time,T2 tag)
+//
+// COUPLING_POLICY::DataIdContainer
+// qui défini
+// les types : DataIdContainer::iterator
+// les méthodes : begin(), end(), empty()
+// COUPLING_POLICY::DataIdContainer::iterator
+// qui défini
+// les méthodes : != , == , ++() , ()++, *(), =
+
+// COUPLING_POLICY::DataTable
+// std::map< DataId, DataType> DataTable;
+
+// Définir void COUPLING_POLICY::DataIdContainer(const DataId &, CouplingPolicy & )
+// qui initialise le container à partir d'un DataId
+
+// Opérateur d'affichage d'un dataId (les types doivent être affichables)
+
+
+class CouplingPolicy {
+
+public:
+
+ // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
+ // - l'itérateur wDataIt1 pointe alors sur ce dataId
+ // Cette méthode doit être redéfini dans le mode de couplage s'il veut gérer
+ // le cas d'un dataId damandé non trouvé mais encadrable
+ // par deux autres dataIds. La méthode renvoie alors isBounded== true et :
+ // - l'itérateur wDataIt1 doit être tel que :
+ // wDataIt1->first < wdataId < (wDataIt1+1)->first
+ template < typename Container >
+ bool isDataIdConveniant(Container & storedDatas,
+ const typename Container::key_type & expectedDataId,
+ bool & isEqual , bool & isBounded,
+ typename Container::iterator & wDataIt1 ) const {
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+ isBounded = false;
+ FindKeyPredicate<value_type> fkp(expectedDataId);
+ wDataIt1 = std::find_if(storedDatas.begin(),storedDatas.end(),fkp);
+ isEqual = (wDataIt1 != storedDatas.end());
+ std::cout << "-------- Generic isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
+ return isEqual || isBounded;
+ }
+
+
+ // Méthode Vide déclarée ici pour définir son nom dans GenericPort
+ // Elle profite à tous les modes de couplages n'implémentant pas
+ // de comportement particulier dans la méthode get pour
+ // le cas d'une demande de dataId inexistant mais encadré par deux autres
+ template <typename DataManipulator>
+ struct BoundedDataIdProcessor{
+ BoundedDataIdProcessor(CouplingPolicy couplingPolicy) {};
+ template < typename Iterator, typename DataId >
+ void inline apply(typename iterator_t<Iterator>::value_type & data,
+ const DataId & dataId,
+ const Iterator & it1) {
+ typedef typename iterator_t<Iterator>::value_type value_type;
+ std::cout << "-------- Generic BoundedDataIdProcessor.apply() called " << std::endl;
+
+ }
+ };
+
+ // Supprime un DataId et ses données associées
+ // du container
+ // Cette méthode utilisée dans GenericPort::Get
+ // peut être surchargée pour par exemple
+ // conserver un historique.
+ template <typename DataManipulator>
+ struct EraseDataIdProcessor {
+
+ EraseDataIdProcessor(CouplingPolicy couplingPolicy) {};
+
+ template < typename Container >
+ void apply(Container & storedDatas,
+ typename Container::iterator & wDataIt1 ) const {
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+
+ std::cout << "-------- Generic eraseDataId called " << std::endl;
+ }
+ };
+
+ // Lorsque cette méthode est appelée l'expectedDataId n'a pas été trouvé
+ // et n'est pas non plus encadrée (en mode temporel)
+ // Si l'on effectue pas de traitement particulier la méthode renvoie false
+ // Si le port a reçu une directive STOP une exception est levée
+ // Si le port a reçu une directive CONTINUE, on localise l'expected
+ template < typename DataManipulator >
+ struct DisconnectProcessor {
+
+ DisconnectProcessor(CouplingPolicy couplingPolicy) {};
+
+ template < typename Container, typename DataId >
+ bool apply(Container & storedDatas,
+ const DataId & expectedDataId,
+ typename Container::iterator & wDataIt1 ) const {
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+
+ std::cout << "-------- Generic DisconnectProcessor called " << std::endl;
+ }
+ };
+
+ virtual ~CouplingPolicy() {}
+
+};
+
+#endif
--- /dev/null
+/* Module Filtre
+ * -------------
+ *
+ * Implemente les fonctions de filtrage et conversion d'un port de DATASTREAM
+ *
+ * Rappel des fonctions du Filtrage:
+ * --------------------------------
+ *
+ * Dans une communication de type DATASTREAM, le destinataire indique à l'avance la liste
+ * des instances qu'il veut recevoir, c'est à dire celles qui lui sont nécessaires.
+ * Il indique pour cela la liste des 'times' et la liste des 'tags' qui
+ * caractérisent les instances désirées.
+ * Ces deux listes sont indépendantes. Toute instance dont les paramètres 'time' et
+ * 'tag' figurent dans la liste des 'times' et respectivement dans la liste des
+ * 'tags' est désirée par le destinataire.
+ * Par la suite, une telle instance sera acceptée par le port-DATASTREAM. Les autres
+ * seront rejetées.
+ *
+ * Le filtrage consiste à limiter les valeurs possibles du paramètre TIME ou TAG (un
+ * entier). La liste des valeurs possibles est décrite sous la forme d'une liste de
+ * valeurs ou de séquences arithmétiques de valeurs.
+ * Exemple:
+ * La liste 1; 3; 30:34; 40:50:2 autorise les valeurs 1 et 3 et toutes les valeurs
+ * comprises entre 30 et 34 inclus et toutes les valeurs de la séquence 40 à 50
+ * inclus par pas de 2, c'est à dire 40, 42, ... 50.
+ * On appelle règle élémentaire de filtrage celle spécifiant un élément de la liste
+ * des valeurs autorisées: soit une seule valeur, soit une séquence de valeurs. Une
+ * séquence de valeurs est spécifiée par sa valeur de départ, sa valeur de fin et
+ * son pas. Le filtrage est donc défini par une suite de règles de filtrage.
+ * La fonction élémentaire de configuration du filtrage sert à spécifier une règle
+ * de filtrage.
+ *
+ * Rappels des fonctions de conversion:
+ * -----------------------------------
+ *
+ * La conversion est intimement liée au filtrage car seules les valeurs passant le
+ * filtre sont converties. La conversion n'est pas obligatoire. Une valeur de TIME ou TAG
+ * entrante peut ne pas être convertie. Elle garde alors sa valeur et est gardée
+ * telle quelle pour l'objet destinataire.
+ * DATASTREAM peut associer une règle de conversion à chaque règle élémentaire de
+ * filtrage.
+ * La conversion consiste à changer:
+ * - un valeur de TIME ou TAG en une valeur différente
+ * - une séquence de valeurs en une autre séquence de valeurs de même taille
+ * (ex: 30:40 en 300:400:10)
+ * Mais la conversion permet aussi de transformer:
+ * - une valeur de TIME ou TAG unique en une séquence de valeurs (les données entrantes sont
+ * alors duppliquées et à chaque fois que l'objet destinataire réclame une donnée
+ * de la séquence, il reçoit en fait une copie de la donnée reçue une seule fois)
+ *
+ * - une séquence de valeurs en une valeur unique (alors, chaque donnée entrante
+ * associée à un TIME ou TAG de la séquence correspond à une donnée unique pour le
+ * destinataire: seule la dernière reçue est la donnée valide)
+ *
+ */
+
+#include <vector>
+#include <iostream>
+
+// Pour l'utilisation de "vector" de la STL
+using namespace std;
+
+// Classe filtre_elementaire
+//
+// Implémente une structure de donnée décrivant un filtre élémentaire
+// sur le paramètre TIME ou TAG; c'est
+// - soit une valeur entière unique
+// - soit une séquence arithmétique de valeurs
+//
+class filtre_elementaire
+{
+public:
+ int len; // Longueur de séquence ou 1 pour une valeur unique
+ int debut; // Début de la séquence ou valeur pour une valeur unique
+ int fin; // Fin de la séquence
+ int pas; // Pas de la séquence
+
+ // Constructeur par défaut
+ filtre_elementaire() {}
+
+ // Création d'un filtre élémentaire pour une valeur unique
+ filtre_elementaire(int valeur)
+ {
+ this->len = 1;
+ this->debut = valeur;
+ }
+
+ // Création d'un filtre élémentaire pour une séquence de valeurs entières
+ // Le pas par défaut est 1
+ filtre_elementaire (int _debut, int _fin, int _pas=1)
+ {
+ this->debut = _debut;
+ this->len = (_fin - _debut) / _pas;
+ if (this->len > 0)
+ {
+ this->fin = _debut + _pas * this->len; // Calcule la vrai borne de fin
+ this->pas = _pas;
+ this->len += 1; // Compte les bornes et non les intervalles
+ }
+ else // erreur de spécification: on ne prend que la première valeur
+ this->len = 1;
+ }
+
+ // Constructeur par copie
+ filtre_elementaire (filtre_elementaire &_f)
+ {
+ this->len = _f.len;
+ this->debut = _f.debut;
+ this->fin = _f.fin;
+ this->pas = _f.pas;
+ }
+};
+
+// Classe filtre_conversion
+//
+// Implémente le filtrage et la conversion du paramètre TIME ou TAG
+// des données reçues par un port DATASTREAM.
+//
+// Mode d'emploi:
+// 1) Création d'un objet
+// 2) Configuration de cet objet par passage de paramètres
+// de filtage et de conversion
+// 3) A la création d'un port DATASTREAM, on passe au constructeur
+// deux objets 'filtre_conversion', l'un pour le TIME, l'autre pour le TAG.
+// 4) A l'utilisation du port DATASTREAM, celui-ci appelle la méthode
+// "applique_filtre_conversion" pour opérer
+//
+class filtre_conversion
+{
+private:
+ // Structure de données décrivant une conversion élémentaire:
+ // un filtre élementaire
+ // et un pointeur éventuel vers les paramètres de conversion associés
+ class conversion_elementaire
+ {
+ public :
+ // Data
+ filtre_elementaire filtre;
+ filtre_elementaire * p_convers;
+
+ // Constructeur
+ conversion_elementaire() {}
+
+ // Constructeur par copie d'un objet non modifie (const)
+ conversion_elementaire (const conversion_elementaire& _ce)
+ {
+ *this = _ce;
+ }
+ // Remarque: le Constructeur par copie d'un objet existe par defaut mais sans le modificateur 'const'
+ // et l'emploi d'un objet comme element dans un vecteur oblige d'avoir un tel const-copy-constructor.
+ };
+
+ // Données de configuration de filtrage et conversion:
+ // une table de filtres élémentaires
+ // avec leurs données de conversion associées éventuelles
+ vector<conversion_elementaire> config;
+
+public:
+ // Constructeur: juste une allocation mémoire initiale
+ filtre_conversion() {}
+
+ // Destructeur:
+ // réclamer la mémoire utilisée par tous les éléments du vecteur config
+ ~filtre_conversion()
+ {
+ vector<conversion_elementaire>::iterator i;
+ for (i = this->config.begin(); i != this->config.end(); i ++)
+ {
+ delete (*i).p_convers;
+ }
+ }
+
+ // Configuration partielle par ajout d'un filtre élémentaire
+ bool config_elementaire (filtre_elementaire& _f)
+ {
+// cout << "ajout config_elementaire 1 " << this << endl;
+ conversion_elementaire conv_elem;
+
+ conv_elem.filtre = _f;
+ conv_elem.p_convers = NULL;
+
+ // Ajoute cette conversion/filtrage elementaire a la liste
+ this->config.push_back (conv_elem);
+
+// vector<conversion_elementaire>::iterator i;
+// cout << "liste apres ajout:" << endl;
+// for (i = this->config.begin(); i != this->config.end(); i ++)
+// {
+// cout << "config elem " << endl;
+// cout << "filtre: len, debut, fin, pas " << (*i).filtre.len << " " << (*i).filtre.debut << " " << (*i).filtre.fin << " " << (*i).filtre.pas << endl;
+// }
+
+ return true;
+ }
+
+ // Configuration partielle par ajout d'un filtre élémentaire
+ // et sa conversion associée
+ //
+ // Retourne false si les param de conversion sont incompatibles avec le filtre élémentaire.
+ // La configuration partielle est alors refusée.
+ //
+ bool config_elementaire (filtre_elementaire& _f, filtre_elementaire& _conv)
+ {
+// cout << "ajout config_elementaire 2 " << this << endl;
+
+ if (_f.len == 1 || _conv.len == 1 || _f.len == _conv.len)
+ {
+ conversion_elementaire conv_elem;
+ conv_elem.filtre = _f;
+ conv_elem.p_convers = new filtre_elementaire(_conv);
+
+ // Ajoute cette conversion/filtrage elementaire a la liste
+ this->config.push_back (conv_elem);
+
+// vector<conversion_elementaire>::iterator i;
+// cout << "liste apres ajout:" << endl;
+// for (i = this->config.begin(); i != this->config.end(); i ++)
+// {
+// cout << "config elem " << endl;
+// cout << "filtre: len, debut, fin, pas " << (*i).filtre.len << " " << (*i).filtre.debut << " " << (*i).filtre.fin << " " << (*i).filtre.pas << endl;
+// }
+
+ return true;
+ }
+ else
+ {
+ // Filtre et conversion incompatibles
+ return false;
+ }
+ }
+
+ // applique_filtre_conversion: Opération du filtre et de la conversion
+ template <typename T > T applique_filtre_conversion (T valeur_initiale, vector<T>& liste_conversions) const;
+};
+
+
+
+// filtre_conversion::applique_filtre_conversion: Opération du filtre et de la conversion
+//
+// Etant donné une valeur entière (de TIME ou de TAG), cette méthode détermine :
+// - si cette valeur passe le filtre
+// - dans le cas où une conversion existe, la liste des valeurs de conversion
+// qui correspondent à la valeur initiale
+//
+// Dans tous les cas, cette méthode retourne une liste de valeurs.
+// Dans le cas où il n'y a pas de conversion, cette liste a une longueur 1
+// et ne contient que la valeur initiale.
+//
+// Paramètre d'entrée : la valeur initiale (integer)
+//
+// Paramètre de sortie : la liste des valeurs après conversion (vector<int>)
+//
+// Valeur de retour : la longueur de la liste
+// si cette longueur est 0, c'est que la valeur initiale ne passe pas le filtre
+//
+template <typename T>
+T filtre_conversion::applique_filtre_conversion (T valeur_initiale, vector<T>& liste_conversions) const
+{
+ // Part d'une liste vierge
+ liste_conversions.clear();
+
+// cout << "config applique_filtre_conversion " << this << endl;
+
+ // Balaye tous les éléments de configuration
+ // et cherche pour chacun d'eux si la valeur initiale est présente parmi les valeurs filtrées
+
+ // Pour tous les éléments de configuration du filtrage/conversion
+ vector<conversion_elementaire>::const_iterator i;
+ for (i = config.begin(); i != config.end(); i ++)
+ {
+
+// cout << "config elem " << endl;
+// cout << "filtre: len, debut, fin, pas " << (*i).filtre.len << " " << (*i).filtre.debut << " " << (*i).filtre.fin << " " << (*i).filtre.pas << endl;
+
+ bool si_passe_filtre = false;
+
+ // Si la longueur du filtre est 1
+ if ((*i).filtre.len == 1) {
+ // Si la valeur initiale correspond à la valeur du filtre
+ if ((*i).filtre.debut == valeur_initiale)
+ si_passe_filtre = true;
+ } else {
+ // Si la valeur initiale est dans la séquence des valeurs du filtre
+ // la valeur est comprise dans les bornes [debut,fin]
+ // et sa distance du début de la séquence est modulo le pas
+ if ( ((*i).filtre.fin - valeur_initiale >= 0) == (valeur_initiale - (*i).filtre.debut >= 0)
+ && (valeur_initiale - (*i).filtre.debut) % (*i).filtre.pas == 0 ) {
+ si_passe_filtre = true;
+ }
+ }
+
+ // Si la valeur initiale passe le filtre
+ if (si_passe_filtre) {
+ // cout << "config: filtre passe " << endl;
+
+ // Si il y a une conversion à effectuer
+ if ((*i).p_convers != NULL) {
+
+ // Si la longueur du filtre est 1
+ if ((*i).filtre.len == 1) {
+
+ // Si la longueur des paramètres de conversion est aussi 1
+ if ((*i).p_convers->len == 1) {
+ // Ajoute la valeur de conversion à la liste des valeurs après conversion
+ liste_conversions.push_back ((*i).p_convers->debut);
+ } else {
+ // Ajoute la séquence de conversion à la liste des valeurs après conversion
+ for (int s = (*i).p_convers->debut; s != (*i).p_convers->fin; s += (*i).p_convers->pas) {
+ liste_conversions.push_back (s);
+ }
+ liste_conversions.push_back ((*i).p_convers->fin);
+ }
+
+ } else {
+ // Le filtre est une séquence qui est convertie en une autre séquence de même longueur
+ // Choisit la valeur au rang désiré dans la séquence de conversion
+ int rang = (valeur_initiale - (*i).filtre.debut) / (*i).filtre.pas;
+
+ int valeur_convertie = (*i).p_convers->debut + rang * (*i).p_convers->pas;
+
+ // Ajoute cette valeur à la liste des valeurs après conversion
+ liste_conversions.push_back (valeur_convertie);
+ }
+ } else {
+ // Ajoute la valeur initiale telle-quelle à la liste des valeurs après conversion
+ liste_conversions.push_back (valeur_initiale);
+ }
+ }
+ }
+
+ return liste_conversions.size();
+}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-06 17:20:28 +0100 (mar, 06 fév 2007) $
+// Id : $Id$
+
+#ifndef DATASTREAM_EXCEPTION_HXX
+#define DATASTREAM_EXCEPTION_HXX
+
+#include "DSC_Exception.hxx"
+#include "CalciumTypes.hxx"
+
+struct DatastreamException : public DSC_Exception {
+
+ DatastreamException( const CalciumTypes::InfoType info,
+ const string & text,
+ const char *fileName,
+ const unsigned int lineNumber,
+ const char *funcName):
+ DSC_Exception(text,fileName,lineNumber,funcName),_info(info)
+ {};
+
+
+ DatastreamException( const CalciumTypes::InfoType info,
+ const string & text ):
+ DSC_Exception(text),_info(info)
+ {};
+
+ DatastreamException(CalciumTypes::InfoType info, const DSC_Exception & ex ):
+ DSC_Exception(ex),_info(info) {};
+
+ virtual ~DatastreamException() throw() {};
+ CalciumTypes::InfoType getInfo() const { return _info;}
+ void setInfo(CalciumTypes::InfoType info) {_info=info;}
+
+private:
+ CalciumTypes::InfoType _info;
+};
+
+
+#endif /* DATASTREAM_EXCEPTION_HXX */
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef __DISPLAY_PAIR__
+#define __DISPLAY_PAIR__
+
+#include <iostream>
+
+template <typename T, typename U> std::ostream & operator <<(std::ostream & os, const std::pair<T,U> & p)
+{ os << "(" << p.first << "," << p.second << ")";
+ return os;
+};
+
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef __FIND_KEY_PREDICATE__
+#define __FIND_KEY_PREDICATE__
+
+#include <functional>
+#include <utility>
+#include "DisplayPair.hxx"
+
+template < typename T >
+struct FindKeyPredicate : public std::unary_function < T, bool >
+{
+ T _value;
+ FindKeyPredicate(const T& value):_value(value){}
+ inline bool operator()(const T &v1, const T& v2) const {
+ std::cout << "FindKeyPredicate Generic -> :" << &(v1.first) << std::endl;
+ return ( v1 == _value );
+ }
+};
+
+// Pour les MAPs avec une clef sous forme de pair
+// template <typename T1, typename T2, typename T3>
+// struct FindKeyPredicate< std::pair<const std::pair<T1,T2>, T3 > > :
+// public std::binary_function < std::pair<const std::pair<T1,T2>, T3 >,
+// std::pair<const std::pair<T1,T2>, T3 >, bool >
+// {
+// std::pair<T1,T2> _value;
+// FindKeyPredicate(const std::pair<T1,T2> & value):_value(value){
+// std::cout << "1-Initializing with value " << _value << std::endl;
+// }
+// bool operator()( const std::pair<const std::pair<T1,T2>, T3 > & v1,
+// const std::pair<const std::pair<T1,T2>, T3 > v2) const {
+// std::cout << "1-> :" << v1 << "," << v2 << " " << std::endl;
+// return (v1.first <= _value ) && (_value < v2.first) ;
+// }
+// };
+
+template <typename T1, typename T2>
+struct FindKeyPredicate< std::pair<T1,T2> > : public std::unary_function < std::pair<T1,T2>, bool >
+{
+ T1 _value;
+ FindKeyPredicate(const T1 & value):_value(value){
+ std::cout << "FindKeyPredicate 2-Initializing with value " << _value << std::endl;
+ }
+
+ inline bool operator()( const std::pair<T1,T2> & v1) const {
+ std::cout << "FindKeyPredicate 2-> :" << v1.first << std::endl;
+ return v1.first == _value ;
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _GENERIC_PORT_HXX_
+#define _GENERIC_PORT_HXX_
+
+#include "CorbaTypeManipulator.hxx"
+
+// SALOME CORBA Exception
+#include "Utils_CorbaException.hxx"
+// SALOME C++ Exception
+#include "Utils_SALOME_Exception.hxx"
+
+#include <iostream>
+#include <map>
+
+// Inclusions pour l'affichage
+#include <algorithm>
+#include <iterator>
+
+// Classe GenericPort
+// --------------------------------
+//
+// Definition: Implemente un port de type "data-stream"
+// Cette implémentation gère tous les types de données définies par DataManipulator::type
+// Ce port est soumis à une politique d'itération sur les identificateurs de données (DataId)
+// Un identificateur de données est construit à partir d'un ou plusieurs paramètres de la méthode put
+// tels que : une date, une itération, un pas de temps ou une combinaison de ces paramètres.
+
+template < typename DataManipulator, class COUPLING_POLICY >
+class GenericPort : public COUPLING_POLICY {
+public:
+ // Type de données manipulés
+ typedef typename DataManipulator::Type DataType;
+ typedef typename DataManipulator::CorbaInType CorbaInDataType;
+
+ GenericPort();
+ virtual ~GenericPort();
+
+ template <typename TimeType,typename TagType> void put(CorbaInDataType data, TimeType time, TagType tag);
+ template <typename TimeType,typename TagType> DataType get(TimeType time, TagType tag);
+ template <typename TimeType,typename TagType> DataType get(TimeType ti, TimeType tf, TagType tag = 0);
+ template <typename TimeType,typename TagType> DataType next(TimeType &t, TagType &tag );
+ void close (PortableServer::POA_var poa, PortableServer::ObjectId_var id);
+
+private:
+
+ // Type identifiant une instance de donnee. Exemple (time,tag)
+ typedef typename COUPLING_POLICY::DataId DataId;
+ typedef std::map< DataId, DataType> DataTable;
+
+ // Stockage des donnees recues et non encore distribuées
+ DataTable storedDatas ;
+
+ // Indicateur que le destinataire attend une instance particuliere de données
+ bool waitingForConvenientDataId;
+ // Indicateur que le destinataire attend n'importe qu'elle instance de données
+ bool waitingForAnyDataId;
+
+ // Identificateur de la donné que le destinataire (propriétaire du port) attend
+ DataId expectedDataId ;
+ // Sauvegarde du DataId courant pour la méthode next
+ DataId lastDataId;
+ bool lastDataIdSet;
+ // Exclusion mutuelle d'acces a la table des données reçues
+ omni_mutex storedDatas_mutex;
+ // Condition d'attente d'une instance (Le processus du Get attend la condition declaree par le processus Put)
+ omni_condition cond_instance;
+
+};
+
+template < typename DataManipulator, typename COUPLING_POLICY >
+GenericPort<DataManipulator, COUPLING_POLICY >::GenericPort() :
+ cond_instance(& this->storedDatas_mutex),waitingForConvenientDataId(false),
+ waitingForAnyDataId(false),lastDataIdSet(false) {}
+
+template < typename DataManipulator, typename COUPLING_POLICY>
+GenericPort<DataManipulator, COUPLING_POLICY>::~GenericPort() {
+ typename DataTable::iterator it;
+ // for (it=storedDatas.begin(); it!=storedDatas.end(); ++it) {
+ // std::cout << "~GenericPort() : destruction de la donnnée associée au DataId :"<< (*it).first << std::endl;
+ // DataManipulator::delete_data( (*it).second );
+ // }
+}
+
+template < typename DataManipulator, typename COUPLING_POLICY> void
+GenericPort<DataManipulator, COUPLING_POLICY>::close (PortableServer::POA_var poa,
+ PortableServer::ObjectId_var id) {
+ // Ferme le port en supprimant le servant
+ // La desactivation du servant du POA provoque sa suppression
+ poa->deactivate_object (id);
+}
+
+
+/* Methode put_generique
+ *
+ * Stocke en memoire une instance de donnee (pointeur) que l'emetteur donne a l'intention du destinataire.
+ * Reveille le destinataire, si il y a lieu.
+ */
+template < typename DataManipulator, typename COUPLING_POLICY>
+template < typename TimeType,typename TagType>
+void GenericPort<DataManipulator, COUPLING_POLICY>::put(CorbaInDataType dataParam,
+ TimeType time,
+ TagType tag) {
+
+ try {
+ // Affichage des donnees pour DEBUGging
+ cerr << "parametres emis: " << time << ", " << tag << endl;
+ DataManipulator::dump(dataParam);
+
+ // L'intérêt des paramètres time et tag pour ce port est décidé dans la politique de couplage
+ // Il est possible de filtrer en prenant en compte uniquement un paramètre time/tag ou les deux
+ // Il est également possible de convertir les données recues ou bien de les dupliquer
+ // pour plusieurs valeurs de time et/ou tag (d'où la notion de container dans la politique de couplage)
+ typedef typename COUPLING_POLICY::DataIdContainer DataIdContainer;
+ typedef typename COUPLING_POLICY::DataId DataId;
+
+ DataId dataId(time,tag);
+ // Effectue les traitements spécifiques à la politique de couplage
+ // pour construire une liste d'ids (par filtrage, conversion ...)
+ // DataIdContainer dataIds(dataId,*(static_cast<const COUPLING_POLICY *>(this)));
+ DataIdContainer dataIds(dataId, *this);
+
+ typename DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ bool expectedDataReceived = false;
+
+ std::cout << "-------- Put : MARK 1 ------------------" << std::endl;
+ if ( dataIds.empty() ) return;
+ std::cout << "-------- Put : MARK 1bis ------------------" << std::endl;
+
+ // Recupere les donnees venant de l'ORB et relâche les structures CORBA
+ // qui n'auraient plus cours en sortie de méthode put
+ DataType data = DataManipulator::get_data(dataParam);
+
+
+ int nbOfIter = 0;
+
+ std::cout << "-------- Put : MARK 2 ------ "<< (dataIdIt == dataIds.end()) << "------------" << std::endl;
+ std::cout << "-------- Put : MARK 2bis "<< (*dataIdIt) <<"------------------" << std::endl;
+ storedDatas_mutex.lock();
+
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+
+ std::cout << "-------- Put : MARK 3 ------------------" << std::endl;
+ // Duplique l'instance de donnée pour les autres dataIds
+ if (nbOfIter > 0) data = DataManipulator::clone(data);
+ std::cout << "-------- Put : MARK 3bis -----"<< dataIdIt.operator*() <<"------------" << std::endl;
+
+ DataId currentDataId=*dataIdIt;
+
+ std::cerr << "processing dataId : "<< currentDataId << std::endl;
+
+ std::cout << "-------- Put : MARK 4 ------------------" << std::endl;
+
+ // Ajoute l'instance de la donnee a sa place dans la table de données
+ // ou remplace une instance précédente si elle existe
+
+ // Recherche la première clé telle quelle ne soit pas < currentDataId
+ // pour celà l'opérateur de comparaison storedDatas.key_comp() est utilisé
+ // <=> premier emplacement où l'on pourrait insérer notre DataId
+ // <=> en général équivaux à (*wDataIt).first >= currentDataId
+ typename DataTable::iterator wDataIt = storedDatas.lower_bound(currentDataId);
+ std::cout << "-------- Put : MARK 5 ------------------" << std::endl;
+
+ // On n'a pas trouvé de dataId supérieur au notre ou
+ // on a trouvé une clé > à cet Id
+ if (wDataIt == storedDatas.end() || storedDatas.key_comp()(currentDataId,(*wDataIt).first) ) {
+ std::cout << "-------- Put : MARK 6 ------------------" << std::endl;
+ // Ajoute la donnee dans la table
+ wDataIt = storedDatas.insert(wDataIt, make_pair (currentDataId, data));
+ } else {
+ // Si on n'est pas en fin de liste et qu'il n'y a pas de relation d'ordre strict
+ // entre notre dataId et le DataId pointé c'est qu'ils sont identiques
+ std::cout << "-------- Put : MARK 7 ------------------" << std::endl;
+ // Les données sont remplacées par les nouvelles valeurs
+ // lorsque que le dataId existe déjà
+ DataType old_data = (*wDataIt).second;
+ (*wDataIt).second = data;
+ // Detruit la vieille donnee
+ DataManipulator::delete_data (old_data);
+ }
+
+ std::cout << "-------- Put : MARK 8 ------------------" << std::endl;
+ // Compte le nombre de dataIds à traiter
+ ++nbOfIter;
+
+ std::cout << "-------- Put : waitingForConvenientDataId : " << waitingForConvenientDataId <<"---" << std::endl;
+ std::cout << "-------- Put : waitingForAnyDataId : " << waitingForAnyDataId <<"---" << std::endl;
+ std::cout << "-------- Put : currentDataId : " << currentDataId <<"---" << std::endl;
+ std::cout << "-------- Put : expectedDataId : " << expectedDataId <<"---" << std::endl;
+ std::cout << "-------- Put : MARK 9 ------------------" << std::endl;
+
+ // A simplifier mais :
+ // - pas possible de mettre des arguments optionnels à cause
+ // du type itérator qui n'est pas connu (pas de possibilité de déclarer un static )
+ // - compliquer de créer une méthode sans les paramètres inutiles tout en réutilisant
+ // la méthode initiale car cette dernière ne peut pas être déclarée virtuelle
+ // à cause de ses paramètres templates. Du coup, il faudrait aussi redéfinir la
+ // méthode simplifiée dans les classes définissant une politique
+ // de couplage particulière ...
+ bool dummy1,dummy2; typename DataTable::iterator dummy3;
+ // Par construction, les valeurs de waitingForAnyDataId, waitingForConvenientDataId et de
+ // expectedDataId ne peuvent pas être modifiées pendant le traitement de la boucle
+ // sur les dataIds (à cause du lock utilisé dans la méthode put et les méthodes get )
+ // rem : Utilisation de l'évaluation gauche droite su logical C or
+ if ( waitingForAnyDataId ||
+ ( waitingForConvenientDataId &&
+ isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) )
+ ) {
+ std::cout << "-------- Put : MARK 10 ------------------" << std::endl;
+ //Doit pouvoir réveiller le get ici (a vérifier)
+ expectedDataReceived = true;
+ }
+ }
+
+ if (expectedDataReceived) {
+ std::cout << "-------- Put : MARK 11 ------------------" << std::endl;
+ // si waitingForAnyDataId était positionné, c'est forcément lui qui a activer
+ // expectedDataReceived à true
+ if (waitingForAnyDataId)
+ waitingForAnyDataId = false;
+ else
+ waitingForConvenientDataId = false;
+ // Reveille le thread du destinataire (stoppe son attente)
+ // Ne faudrait-il pas réveiller plutôt tous les threads ?
+ // Celui réveillé ne correspond pas forcément à celui qui demande
+ // cet expectedDataReceived.
+ // Pb1 : cas d'un un get séquentiel et d'un get sur un dataId que l'on vient de recevoir.
+ // Si l'on reveille le mauvais thread, l'autre va attendre indéfiniment ! (sauf timeout)
+ // Pb2 : également si deux attentes de DataIds même différents car on n'en stocke qu'un !
+ // Conclusion : Pour l'instant on ne gère pas un service multithreadé qui effectue
+ // des lectures simultanées sur le même port !
+ cond_instance.signal();
+ }
+ std::cout << "-------- Put : MARK 12 ------------------" << std::endl;
+
+ // Deverouille l'acces a la table : On peut remonter l'appel au dessus de expected...
+ storedDatas_mutex.unlock();
+
+ std::cout << "-------- Put : MARK 13 ------------------" << std::endl;
+
+ } // Catch les exceptions SALOME//C++ pour la transformer en une exception SALOME//CORBA
+ catch ( const SALOME_Exception & ex ) {
+ // On évite de laisser un mutex
+ storedDatas_mutex.unlock();
+
+ std::cerr << ex;
+ THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
+ }
+
+}
+
+
+// Version du Get en 0 copy
+// ( n'effectue pas de recopie de la donnée trouvée dans storedDatas )
+// ( L'utilisateur devra être attentif à la politique de gestion de l'historique
+// spécifique au mode de couplage car il peut y avoir une suppression potentielle
+// d'une donnée utilisée directement au code utilisateur )
+// Le code doit prendre connaissance du transfert de propriété ou non des données
+// auprès du mode de couplage choisi.
+template < typename DataManipulator, typename COUPLING_POLICY >
+template < typename TimeType,typename TagType>
+typename DataManipulator::Type
+GenericPort<DataManipulator, COUPLING_POLICY>::get(TimeType time,
+ TagType tag)
+// REM : Laisse passer toutes les exceptions
+// En particulier les SALOME_Exceptions qui viennent de la COUPLING_POLICY
+// Pour déclarer le throw avec l'exception spécifique il faut que je vérifie
+// qu'un setunexpeted est positionné sinon le C++ arrête tout par appel à terminate
+{
+ typedef typename COUPLING_POLICY::DataId DataId;
+ // (Pointeur sur séquence) ou valeur..
+ DataType dataToTransmit ;
+ bool isEqual, isBounded;
+ typedef typename DataManipulator::InnerType InnerType;
+
+ std::cout << "-------- Get : MARK 1 ------------------" << std::endl;
+ expectedDataId = DataId(time,tag);
+ std::cout << "-------- Get : MARK 2 ------------------" << std::endl;
+
+ typename DataTable::iterator wDataIt1;
+
+ try {
+ storedDatas_mutex.lock(); // Gérer les Exceptions ds le corps de la méthode
+
+ while ( true ) {
+
+ // Renvoie isEqual si le dataId attendu est trouvé dans storedDatas :
+ // - l'itérateur wDataIt1 pointe alors sur ce dataId
+ // Renvoie isBounded si le dataId attendu n'est pas trouvé mais encadrable et
+ // que la politique gére ce cas de figure
+ // - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
+ // Méthode provenant de la COUPLING_POLICY
+ isDataIdConveniant(storedDatas,expectedDataId,isEqual,isBounded,wDataIt1);
+ std::cout << "-------- Get : MARK 3 ------------------" << std::endl;
+
+ // L'ordre des différents tests est important
+ if ( isEqual ) {
+
+ std::cout << "-------- Get : MARK 4 ------------------" << std::endl;
+ // La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM.
+ // Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
+ // C'est EraseDataId qui choisi ou non de supprimer la donnée
+ // Du coup interaction potentielle entre le 0 copy et gestion de l'historique
+ dataToTransmit = (*wDataIt1).second;
+
+ std::cout << "-------- Get : MARK 5 ------------------" << std::endl;
+ std::cout << "-------- Get : Données trouvées à t : " << std::endl;
+ typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
+ size_t N = DataManipulator::size(dataToTransmit);
+ std::copy(InIt1, InIt1 + N,
+ std::ostream_iterator< InnerType > (std::cout," "));
+ std::cout << std::endl;
+
+ // Décide de la suppression de certaines instances de données
+ // La donnée contenu dans la structure CORBA et son dataId sont désallouées
+ // Méthode provenant de la COUPLING_POLICY
+ typename COUPLING_POLICY::EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,wDataIt1);
+ std::cout << "-------- Get : MARK 6 ------------------" << std::endl;
+ break;
+
+ }
+ std::cout << "-------- Get : MARK 7 ------------------" << std::endl;
+
+ //if ( isBounded() && COUPLING_POLICY::needToProcessBoundedDataId() ) {
+ // Le DataId demandé n'est pas trouvé mais est encadré ET la politique de couplage
+ // implémente une méthode processBoundedDataId capable de générer les données à retourner
+ if ( isBounded ) {
+ // Pour être cohérent avec la politique du bloc précédent
+ // on stocke la paire (dataId,données interpolées ).
+ // CALCIUM ne stockait pas les données interpolées.
+ // Cependant comme les données sont censées être produites
+ // par ordre croissant de DataId, de nouvelles données ne devrait pas améliorer
+ // l'interpolation.
+ // Les données calciulées sont donc stockées dans storedDatas.
+ // La propriété des données N'EST PAS transférée à l'utilisateur en mode CALCIUM.
+ std::cout << "-------- Get : MARK 8 ------------------" << std::endl;
+
+ typename COUPLING_POLICY::BoundedDataIdProcessor<DataManipulator> processBoundedDataId(*this);
+ //si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1);
+ //ancienne version template processBoundedDataId<DataManipulator>(dataToTransmit,expectedDataId,wDataIt1);
+ //BDIP processBoundedDataId;
+ processBoundedDataId.apply(dataToTransmit,expectedDataId,wDataIt1);
+
+ // Il ne peut pas y avoir déjà une clé expectedDataId dans storedDatas (utilisation de la notation [] )
+ // Cette opération n'a peut être pas un caractère générique.
+ // A déplacer en paramètre de la méthode précédente ?
+ storedDatas[expectedDataId]=dataToTransmit;
+
+ std::cout << "-------- Get : Données calculées à t : " << std::endl;
+ typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
+ size_t N = DataManipulator::size(dataToTransmit);
+
+ std::copy(InIt1, InIt1 + N,
+ std::ostream_iterator< InnerType > (std::cout," "));
+ std::cout << std::endl;
+ std::cout << "-------- Get : MARK 9 ------------------" << std::endl;
+
+ typename COUPLING_POLICY::EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,wDataIt1);
+
+ break;
+ }
+
+ // Délègue au mode de couplage la gestion d'une demande de donnée non disponible
+ // si le port est deconnecté
+ typename COUPLING_POLICY::DisconnectProcessor<DataManipulator> processDisconnect(*this);
+ if ( processDisconnect.apply(storedDatas, expectedDataId, wDataIt1) ) continue;
+
+ // Réception bloquante sur le dataId demandé
+ // Si l'instance de donnée n'est pas trouvee
+ std::cout << "-------- Get : MARK 10 ------------------" << std::endl;
+ //Positionné à faux dans la méthode put
+ waitingForConvenientDataId = true;
+ std::cout << "-------- Get : MARK 11 ------------------" << std::endl;
+
+ // Ici on attend que la méthode put recoive la donnée
+ cond_instance.wait();
+
+ std::cout << "-------- Get : MARK 12 ------------------" << std::endl;
+ }
+
+ } catch (...) {
+ storedDatas_mutex.unlock();
+ throw;
+ }
+
+ // Deverouille l'acces a la table
+ storedDatas_mutex.unlock();
+ std::cout << "-------- Get : MARK 13 ------------------" << std::endl;
+
+ // dataToTransmit est positionné par la méthode put
+ // La propriété de la données est transmise à l'utilisateur
+ return dataToTransmit;
+
+}
+
+template < typename DataManipulator, typename COUPLING_POLICY >
+template < typename TimeType,typename TagType>
+typename DataManipulator::Type
+GenericPort<DataManipulator, COUPLING_POLICY>::get(TimeType ti,
+ TimeType tf,
+ TagType tag ) {
+ TimeType t = COUPLING_POLICY::getEffectiveTime(ti,tf);
+ return get(t,tag);
+}
+
+
+// Version du next en 0 copy
+// ( n'effectue pas de recopie de la donnée trouvée dans storedDatas )
+template < typename DataManipulator, typename COUPLING_POLICY >
+template < typename TimeType,typename TagType>
+typename DataManipulator::Type
+GenericPort<DataManipulator, COUPLING_POLICY>::next(TimeType &t,
+ TagType &tag ) {
+
+ typedef typename COUPLING_POLICY::DataId DataId;
+
+ DataType dataToTransmit;
+ DataId dataId;
+
+ try {
+ storedDatas_mutex.lock();// Gérer les Exceptions ds le corps de la méthode
+
+ std::cout << "-------- Next : MARK 1 ---lastDataIdSet ("<<lastDataIdSet<<")---------------" << std::endl;
+
+ typename DataTable::iterator wDataIt1;
+ wDataIt1 = storedDatas.end();
+
+ //Recherche le prochain dataId à renvoyer
+ if (lastDataIdSet)
+ wDataIt1 = storedDatas.upper_bound(lastDataId);
+ else if ( !storedDatas.empty() ) {
+ lastDataIdSet = true;
+ wDataIt1 = storedDatas.begin();
+ }
+
+ while ( storedDatas.empty() || wDataIt1 == storedDatas.end() ) {
+
+ // Délègue au mode de couplage la gestion d'une demande de donnée non disponible
+ // si le port est deconnecté
+ typename COUPLING_POLICY::DisconnectProcessor<DataManipulator> processDisconnect(*this);
+ if ( processDisconnect.apply(storedDatas, lastDataId, wDataIt1) ) break;
+
+ std::cout << "-------- Next : MARK 2 ------------------" << std::endl;
+ //Positionné à faux dans la méthode put
+ waitingForAnyDataId = true;
+ std::cout << "-------- Next : MARK 3 ------------------" << std::endl;
+ // Ici on attend que la méthode put recoive la donnée
+ cond_instance.wait();
+
+ if (lastDataIdSet) {
+ std::cout << "-------- Next : MARK 4 ------------------" << std::endl;
+ wDataIt1 = storedDatas.upper_bound(lastDataId);
+ } else {
+ std::cout << "-------- Next : MARK 5 ------------------" << std::endl;
+ lastDataIdSet = true;
+ wDataIt1 = storedDatas.begin();
+ }
+ }
+
+ std::cout << "-------- Next : MARK 6 ------------------" << std::endl;
+
+ t = getTime( (*wDataIt1).first );
+ tag = getTag ( (*wDataIt1).first );
+ dataToTransmit = (*wDataIt1).second;
+
+ std::cout << "-------- Next : MARK 7 ------------------" << std::endl;
+ lastDataId = (*wDataIt1).first;
+
+ typename COUPLING_POLICY::EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas, wDataIt1);
+
+ std::cout << "-------- Next : MARK 8 ------------------" << std::endl;
+ } catch (...) {
+ storedDatas_mutex.unlock();
+ throw;
+ }
+ storedDatas_mutex.unlock();
+
+ std::cout << "-------- Next : MARK 9 ------------------" << std::endl;
+
+ // La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM
+ // Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
+ // c'est eraseDataId qui choisi ou non de supprimer la donnée
+ // Du coup interaction potentielle entre le 0 copy et gestion des niveaux
+ return dataToTransmit;
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
+// Id : $Id$
+
+#ifndef _GENERIC_USES_PORT_HXX_
+#define _GENERIC_USES_PORT_HXX_
+
+#include "CorbaTypeManipulator.hxx"
+
+#include "uses_port.hxx"
+#include "SALOME_Ports.hh"
+
+#include "DSC_Exception.hxx"
+
+// #define GENERATE_USES_PORT(dataManip,portType,portName) \
+// const char * _repository_##portType##_name_ = "IDL:Ports/##portType##:1.0"; \
+// GenericUsesPort< dataManip, portType, _repository_##portType##_name_ > portName;
+
+//ex : GENERATE_USES_PORT(Ports::Data_Short_Port,data_short_port);
+
+template <typename DataManipulator, typename CorbaPortType, char * repositoryName, typename UsesPort=uses_port>
+class GenericUsesPort : public virtual UsesPort
+{
+public :
+ // Type de données manipulés
+ typedef typename DataManipulator::Type DataType;
+ typedef typename DataManipulator::CorbaInType CorbaInDataType;
+
+ GenericUsesPort();
+ virtual ~GenericUsesPort();
+
+ virtual const char * get_repository_id();
+ virtual bool set_port(Ports::Port_ptr port);
+ template <typename TimeType,typename TagType>
+ void put(CorbaInDataType data, TimeType time, TagType tag);
+
+ virtual void uses_port_changed(Engines::DSC::uses_port * new_uses_port,
+ const Engines::DSC::Message message);
+
+protected :
+ Engines::DSC::uses_port * _my_ports;
+};
+
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName, typename UsesPort >
+GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::GenericUsesPort() {
+ _my_ports = NULL;
+}
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName, typename UsesPort >
+GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::~GenericUsesPort() {}
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName, typename UsesPort >
+const char *
+GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::get_repository_id() {
+ return repositoryName;
+}
+
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName, typename UsesPort >
+bool
+GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::set_port(Ports::Port_ptr port) {
+ if (_my_ports) {
+ size_t n = _my_ports->length()+1;
+ _my_ports->length(n);
+ (*_my_ports)[n]=CorbaPortType::_narrow(port);
+ } else {
+ // Vérifier si port is_nil
+ _my_ports = new Engines::DSC::uses_port();
+ _my_ports->length(1);
+ (*_my_ports)[0]=CorbaPortType::_narrow(port);
+ }
+}
+
+template <typename DataManipulator,typename CorbaPortType, char * repositoryName, typename UsesPort >
+template <typename TimeType,typename TagType>
+void
+GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::put( CorbaInDataType data,
+ TimeType time,
+ TagType tag) {
+ typedef typename CorbaPortType::_ptr_type CorbaPortTypePtr;
+ if (!_my_ports)
+ throw DSC_Exception(LOC("There is no connected provides port to communicate with."));
+
+ // PB1 : Cf remarque dans CalciumInterface, si on n'effectue pas de copie
+ // du buffer !
+ // PB2 : Si les ports provides auquels on envoie data sont collocalisés
+ // ils vont partagés le même buffer (à cause de notre optim ds get_data)
+ // il faut alors effectuer une copie ici.
+ // Pour l'instant on résoud PB2 en créant une copie de la donnée en cas
+ // de connexions multiples. Il faudra tester la collocalisation.
+ DataType copyOfData; // = data; PB1
+ for(int i = 0; i < _my_ports->length(); i++) {
+
+ CorbaPortTypePtr port = CorbaPortType::_narrow((*_my_ports)[i]);
+ //if (i) { PB1
+ copyOfData = DataManipulator::clone(data);
+ std::cout << "-------- GenericUsesPort::put : Copie de data("
+ //<< DataManipulator::getPointer(data)
+ <<") vers copyOfData ("
+ <<DataManipulator::getPointer(copyOfData)
+ <<")------------------" << std::endl;
+ //} PB1
+ try {
+ port->put(*copyOfData,time,tag); // catcher les exceptions
+ } catch(const CORBA::SystemException& ex){
+ DataManipulator::delete_data(copyOfData);
+ throw DSC_Exception(LOC(OSS() << "Impossible d'invoquer la méthode put sur le port n°"
+ << i << "( i>= 0)"));
+
+ }
+ //if (i) PB1
+ // La séquence est détruite avec le buffer si on n'est pas collocalisé
+ // La séquence est détruite sans son buffer sinon (cf comportement de get_data
+ // appelée dans put (port provides)
+ DataManipulator::delete_data(copyOfData);
+ }
+}
+
+
+template <typename DataManipulator, typename CorbaPortType, char * repositoryName, typename UsesPort>
+void
+GenericUsesPort< DataManipulator, CorbaPortType, repositoryName, UsesPort
+ >::uses_port_changed(Engines::DSC::uses_port * new_uses_port,
+ const Engines::DSC::Message message)
+{
+ if (_my_ports) delete _my_ports;
+
+ std::cerr << "GenericUsesPort::uses_port_changed" << endl;
+ _my_ports = new Engines::DSC::uses_port(*new_uses_port);
+}
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef _ITERATOR_TRAITS_HXX_
+#define _ITERATOR_TRAITS_HXX_
+
+// Trait permettant d'accéder au type de donnée stockée
+// dans une map
+template < typename MapIterator >
+struct iterator_t {
+ typedef typename MapIterator::value_type value_type1;
+ typedef typename value_type1::second_type value_type;
+};
+
+#endif
--- /dev/null
+lib_LTLIBRARIES = libSalomeDatastream.la
+
+libSalomeDatastream_la_SOURCES = fake.cc
+#DatastreamException_cxx_CXXFLAGS = -I@KERNEL_ROOT_DIR@/include/salome
+#nodist_libSalomeDatastream_la_SOURCES = $(top_builddir)/idl/Datastream_PortsSK.cc
+libSalomeDatastream_la_CXXFLAGS = -I$(top_srcdir)/src/DSC_User
+# -I$(top_srcdir)/src/DSC_User/Datastream/Palm \
+# -I@KERNEL_ROOT_DIR@/include/salome \
+# -I$(top_builddir)/idl \
+# @OMNIORB_INCLUDES@
+
+libSalomeDatastream_la_LIBADD = Palm/libSalomePalm.la Calcium/libSalomeCalcium.la
+libSalomeDatastream_la_LDFLAGS = -no-undefined -version-info 0:0:0
+##################################################################################################################
+
+include_HEADERS = GenericPort.hxx GenericUsesPort.hxx DataIdFilter.hxx CorbaTypeManipulator.hxx \
+ CouplingPolicy.hxx DisplayPair.hxx \
+ FindKeyPredicate.hxx AdjacentFunctor.hxx IteratorTraits.hxx ConstTraits.hxx \
+ lambda.hpp DatastreamException.hxx
+
+CLEANFILES = *.hh *SK.cc
+
+SUBDIRS = Palm Calcium
--- /dev/null
+AM_CXXFLAGS = -I$(top_srcdir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_User/Datastream \
+ -I$(top_builddir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_Basic \
+ -I@KERNEL_ROOT_DIR@/include/salome \
+ -I$(top_builddir)/idl \
+ @OMNIORB_INCLUDES@ \
+ -I$(top_srcdir)/src/DSC_User/Datastream/Calcium
+
+BUILT_SOURCES = SALOME_Component.hh SALOME_Exception.hh
+
+%.hh : @KERNEL_ROOT_DIR@/idl/salome/%.idl
+ @IDL@ @IDLGENFLAGS@ -I@KERNEL_ROOT_DIR@/idl/salome $<
+
+noinst_LTLIBRARIES = libSalomePalm.la
+
+libSalomePalm_la_SOURCES = palm_port_factory.cxx
+nodist_libSalomePalm_la_SOURCES = $(top_builddir)/idl/Palm_PortsSK.cc
+libSalomePalm_la_CXXFLAGS = -I$(top_srcdir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_User/Datastream \
+ -I$(top_builddir)/src/DSC_User \
+ -I$(top_srcdir)/src/DSC_Basic \
+ -I@KERNEL_ROOT_DIR@/include/salome \
+ -I$(top_builddir)/idl \
+ @OMNIORB_INCLUDES@ \
+ -I$(top_srcdir)/src/DSC_User/Datastream/Calcium
+
+
+## Réussir la déclaration forward ds ProcessTimeInterval.hxx afin d'enlever la ligne précédente
+
+noinst_PROGRAMS = test_DataIdContainer
+test_DataIdContainer_SOURCES = test_DataIdContainer.cxx
+## pas normal d'être obligé de linké à caus de __init___...thread
+test_DataIdContainer_LDFLAGS = -L@KERNEL_ROOT_DIR@/lib/salome
+#-L@PARALLEL_KERNEL_ROOT_DIR@/lib
+test_DataIdContainer_LDFLAGS += @OMNIORB_LIBS@ -lomniORB4 -lomniDynamic4 -lCOS4 -lCOSDynamic4 -lomnithread
+##\
+## -lSalomeDSCContainer -lSalomeDSCSuperv -lSalomeDSCSupervDatastream -lSalomeDSCSupervBasic
+
+TESTS = test_DataIdContainer
+##test_DataIdContainer_CXXFLAGS = $(AM_CXXFLAGS) -I$(top_srcdir)/src/DSC_User/Basic \
+## -I$(top_srcdir)/src/DSC
+##################################################################################################################
+
+include_HEADERS = palm_port_factory.hxx palm_data_short_port_provides.hxx \
+ palm_data_seq_short_port_provides.hxx PalmCouplingPolicy.hxx
+
+CLEANFILES = *.hh *SK.cc
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-29 16:12:41 +0100 (lun, 29 jan 2007) $
+// Id : $Id$
+
+#ifndef _PALM_COUPLING_POLICIES_HXX_
+#define _PALM_COUPLING_POLICIES_HXX_
+
+#include <CORBA.h>
+#include <vector>
+#include "DataIdFilter.hxx"
+#include "DisplayPair.hxx"
+#include "CouplingPolicy.hxx"
+
+class PalmCouplingPolicy: public CouplingPolicy {
+
+ template <typename T_TIME, typename T_TAG > class InternalDataIdContainer;
+ template <typename T_TIME, typename T_TAG > friend class InternalDataIdContainer;
+ // Objet de filtrage et conversion d'un TIME
+ filtre_conversion filtre_convert_TIME ;
+ // Objet de filtrage et conversion d'un TAG
+ filtre_conversion filtre_convert_TAG ;
+
+
+public:
+
+ filtre_conversion * get_filtre_convert_TIME() { return &filtre_convert_TIME; }
+ filtre_conversion * get_filtre_convert_TAG() { return &filtre_convert_TAG; }
+
+ // Classe DataId rassemblant les paramètres de la méthode PORT::put
+ // qui identifient l'instance d'une donnée pour Palm
+ // Rem : Le DataId doit pouvoir être une key dans une map stl
+ typedef CORBA::Long TimeType;
+ typedef CORBA::Long TagType;
+ typedef std::pair < TimeType , TagType > DataId;
+ typedef InternalDataIdContainer < TimeType , TagType > DataIdContainer;
+
+ TimeType getTime(const DataId &dataId) const { return dataId.first;}
+ TagType getTag (const DataId &dataId) const { return dataId.second;}
+
+ // Container qui permet d'itérer sur l'ensemble des DataId générés par les
+ // eventuelles conversions
+ template <typename T_TIME, typename T_TAG > class InternalDataIdContainer {
+
+ std::vector<T_TIME> _lTime;
+ std::vector<T_TAG> _lTag;
+
+ // Interdit la construction d'un container vide car
+ // aucune méthode d'ajout d'élément n'a été implémentée
+ InternalDataIdContainer() {}
+
+ public:
+ typedef DataId value_type;
+ template <typename TTIME, typename TTAG> class DataIdIterator;
+ typedef DataIdIterator<T_TIME, T_TAG> iterator;
+ typedef value_type & reference;
+ typedef value_type const & const_reference;
+
+ // Remplit le container d'identificateurs après avoir appliqué
+ // les filtres/convertions des paramètres "TIMEs" et des "TAGs"
+ InternalDataIdContainer(const DataId & dataId, const PalmCouplingPolicy & policy ) {
+ std::cout << "----Cst ---- InternalDataIdContainer(const DataId & dataId..) " << dataId <<std::endl;
+ policy.filtre_convert_TIME.applique_filtre_conversion(dataId.first, _lTime);
+ int c=0;
+ for(vector<CORBA::Long>::iterator i=_lTime.begin();i!=_lTime.end();++i)
+ std::cout << "_lTime["<< c++ << "] : " << *i << std::endl;
+ policy.filtre_convert_TAG.applique_filtre_conversion(dataId.second, _lTag);
+ c=0;
+ for(vector<CORBA::Long>::iterator i=_lTag.begin();i!=_lTag.end();++i)
+ std::cout << "_lTag["<< c++ << "] : " << *i << std::endl;
+ }
+
+ // Pas encore testé
+ InternalDataIdContainer(std::vector<T_TIME> const & lTime, std::vector<T_TAG> const & lTag):
+ _lTime(lTime),_lTag(lTag) {}
+
+
+ // Pas encore testé
+ InternalDataIdContainer( InternalDataIdContainer const & pc):
+ _lTime(pc._lTime), _lTag(pc._lTag) {}
+
+
+ // Pas encore testé
+ InternalDataIdContainer & operator=(const InternalDataIdContainer & p) {
+ if (this != &pc) { _lTime=pc._lTime; _lTag=pc._lTag; }
+ return *this;
+ }
+
+ virtual ~InternalDataIdContainer() {}
+
+ iterator begin() { return iterator(*this); }
+ iterator end() { return iterator(*this,_lTime.end(),_lTag.end()); }
+ // En Palm les deux paramètres du couple (temps,tag) doivent
+ // exister (un seul paramètre n'est pas recevable)
+ bool empty() const { return _lTime.empty() || _lTag.empty(); }
+
+ private:
+ // Définition de l'itérateur du container
+ template <typename TTIME, typename TTAG> class DataIdIterator {
+
+ private:
+ typedef typename std::vector<TTIME>::const_iterator ItTime;
+ typedef typename std::vector<TTAG >::const_iterator ItTag;
+ ItTime _itTime;
+ ItTag _itTag;
+ const InternalDataIdContainer<TTIME,TTAG> & _pc;
+ DataIdIterator() {}
+
+ public:
+
+ // Pas encore testé
+ DataIdIterator(const InternalDataIdContainer<TTIME,TTAG> & pc):
+ _pc(pc),_itTime(pc._lTime.begin()),_itTag(pc._lTag.begin()) {}
+ DataIdIterator(const InternalDataIdContainer<TTIME,TTAG> & pc, ItTime itTime, ItTag itTag):
+ _pc(pc),_itTime(itTime),_itTag(itTag) {}
+ // Pas encore testé
+ DataIdIterator(const DataIdIterator & dIt):
+ _pc(dIt._pc),_itTime(dIt._itTime),_itTag(dIt._itTag) {}
+ ~DataIdIterator() {}
+
+
+ // Pas encore testé
+ DataIdIterator & operator=(const DataIdIterator & dIt) {
+ if (this != &dIt) {
+ _pc=dIt._pc;_itTime=dIt._itTime;_itTag=dIt._itTag;
+ }
+ return *this;
+ }
+
+ DataId operator*() const {
+ std::cout << "-------- operator*(), *_itTime : " << *_itTime << " *_itTag " << *_itTag <<std::endl;
+ return DataId(*_itTime,*_itTag); }
+
+ bool operator==( const DataIdIterator & dIt) const {
+ return (_itTime == dIt._itTime) && (_itTag == dIt._itTag) && (&_pc == &dIt._pc);
+ }
+
+ bool operator!=( const DataIdIterator & dIt) const {
+ return (_itTime != dIt._itTime) || (_itTag != dIt._itTag) || (&_pc != &dIt._pc);
+ }
+
+ // Notation préfixé
+ DataIdIterator & operator++() {
+ if ( _itTag != _pc._lTag.end() ) {
+ ++_itTag;
+ if (_itTag != _pc._lTag.end() ) return *this;
+ }
+ if ( _itTime != _pc._lTime.end() ) {
+ ++_itTime;
+ if (_itTime != _pc._lTime.end() ) _itTag=_pc._lTag.begin();
+ }
+ return *this;
+ }
+
+ // Notation postfixé
+ DataIdIterator operator++(int fake) {
+ DataIdIterator tmpIt=*this; ++*this; return tmpIt;
+ }
+
+ }; //Fin de la classe de l'itérateur
+ }; //Fin de la classe du container
+
+
+
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef _PALM_DATA_SEQ_SHORT_PORT_PROVIDES_HXX_
+#define _PALM_DATA_SEQ_SHORT_PORT_PROVIDES_HXX_
+
+#include "Palm_Ports.hh"
+#include "provides_port.hxx"
+#include "GenericPort.hxx"
+#include "PalmCouplingPolicy.hxx"
+
+class palm_data_seq_short_port_provides :
+ public virtual POA_Ports::Palm_Ports::Palm_Data_Seq_Short_Port,
+ public virtual provides_port,
+ public virtual GenericPort< seq_u_manipulation<Ports::Palm_Ports::seq_short, CORBA::Short>,
+ PalmCouplingPolicy >
+{
+ typedef Ports::Palm_Ports::seq_short CorbaDataType;
+ typedef seq_u_manipulation<CorbaDataType, CORBA::Short> DataManipulator;
+ typedef GenericPort< DataManipulator, PalmCouplingPolicy > Port;
+
+ public :
+ palm_data_seq_short_port_provides() {}
+ virtual ~palm_data_seq_short_port_provides() {}
+
+ void put(DataManipulator::CorbaInType data, CORBA::Long time, CORBA::Long tag) {
+ Port::put(data, time, tag);
+ }
+
+ Ports::Port_ptr get_port_ref() {
+ return _this();
+ }
+};
+
+#endif
--- /dev/null
+#ifndef _PALM_DATA_SHORT_PORT_PROVIDES_HXX_
+#define _PALM_DATA_SHORT_PORT_PROVIDES_HXX_
+
+#include "Palm_Ports.hh"
+#include "provides_port.hxx"
+#include "GenericPort.hxx"
+#include "PalmCouplingPolicy.hxx"
+
+class palm_data_short_port_provides :
+ public virtual POA_Ports::Palm_Ports::Palm_Data_Short_Port,
+ public virtual provides_port,
+ public virtual GenericPort< atom_manipulation< CORBA::Short >, PalmCouplingPolicy >
+
+{
+ typedef CORBA::Short CorbaDataType;
+ typedef atom_manipulation < CorbaDataType > DataManipulator;
+ typedef GenericPort< DataManipulator, PalmCouplingPolicy > Port;
+
+ public :
+ palm_data_short_port_provides() {}
+ virtual ~palm_data_short_port_provides() {}
+
+ void put(DataManipulator::CorbaInType data, CORBA::Long time, CORBA::Long tag) {
+ Port::put(data, time, tag);
+ }
+
+ virtual Ports::Port_ptr get_port_ref() {
+ return _this();
+ }
+};
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+
+#include "palm_port_factory.hxx"
+
+palm_port_factory::palm_port_factory() {
+}
+
+palm_port_factory::~palm_port_factory() {}
+
+provides_port *
+palm_port_factory::create_data_servant(string type) {
+ provides_port * rtn_port = NULL;
+ if (type == "short") {
+ rtn_port = new palm_data_short_port_provides();
+ }
+ if (type == "seq_short") {
+ rtn_port = new palm_data_seq_short_port_provides();
+ }
+ return rtn_port;
+}
+
+uses_port *
+palm_port_factory::create_data_proxy(string type) {
+ uses_port * rtn_port = NULL;
+ return rtn_port;
+}
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+
+#ifndef _PALM_PORT_FACTORY_HXX_
+#define _PALM_PORT_FACTORY_HXX_
+
+#include "uses_port.hxx"
+#include "provides_port.hxx"
+#include <string>
+
+#include "palm_data_short_port_provides.hxx"
+#include "palm_data_seq_short_port_provides.hxx"
+
+using namespace std;
+
+class palm_port_factory
+{
+ public:
+ palm_port_factory();
+ virtual ~palm_port_factory();
+
+ virtual provides_port * create_data_servant(string type);
+ virtual uses_port * create_data_proxy(string type);
+};
+
+#endif
+
--- /dev/null
+#include "PalmCouplingPolicy.hxx"
+
+#include "palm_data_short_port_provides.hxx"
+
+//using namespace PalmCouplingPolicy;
+
+class TEST1 : public PalmCouplingPolicy {
+public:
+ TEST1() {
+
+ std::cout << "------------ TEST1 --------------" << std::endl;
+
+ int ret=0;
+
+ CORBA::Long time=1,tag=1;
+ typedef PalmCouplingPolicy::DataIdContainer DataIdContainer;
+ typedef PalmCouplingPolicy::DataId DataId;
+
+ DataId dataId(time,tag); //potentiellement avec un troisième paramètre
+ //std::vector<CORBA::Long> a(1,time);std::vector<CORBA::Long> b(1,tag);
+ //DataIdContainer dataIds(a,b);
+
+ std::cout << "-------- MARK 1 --"<< dataId <<"----------------" << std::endl;
+
+ filtre_conversion * f_time = get_filtre_convert_TIME();
+ filtre_conversion * f_tag = get_filtre_convert_TAG();
+
+ // On accepte les temps de 1 à 100 sans conversion
+ filtre_elementaire * f_time_el = new filtre_elementaire(1, 100);
+ f_time->config_elementaire(*f_time_el);
+
+ // On accepte que les tags 1 et ce sans conversion
+ filtre_elementaire * f_time_tag = new filtre_elementaire(1);
+ f_tag->config_elementaire(*f_time_tag);
+
+ DataIdContainer dataIds(dataId,*this);
+
+ DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ if (!dataIds.empty())
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+ std::cout << "-------- MARK 2 --"<< *dataIdIt <<"----------------" << std::endl;
+
+ }
+ }
+};
+
+class TEST2 : public PalmCouplingPolicy {
+public:
+ TEST2() {
+
+ std::cout << "------------ TEST2 --------------" << std::endl;
+
+ int ret=0;
+
+ CORBA::Long time=1,tag=1;
+ typedef PalmCouplingPolicy::DataIdContainer DataIdContainer;
+ typedef PalmCouplingPolicy::DataId DataId;
+
+ DataId dataId(time,tag); //potentiellement avec un troisième paramètre
+ //std::vector<CORBA::Long> a(1,time);std::vector<CORBA::Long> b(1,tag);
+ //DataIdContainer dataIds(a,b);
+
+ std::cout << "-------- MARK 1 --"<< dataId <<"----------------" << std::endl;
+
+ filtre_conversion * f_time = get_filtre_convert_TIME();
+ filtre_conversion * f_tag = get_filtre_convert_TAG();
+
+
+ filtre_elementaire * f_time_2 = new filtre_elementaire(1);
+ filtre_elementaire * g_time_2 = new filtre_elementaire(2);
+ f_time->config_elementaire(*f_time_2, *g_time_2);
+ filtre_elementaire * f_time_3 = new filtre_elementaire(1);
+ f_time->config_elementaire(*f_time_3);
+
+ // On accepte que les tags 1 et ce sans conversion
+ filtre_elementaire * f_time_tag = new filtre_elementaire(1);
+ f_time_tag = new filtre_elementaire(1);
+ f_tag->config_elementaire(*f_time_tag);
+
+
+ DataIdContainer dataIds(dataId,*this);
+
+ DataIdContainer::iterator dataIdIt = dataIds.begin();
+
+ if (!dataIds.empty())
+ for (;dataIdIt != dataIds.end();++dataIdIt) {
+ std::cout << "-------- MARK 2 --"<< *dataIdIt <<"----------------" << std::endl;
+
+ }
+ }
+};
+
+int main() {
+ TEST1 test1;
+ TEST2 test2;
+};
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#ifndef _PROCESS_TIME_INTERVAL_TRAIT_HXX_
+#define _PROCESS_TIME_INTERVAL_TRAIT_HXX_
+
+#include "IteratorTraits.hxx"
+
+// Par défaut les classes définissant un mode de couplage n'implémentent pas
+// de traitement particulier pour une de demande de données identifiées à partir
+// d'un dataId non reçu mais encadré par deux dataIds
+// Ce trait peut être spécialisé pour la classe de couplage pour effectuer
+// le traitement de son choix
+template <class WhatEver > struct ProcessTimeIntervalTraits {
+
+ template < typename Iterator >
+ std::pair<bool, typename iterator_t<Iterator>::value_type >
+ static inline apply(typename WhatEver::DataId dataId, Iterator it1) {
+ typedef typename iterator_t<Iterator>::value_type value_type;
+ return std::make_pair<bool,value_type> (0,0);
+ }
+};
+
+// class CalciumCoulpingPolicy;
+// template < typename Iterator >
+// typename iterator_t<Iterator>::value_type
+// CalciumCoulpingPolicy::processTimeInterval (DataId & dataId,
+// Iterator & it1, Iterator & it2);
+#include "CalciumCouplingPolicy.hxx"
+template <> struct ProcessTimeIntervalTraits<CalciumCouplingPolicy> {
+
+ template < class Iterator >
+ std::pair<bool,typename iterator_t<Iterator>::value_type>
+ static inline apply(CalciumCouplingPolicy::DataId dataId, Iterator it1) {
+
+ Iterator it2=it1; it2++;
+
+ typedef typename iterator_t<Iterator>::value_type value_type;
+ return std::make_pair<bool,value_type> (1,processTimeInterval(dataId,it1,it2));
+ }
+};
+
+#endif
--- /dev/null
+void fake_method(void) {
+int fake_int;
+};
--- /dev/null
+// -- lambda.hpp -- Boost Lambda Library -----------------------------------
+// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://lambda.cs.utu.fi
+
+#ifndef BOOST_LAMBDA_LAMBDA_HPP
+#define BOOST_LAMBDA_LAMBDA_HPP
+
+
+#include "boost/lambda/core.hpp"
+
+#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
+#include <istream>
+#include <ostream>
+#endif
+
+#include "boost/lambda/detail/operator_actions.hpp"
+#include "boost/lambda/detail/operator_lambda_func_base.hpp"
+#include "boost/lambda/detail/operator_return_type_traits.hpp"
+
+
+#include "boost/lambda/detail/operators.hpp"
+
+#ifndef BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+// sorry, member ptr does not work with gcc2.95
+#include "boost/lambda/detail/member_ptr.hpp"
+#endif
+
+
+#endif
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#include <iostream>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+#include <functional>
+#include <utility>
+
+#include "DisplayPair.hxx"
+#include "AdjacentFunctor.hxx"
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct MyRand {
+ static const double MAXVALUE = 150.0;
+ MyRand() { srand(getpid()); }
+ int operator()() const {
+ return 1+(int) ( MAXVALUE *rand()/(RAND_MAX +1.0));
+ }
+};
+
+int main() {
+ typedef int Type;
+ const int N=20;
+ std::vector<Type> vect(N);
+ MyRand myRand;
+
+ //TEST1
+ std::generate(vect.begin(),vect.end(),myRand);
+ std::cout << "Vecteur généré aléatoirement :" << std::endl;
+ copy(vect.begin(),vect.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+ int valueToFind = myRand();
+ std::cout << "La valeur recherchée est : " << valueToFind << std::endl;
+
+ std::sort(vect.begin(),vect.end(),std::less< Type > ());
+ std::cout << "Vecteur trié par ordre croissant :" << std::endl;
+ copy(vect.begin(),vect.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+ std::vector<Type>::iterator it,it1,it2;
+ AdjacentFunctor<Type> ap(valueToFind);
+ AdjacentFunctor<Type> & vap(ap);
+ // Ne peut pas marcher à cause de la recopie du prédicat !!
+ it = std::find_if(vect.begin(),vect.end(),vap);
+ // On peut garder la valeur prédente de l'itérateur
+ // si l'itérateur n'est pas reverse
+// for (it = vect.begin(); it!=vect.end(); ++it)
+// if ( ap(*it) ) break;
+
+ if ( it == vect.end() ) {
+ std::cout << " Je n'ai pas trouvé la valeur " << valueToFind << std::endl;
+ } else {
+ if ( (*it) == valueToFind ) std::cout << " La valeur est trouvée *it :" << (*it) << std::endl;
+ else {
+ // Type min,max;
+ // if ( ap.getBounds(min,max) ) {
+ it2=it;it2--;
+ std::cout << "La valeur : " << valueToFind << " est encadrée par (*it) :" << (*it) << " et valeur de *(it-1) :" << (*it2) << std::endl;
+ }
+ }
+
+
+
+
+ // if ( it == vect.end() ) {
+// std::cout << " Je n'ai pas trouvé la valeur " << valueToFind << std::endl;
+// } else {
+// if ( (*it) == valueToFind ) std::cout << " La valeur est trouvée *it :" << (*it) << std::endl;
+// else {
+// Type min,max;
+// if ( ap.getBounds(min,max) ) {
+// it2=it;it2--;
+// std::cout << "La valeur : " << valueToFind << " est encadrée par (*it) :" << (*it) << " et valeur de *(it-1) :" << (*it2) << std::endl;
+// }
+// }
+// }
+
+ //TEST2
+// typedef std::map<Type,double> MapIntDouble;
+// MapIntDouble myMap;
+// MapIntDouble::const_iterator itM1,itM2;
+// for(it=vect.begin(); it!=vect.end(); ++it) myMap[*it] = myRand();
+
+// std::cout << "Clés de la Map :" << std::endl;
+// for(itM1=myMap.begin();itM1!=myMap.end();++itM1)
+// //std::cout << &((*itM1).first)
+// std::cout << (*itM1).first << " ";
+// std::cout<< std::endl;
+
+// AdjacentFunctor<MapIntDouble::value_type::first_type> apMap(valueToFind);
+// for (itM1 = myMap.begin(); itM1 != myMap.end(); ++itM1)
+// if ( apMap(itM1->first) ) break;
+
+// if ( itM1 == myMap.end() ) {
+// std::cout << " Je n'est pas trouvé la valeur " << valueToFind << std::endl;
+// } else {
+// if ( (itM1->first) == valueToFind ) std::cout << " La valeur est trouvée itM1->first :" << (itM1->first) << std::endl;
+// else {
+// Type min,max;
+// if ( apMap.getBounds(min,max) ) {
+// itM2=itM1;itM2--;
+// std::cout << "La valeur " << valueToFind << " est encadrée par (itM1->first) :" << (itM1->first) << " et valeur de (it-1)->first :" << (itM2->first) << std::endl;
+// }
+// }
+// }
+
+ // TEST3
+// typedef std::map<std::pair<int,double>, double> MapIntDouble_Double;
+// MapIntDouble_Double myMapP;
+// MapIntDouble_Double::const_iterator itMP1,itMP2;
+// for(it=vect.begin(); it!=vect.end(); ++it) myMapP[std::make_pair<int,double>(*it,myRand())] = myRand();
+// //myMapP[std::make_pair<int,double>(*(vect.begin()),myRand())] = myRand();
+
+// std::cout << "Clés de la MapP :" << std::endl;
+// for(itMP1=myMapP.begin();itMP1!=myMapP.end();++itMP1)
+// std::cout << (*itMP1).first << " " ;
+// std::cout<< std::endl;
+
+// //AdjacentPredicate<std::pair<int,double> > apMap(valueToFind);
+// std::pair<int,double> valuePToFind=std::make_pair<int,double>(valueToFind,myRand());
+// //std::pair<int,double> valuePToFind=myMapP.begin()->first;
+// AdjacentFunctor< MapIntDouble_Double::key_type > apMapP(valuePToFind);
+// for (itMP1 = myMapP.begin(); itMP1 != myMapP.end(); ++itMP1)
+// if ( apMapP(itMP1->first) ) break;
+
+// if ( itMP1 == myMapP.end() ) {
+// std::cout << " Je n'est pas trouvé la valeur " << valuePToFind << std::endl;
+// } else {
+// if ( (itMP1->first) == valuePToFind ) std::cout << " La valeur est trouvée itMP1->first :" << (itMP1->first) << std::endl;
+// else {
+// MapIntDouble_Double::key_type min,max;
+// if ( apMapP.getBounds(min,max) ) {
+// itMP2=itMP1;itMP2--;
+// std::cout << "La valeur " << valuePToFind << " est encadrée par (itMP1->first) :" << (itMP1->first) << " et valeur de (it-1)->first :" << (itMP2->first) << std::endl;
+// }
+// }
+// }
+
+
+ std::cout<< std::endl;
+
+};
+
--- /dev/null
+// Eric Fayolle - EDF R&D
+// Modified by : $LastChangedBy$
+// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $
+// Id : $Id$
+
+#include "AdjacentPredicate.hxx"
+#include "DisplayPair.hxx"
+
+#include <iostream>
+
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct MyRand {
+ static const double MAXVALUE = 150.0;
+ MyRand() { srand(getpid()); }
+ int operator()() const {
+ return 1+(int) ( MAXVALUE *rand()/(RAND_MAX +1.0));
+ }
+};
+
+typedef int TimeType;
+typedef double TagType;
+typedef std::pair< TimeType , TagType > DataId;
+
+template < typename DataType >
+ DataType processTimeInterval (DataId & dataId,
+ typename std::map<DataId, DataType>::const_iterator const & it1) {
+ return (*it1).second;
+};
+
+int main() {
+ typedef int Type;
+ const int N=20;
+ std::vector<Type> vect(N);
+ MyRand myRand;
+
+ //TEST1
+ std::generate(vect.begin(),vect.end(),myRand);
+ std::cout << "Vecteur généré aléatoirement :" << std::endl;
+ copy(vect.begin(),vect.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+ int valueToFind = myRand();
+
+ std::sort(vect.begin(),vect.end(),std::less< Type > ());
+ std::cout << "Vecteur trié par ordre croissant :" << std::endl;
+ copy(vect.begin(),vect.end(),std::ostream_iterator<Type>(std::cout," "));
+ std::cout<< std::endl;
+
+ std::vector<Type>::iterator it;
+ AdjacentPredicate<Type> ap(valueToFind);
+ it = std::adjacent_find(vect.begin(),vect.end(),ap);
+ if ( it == vect.end() )
+ std::cout << "Je n'est pas trouvé d'intervalle pour encadrer " << valueToFind << std::endl;
+ else
+ std::cout << "La valeur à trouver : " << valueToFind <<" est entre * it :" << *it << " et valeur de *(it+1) :" << *(it+1) << std::endl;
+ std::cout<< std::endl;
+
+ //TEST2
+ typedef std::map<int,double> MapIntDouble;
+ MapIntDouble myMap;
+ MapIntDouble::const_iterator itM1,itM2;
+ for(it=vect.begin(); it!=vect.end(); ++it) myMap[*it] = myRand();
+
+ std::cout << "Clés de la Map :" << std::endl;
+ for(itM1=myMap.begin();itM1!=myMap.end();++itM1)
+ //std::cout << &((*itM1).first)
+ std::cout << (*itM1).first << " ";
+ std::cout<< std::endl;
+
+ //AdjacentPredicate<std::pair<int,double> > apMap(valueToFind);
+ AdjacentPredicate< MapIntDouble::value_type > apMap(valueToFind);
+ itM1 = std::adjacent_find(myMap.begin(),myMap.end(),apMap);
+ itM2=itM1;itM2++;
+ if ( itM1 == myMap.end() )
+ std::cout << "Map : Je n'est pas trouvé d'intervalle pour encadrer " << valueToFind << std::endl;
+ else {
+ std::cout << "Map : La valeur à trouver : " << valueToFind <<" est entre (*itM1).first :" << (*itM1).first << " et valeur de *(itM1+1).first :" << (*(itM2)).first << std::endl;
+ }
+ std::cout<< std::endl;
+
+ // TEST3
+ typedef std::map<std::pair<int,double>, double> MapPIntDouble_Double;
+ MapPIntDouble_Double myMapP;
+ MapPIntDouble_Double::const_iterator itMP1,itMP2;
+ // for(it=vect.begin(); it!=vect.end(); ++it) myMapP[std::make_pair<int,double>(*it,myRand())] = myRand();
+ myMapP[std::make_pair<int,double>(*(vect.begin()),myRand())] = myRand();
+
+ std::cout << "Clés de la MapP :" << std::endl;
+ for(itMP1=myMapP.begin();itMP1!=myMapP.end();++itMP1)
+ std::cout << (*itMP1).first << " " ;
+ std::cout<< std::endl;
+
+ //AdjacentPredicate<std::pair<int,double> > apMap(valueToFind);
+ // std::pair<int,double> valuePToFind=std::make_pair<int,double>(valueToFind,myRand());
+ std::pair<int,double> valuePToFind=myMapP.begin()->first;
+ AdjacentPredicate< MapPIntDouble_Double::value_type > apMapP(valuePToFind);
+ itMP1 = std::adjacent_find(myMapP.begin(),myMapP.end(),apMapP);
+ itMP2=itMP1;itMP2++;
+ if ( itMP1 == myMapP.end() )
+ std::cout << "MapP : Je n'est pas trouvé d'intervalle pour encadrer " << valuePToFind << std::endl;
+ else {
+ std::cout << "MapP : La valeur à trouver : " << valuePToFind <<" est entre (*itMP1).first :" << (*itMP1).first << " et valeur de *(itMP1+1).first :" << (*(itMP2)).first << std::endl;
+ }
+
+ std::cout << processTimeInterval<double>(valuePToFind,itMP1);
+ std::cout<< std::endl;
+
+ std::cout<< std::endl;
+
+};
+
# Author : André RIBES (EDF)
# Module : KERNEL
-SUBDIRS = DSC_Basic
+SUBDIRS = DSC_Basic DSC_User
