From: ribes Date: Mon, 5 Mar 2007 08:59:15 +0000 (+0000) Subject: Adding Datastream and DSC_User, not compile for now X-Git-Tag: DSC_OK~10 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=37875bfc03723328aa8b54af942d1338445b1356;p=modules%2Fkernel.git Adding Datastream and DSC_User, not compile for now --- diff --git a/configure.ac b/configure.ac index 39f269516..f6ee7f2a0 100644 --- a/configure.ac +++ b/configure.ac @@ -520,6 +520,7 @@ AC_OUTPUT([ \ ./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 \ diff --git a/src/DSC/DSC_User/Basic/Makefile.am b/src/DSC/DSC_User/Basic/Makefile.am new file mode 100644 index 000000000..4c6897ae3 --- /dev/null +++ b/src/DSC/DSC_User/Basic/Makefile.am @@ -0,0 +1,15 @@ +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 diff --git a/src/DSC/DSC_User/Basic/basic_port_factory.cxx b/src/DSC/DSC_User/Basic/basic_port_factory.cxx new file mode 100644 index 000000000..c2f51c86a --- /dev/null +++ b/src/DSC/DSC_User/Basic/basic_port_factory.cxx @@ -0,0 +1,25 @@ +// 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; +} diff --git a/src/DSC/DSC_User/Basic/basic_port_factory.hxx b/src/DSC/DSC_User/Basic/basic_port_factory.hxx new file mode 100644 index 000000000..eede4d7ea --- /dev/null +++ b/src/DSC/DSC_User/Basic/basic_port_factory.hxx @@ -0,0 +1,23 @@ +// 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 + diff --git a/src/DSC/DSC_User/Basic/data_short_port_provides.cxx b/src/DSC/DSC_User/Basic/data_short_port_provides.cxx new file mode 100644 index 000000000..82209e6ea --- /dev/null +++ b/src/DSC/DSC_User/Basic/data_short_port_provides.cxx @@ -0,0 +1,29 @@ +// 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(); +} diff --git a/src/DSC/DSC_User/Basic/data_short_port_provides.hxx b/src/DSC/DSC_User/Basic/data_short_port_provides.hxx new file mode 100644 index 000000000..257bd8e13 --- /dev/null +++ b/src/DSC/DSC_User/Basic/data_short_port_provides.hxx @@ -0,0 +1,29 @@ +// André Ribes EDF R&D - 2006 +// + +#ifndef _DATA_SHORT_PORT_PROVIDES_HXX_ +#define _DATA_SHORT_PORT_PROVIDES_HXX_ + +#include +#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 diff --git a/src/DSC/DSC_User/Basic/data_short_port_uses.cxx b/src/DSC/DSC_User/Basic/data_short_port_uses.cxx new file mode 100644 index 000000000..c9c02d58d --- /dev/null +++ b/src/DSC/DSC_User/Basic/data_short_port_uses.cxx @@ -0,0 +1,50 @@ +// André Ribes EDF R&D - 2006 +// + +#include "data_short_port_uses.hxx" +#include +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); +} diff --git a/src/DSC/DSC_User/Basic/data_short_port_uses.hxx b/src/DSC/DSC_User/Basic/data_short_port_uses.hxx new file mode 100644 index 000000000..f1ab8c63a --- /dev/null +++ b/src/DSC/DSC_User/Basic/data_short_port_uses.hxx @@ -0,0 +1,31 @@ +// 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 + diff --git a/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx b/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx new file mode 100644 index 000000000..67c776aa8 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx @@ -0,0 +1,59 @@ +// 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::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 diff --git a/src/DSC/DSC_User/Datastream/AdjacentPredicate.hxx b/src/DSC/DSC_User/Datastream/AdjacentPredicate.hxx new file mode 100644 index 000000000..a7c5c016e --- /dev/null +++ b/src/DSC/DSC_User/Datastream/AdjacentPredicate.hxx @@ -0,0 +1,53 @@ +// 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 +#include +#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 +struct AdjacentPredicate< std::pair, T3 > > : + public std::binary_function < std::pair, T3 >, + std::pair, T3 >, bool > +{ + std::pair _value; + AdjacentPredicate(const std::pair & value):_value(value){ + std::cout << "1-Initializing with value " << _value << std::endl; + } + bool operator()( const std::pair, T3 > & v1, + const std::pair, T3 > v2) const { + std::cout << "1-> :" << v1 << "," << v2 << " " << std::endl; + return (v1.first <= _value ) && (_value < v2.first) ; + } +}; + +template +struct AdjacentPredicate< std::pair > : public std::binary_function < std::pair, std::pair, bool > +{ + T1 _value; + AdjacentPredicate(const T1 & value):_value(value){ + std::cout << "2-Initializing with value " << _value << std::endl; + } + bool operator()( const std::pair & v1, const std::pair& v2) const { + std::cout << "2-> :" << &(v1.first) << "," << &(v2.first) << " " << std::endl; + return (v1.first <= _value ) && (_value < v2.first) ; + } +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/Calcium.c b/src/DSC/DSC_User/Datastream/Calcium/Calcium.c new file mode 100644 index 000000000..6ad934fb1 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/Calcium.c @@ -0,0 +1,137 @@ +// Eric Fayolle - EDF R&D +// Modified by : $LastChangedBy$ +// Date : $LastChangedDate$ +// Id : $Id$ + +#include "calcium.h" +#include +#include + +// 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,); diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.cxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.cxx new file mode 100644 index 000000000..eaf8c3ff4 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.cxx @@ -0,0 +1,81 @@ +// 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; + } +} diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx new file mode 100644 index 000000000..b48470681 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx @@ -0,0 +1,371 @@ +// 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 +#include +#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 class InternalDataIdContainer; + template friend class InternalDataIdContainer; + template friend class BoundedDataIdProcessor; + template friend class EraseDataIdProcessor; + template 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 + 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 struct BoundedDataIdProcessor; + template struct EraseDataIdProcessor; + template 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 +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 +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::value_type & data, + const DataId & dataId, const MapIterator & it1) { + + typedef typename iterator_t::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(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(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(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 +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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericProvidesPort.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericProvidesPort.hxx new file mode 100644 index 000000000..f7094bfd8 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericProvidesPort.hxx @@ -0,0 +1,53 @@ +// 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 +// +// 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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericUsesPort.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericUsesPort.hxx new file mode 100644 index 000000000..9bfd53029 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumGenericUsesPort.hxx @@ -0,0 +1,47 @@ +// 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 +class CalciumGenericUsesPort : public GenericUsesPort +{ +public : + virtual ~CalciumGenericUsesPort() {}; + void disconnect(bool provideLastGivenValue); + +}; + + +template +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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx new file mode 100644 index 000000000..66ef57865 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx @@ -0,0 +1,495 @@ +// 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 +#include +#include +#include "Superv_Component_i.hxx" +#include "DatastreamException.hxx" +#include "CalciumTypes.hxx" +#include "CalciumGenericUsesPort.hxx" +#include "Copy2UserSpace.hxx" +#include "Copy2CorbaSpace.hxx" +#include "CalciumPortTraits.hxx" + +#include + + +// Déplacer cette information dans CorbaTypeManipulator +// Gérer en même temps la recopie profonde. + +template +struct IsSameType { + static const bool value = false; +}; +template +struct IsSameType { + static const bool value = true; +}; + + + + +class CalciumInterface { +public : + + + static void + ecp_fin (Superv_Component_i & component, bool provideLastGivenValue) + { + std::vector usesPortNames; + std::vector::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(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 static void + ecp_free ( T1 * dataPtr ) + { + ecp_free ( dataPtr ); + } + + template static void + ecp_free ( T1 * dataPtr ) + { + + typedef typename ProvidesPortTraits::PortType PortType; + typedef typename PortType::DataManipulator DataManipulator; + typedef typename DataManipulator::Type DataType; // Attention != T + typedef typename DataManipulator::InnerType InnerType; + + DeleteTraits::value >::apply(dataPtr); + + } + + template 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 (component,dependencyType,ti,tf, + i,nomVar,bufferLength,nRead,data); + + } + + template 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::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 ")); + 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::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::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::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::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(std::cout," ")); + std::cout << "Ptr :" << data << std::endl; + + std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl; + + + return; + } + + + template 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 (component,dependencyType,t,i,nomVar,bufferLength,data); + } + + template 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::NonStarType T; + typedef typename UsesPortTraits::PortType PortType; + typedef typename ProvidesPortTraits::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 ")); + 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::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::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 struct CalTimeType { + typedef float TimeType; +}; + +template <> struct CalTimeType { + typedef double TimeType; +}; + +extern "C" CalciumTypes::InfoType +ecp_fin_ (void * component, int code) { + + Superv_Component_i * _component = static_cast(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(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(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(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(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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx new file mode 100644 index 000000000..7a6ec9e5a --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx @@ -0,0 +1,70 @@ +// 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 struct ProvidesPortTraits { + typedef UnknownPortType PortType; +}; +template <> struct ProvidesPortTraits { + typedef calcium_integer_port_provides PortType; +}; +template <> struct ProvidesPortTraits { + typedef calcium_integer_port_provides PortType; +}; +template <> struct ProvidesPortTraits { + typedef calcium_real_port_provides PortType; +}; +template <> struct ProvidesPortTraits { + typedef calcium_double_port_provides PortType; +}; +template <> struct ProvidesPortTraits { + typedef calcium_string_port_provides PortType; +}; +template <> struct ProvidesPortTraits { + 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 { + typedef calcium_complex_port_provides PortType; +}; + +template < typename T > struct StarTrait { typedef T NonStarType; }; +template < typename T > struct StarTrait< T * > { typedef T NonStarType; }; + +template struct UsesPortTraits { + typedef UnknownPortType PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_integer_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_integer_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_real_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_double_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_string_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_logical_port_uses PortType; +}; +template <> struct UsesPortTraits { + typedef calcium_complex_port_uses PortType; +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes.hxx new file mode 100644 index 000000000..38df9b241 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes.hxx @@ -0,0 +1,183 @@ +// 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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumTypesManipulator.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypesManipulator.hxx new file mode 100644 index 000000000..2ef37c863 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypesManipulator.hxx @@ -0,0 +1,19 @@ +#ifndef _CALCIUM_TYPES_MANIPULATOR_HXX_ +#define _CALCIUM_TYPES_MANIPULATOR_HXX_ + +//Cette classe n'est pas necessaire pour l'instant. +#include "Calcium_Ports.hh" + +template struct CalciumTypesManipulator : + public seq_u_manipulation { + static bool needInterpolation=true; +} + +template struct CalciumTypesManipulator : + public seq_u_manipulation { + static bool needInterpolation=true; +} + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx b/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx new file mode 100644 index 000000000..b4d1ce91d --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx @@ -0,0 +1,66 @@ +// 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 +#include +#include "CalciumPortTraits.hxx" + +template +struct Copy2CorbaSpace { + + template + static void apply( T1 * & corbaData, T2 & data, size_t nRead){ + + typedef typename ProvidesPortTraits::PortType PortType; + //typedef typename UsesPortTraits::PortType PortType; + typedef typename PortType::DataManipulator DataManipulator; + typedef typename DataManipulator::InnerType InnerType; + + std::cerr << "-------- Copy2CorbaSpace 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 MARK 2 --(dataPtr : " + << DataManipulator::getPointer(corbaData,false)<<")----------------" << std::endl; + + } +}; + +// Cas ou il faut effectuer une recopie +template <> struct +Copy2CorbaSpace { + + template + static void apply( T1 * & corbaData, T2 & data, size_t nRead){ + + typedef typename ProvidesPortTraits::PortType PortType; + // typedef typename UsesPortTraits::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 MARK 1 --(dataPtr : " << + dataPtr<<")----------------" << std::endl; + + std::copy(&data,&data+nRead,dataPtr); + + std::cerr << "-------- Copy2CorbaSpace MARK 2 --(nRead: "< MARK 3 : " ; + std::copy(dataPtr,dataPtr+nRead,std::ostream_iterator(std::cout," ")); + std::cout << std::endl; + std::cerr << "-------- Copy2CorbaSpace MARK 4 --(data : " < +#include +#include "CalciumPortTraits.hxx" + +//Cas du zero copie +template +struct Copy2UserSpace{ + + template + static void apply( T1 * & data, T2 & corbaData, size_t nRead ){ + + typedef typename ProvidesPortTraits::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{ + + //Recopie le contenu de la donnée CORBA dans le buffer utilisateur de longueur + //nRead + template + static void apply( T1 * &data, T2 & corbaData, size_t nRead){ + + typedef typename ProvidesPortTraits::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 MARK 1 --(dataPtr : " < MARK 2 --(nRead: "< MARK 3 --(data : " <(std::cout," ")); + std::cout << std::endl; + + } +}; + + +template +struct DeleteTraits { + template + static void apply(T * dataPtr) { + + typedef typename ProvidesPortTraits::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{ + template + static void apply(T * dataPtr) { + delete[] dataPtr; + } +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/Makefile.am b/src/DSC/DSC_User/Datastream/Calcium/Makefile.am new file mode 100644 index 000000000..6399a774f --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/Makefile.am @@ -0,0 +1,73 @@ +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 + diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium.h b/src/DSC/DSC_User/Datastream/Calcium/calcium.h new file mode 100644 index 000000000..b11c0f317 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium.h @@ -0,0 +1,736 @@ +/* Outils d'Aide au Couplage de Code de Calcul : $Id$ */ + +#ifndef __CALCIUM_H +#define __CALCIUM_H + +#include +#include + +#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 diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium.hf b/src/DSC/DSC_User/Datastream/Calcium/calcium.hf new file mode 100644 index 000000000..3a73c0b1f --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium.hf @@ -0,0 +1,78 @@ +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) + diff --git a/src/DSC/DSC_User/Datastream/Calcium/calciumP.h b/src/DSC/DSC_User/Datastream/Calcium/calciumP.h new file mode 100644 index 000000000..a7e9166f2 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calciumP.h @@ -0,0 +1,521 @@ +/* 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 + diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_complex_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_complex_port_uses.hxx new file mode 100644 index 000000000..1763ce056 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_complex_port_uses.hxx @@ -0,0 +1,27 @@ +// 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::Calcium_Complex_Port, + _repository_Calcium_Complex_Port_name + > +{ + public : + + virtual ~calcium_complex_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_provides.cxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_provides.cxx new file mode 100644 index 000000000..7da10afdc --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_provides.cxx @@ -0,0 +1,8 @@ +#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) {}; diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_uses.cxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_uses.cxx new file mode 100644 index 000000000..89f3be753 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_destructors_port_uses.cxx @@ -0,0 +1,13 @@ +#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) {}; diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_double_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_double_port_uses.hxx new file mode 100644 index 000000000..735a73941 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_double_port_uses.hxx @@ -0,0 +1,27 @@ +// 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::Calcium_Double_Port, + _repository_Calcium_Double_Port_name + > +{ + public : + + virtual ~calcium_double_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_integer_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_integer_port_uses.hxx new file mode 100644 index 000000000..267d069be --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_integer_port_uses.hxx @@ -0,0 +1,27 @@ +// 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::Calcium_Integer_Port, + _repository_Calcium_Integer_Port_name + > +{ + public : + + virtual ~calcium_integer_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_logical_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_logical_port_uses.hxx new file mode 100644 index 000000000..48bcd99a3 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_logical_port_uses.hxx @@ -0,0 +1,27 @@ +// 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::Calcium_Logical_Port, + _repository_Calcium_Logical_Port_name + > +{ + public : + + virtual ~calcium_logical_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.cxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.cxx new file mode 100644 index 000000000..a038222df --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.cxx @@ -0,0 +1,50 @@ +// 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; +} diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.hxx new file mode 100644 index 000000000..e412e37f1 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_factory.hxx @@ -0,0 +1,36 @@ +// 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 + +#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 + diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_port_provides.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_provides.hxx new file mode 100644 index 000000000..3f75a320c --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_port_provides.hxx @@ -0,0 +1,38 @@ +// 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 ) \ + +CALCIUM_GENERIC_PROVIDES_PORT(calcium_real_port_provides, \ + POA_Ports::Calcium_Ports::Calcium_Real_Port, \ + seq_u_manipulation ) \ + +CALCIUM_GENERIC_PROVIDES_PORT(calcium_double_port_provides, \ + POA_Ports::Calcium_Ports::Calcium_Double_Port, \ + seq_u_manipulation ) \ + +CALCIUM_GENERIC_PROVIDES_PORT(calcium_complex_port_provides, \ + POA_Ports::Calcium_Ports::Calcium_Complex_Port, \ + seq_u_manipulation ) \ + +CALCIUM_GENERIC_PROVIDES_PORT(calcium_logical_port_provides, \ + POA_Ports::Calcium_Ports::Calcium_Logical_Port, \ + seq_u_manipulation ) \ + +CALCIUM_GENERIC_PROVIDES_PORT(calcium_string_port_provides, \ + POA_Ports::Calcium_Ports::Calcium_String_Port, \ + seq_u_manipulation ) \ + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_real_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_real_port_uses.hxx new file mode 100644 index 000000000..7edd674df --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_real_port_uses.hxx @@ -0,0 +1,28 @@ +// 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::Calcium_Real_Port, + _repository_Calcium_Real_Port_name + > +{ + public : + + virtual ~calcium_real_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_repository_types.cxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_repository_types.cxx new file mode 100644 index 000000000..f8f4653f4 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_repository_types.cxx @@ -0,0 +1,18 @@ +// 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"; diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_string_port_uses.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_string_port_uses.hxx new file mode 100644 index 000000000..977a585de --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_string_port_uses.hxx @@ -0,0 +1,27 @@ +// 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::Calcium_String_Port, + _repository_Calcium_String_Port_name + > +{ + public : + + virtual ~calcium_string_port_uses(); + +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.cxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.cxx new file mode 100644 index 000000000..ddef0e4a0 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.cxx @@ -0,0 +1,10 @@ +// 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() {} diff --git a/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.hxx b/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.hxx new file mode 100644 index 000000000..b31834506 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/calcium_uses_port.hxx @@ -0,0 +1,20 @@ +// 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 + diff --git a/src/DSC/DSC_User/Datastream/Calcium/testInterpolation.cxx b/src/DSC/DSC_User/Datastream/Calcium/testInterpolation.cxx new file mode 100644 index 000000000..9daf30b84 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/testInterpolation.cxx @@ -0,0 +1,58 @@ +// 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 +#include +#include + +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 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(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(std::cout," ")); + std::cout<< std::endl; + std::vector::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(std::cout," ")); + std::cout<< std::endl; + + +}; + diff --git a/src/DSC/DSC_User/Datastream/Calcium/test_CalciumInterface.cxx b/src/DSC/DSC_User/Datastream/Calcium/test_CalciumInterface.cxx new file mode 100644 index 000000000..57632a9da --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/test_CalciumInterface.cxx @@ -0,0 +1,11 @@ +// 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; +} diff --git a/src/DSC/DSC_User/Datastream/Calcium/test_DataIdContainer.cxx b/src/DSC/DSC_User/Datastream/Calcium/test_DataIdContainer.cxx new file mode 100644 index 000000000..b2874b407 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/test_DataIdContainer.cxx @@ -0,0 +1,110 @@ +// 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; +}; + diff --git a/src/DSC/DSC_User/Datastream/Calcium/version.h b/src/DSC/DSC_User/Datastream/Calcium/version.h new file mode 100644 index 000000000..3745131ca --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Calcium/version.h @@ -0,0 +1,13 @@ +/* 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 + diff --git a/src/DSC/DSC_User/Datastream/ConstTraits.hxx b/src/DSC/DSC_User/Datastream/ConstTraits.hxx new file mode 100644 index 000000000..677937e89 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/ConstTraits.hxx @@ -0,0 +1,12 @@ +// 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 diff --git a/src/DSC/DSC_User/Datastream/CorbaTypeManipulator.hxx b/src/DSC/DSC_User/Datastream/CorbaTypeManipulator.hxx new file mode 100644 index 000000000..d00b2f78e --- /dev/null +++ b/src/DSC/DSC_User/Datastream/CorbaTypeManipulator.hxx @@ -0,0 +1,373 @@ +// 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 +#include + +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 +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 +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 +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(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 +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(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 diff --git a/src/DSC/DSC_User/Datastream/CouplingPolicy.hxx b/src/DSC/DSC_User/Datastream/CouplingPolicy.hxx new file mode 100644 index 000000000..1bf831d68 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/CouplingPolicy.hxx @@ -0,0 +1,133 @@ +// 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 +#include +#include + +// 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 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 + struct BoundedDataIdProcessor{ + BoundedDataIdProcessor(CouplingPolicy couplingPolicy) {}; + template < typename Iterator, typename DataId > + void inline apply(typename iterator_t::value_type & data, + const DataId & dataId, + const Iterator & it1) { + typedef typename iterator_t::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 + 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 diff --git a/src/DSC/DSC_User/Datastream/DataIdFilter.hxx b/src/DSC/DSC_User/Datastream/DataIdFilter.hxx new file mode 100644 index 000000000..7bd2c727d --- /dev/null +++ b/src/DSC/DSC_User/Datastream/DataIdFilter.hxx @@ -0,0 +1,332 @@ +/* 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 +#include + +// 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 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::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::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::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 T applique_filtre_conversion (T valeur_initiale, vector& 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) +// +// 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 +T filtre_conversion::applique_filtre_conversion (T valeur_initiale, vector& 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::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(); +} diff --git a/src/DSC/DSC_User/Datastream/DatastreamException.hxx b/src/DSC/DSC_User/Datastream/DatastreamException.hxx new file mode 100644 index 000000000..ecedc2807 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/DatastreamException.hxx @@ -0,0 +1,40 @@ +// 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 */ diff --git a/src/DSC/DSC_User/Datastream/DisplayPair.hxx b/src/DSC/DSC_User/Datastream/DisplayPair.hxx new file mode 100644 index 000000000..bf2a8e623 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/DisplayPair.hxx @@ -0,0 +1,17 @@ +// 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 + +template std::ostream & operator <<(std::ostream & os, const std::pair & p) +{ os << "(" << p.first << "," << p.second << ")"; + return os; +}; + + +#endif diff --git a/src/DSC/DSC_User/Datastream/FindKeyPredicate.hxx b/src/DSC/DSC_User/Datastream/FindKeyPredicate.hxx new file mode 100644 index 000000000..04bdfc203 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/FindKeyPredicate.hxx @@ -0,0 +1,55 @@ +// 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 +#include +#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 +// struct FindKeyPredicate< std::pair, T3 > > : +// public std::binary_function < std::pair, T3 >, +// std::pair, T3 >, bool > +// { +// std::pair _value; +// FindKeyPredicate(const std::pair & value):_value(value){ +// std::cout << "1-Initializing with value " << _value << std::endl; +// } +// bool operator()( const std::pair, T3 > & v1, +// const std::pair, T3 > v2) const { +// std::cout << "1-> :" << v1 << "," << v2 << " " << std::endl; +// return (v1.first <= _value ) && (_value < v2.first) ; +// } +// }; + +template +struct FindKeyPredicate< std::pair > : public std::unary_function < std::pair, 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 & v1) const { + std::cout << "FindKeyPredicate 2-> :" << v1.first << std::endl; + return v1.first == _value ; + } +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/GenericPort.hxx b/src/DSC/DSC_User/Datastream/GenericPort.hxx new file mode 100644 index 000000000..e0f656dd7 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/GenericPort.hxx @@ -0,0 +1,495 @@ +// 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 +#include + +// Inclusions pour l'affichage +#include +#include + +// 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 void put(CorbaInDataType data, TimeType time, TagType tag); + template DataType get(TimeType time, TagType tag); + template DataType get(TimeType ti, TimeType tf, TagType tag = 0); + template 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::GenericPort() : + cond_instance(& this->storedDatas_mutex),waitingForConvenientDataId(false), + waitingForAnyDataId(false),lastDataIdSet(false) {} + +template < typename DataManipulator, typename COUPLING_POLICY> +GenericPort::~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::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::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(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::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 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 processBoundedDataId(*this); + //si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1); + //ancienne version template processBoundedDataId(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 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 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::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::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 ("< 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 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 diff --git a/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx b/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx new file mode 100644 index 000000000..42d42c672 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx @@ -0,0 +1,134 @@ +// 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 +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 + 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 +GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::GenericUsesPort() { + _my_ports = NULL; +} + +template +GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::~GenericUsesPort() {} + +template +const char * +GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::get_repository_id() { + return repositoryName; +} + + +template +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 +template +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 (" + <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 +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 diff --git a/src/DSC/DSC_User/Datastream/IteratorTraits.hxx b/src/DSC/DSC_User/Datastream/IteratorTraits.hxx new file mode 100644 index 000000000..3a3401ca5 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/IteratorTraits.hxx @@ -0,0 +1,17 @@ +// 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 diff --git a/src/DSC/DSC_User/Datastream/Makefile.am b/src/DSC/DSC_User/Datastream/Makefile.am new file mode 100644 index 000000000..a10b336b2 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Makefile.am @@ -0,0 +1,23 @@ +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 diff --git a/src/DSC/DSC_User/Datastream/Palm/Makefile.am b/src/DSC/DSC_User/Datastream/Palm/Makefile.am new file mode 100644 index 000000000..268189c27 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/Makefile.am @@ -0,0 +1,49 @@ +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 + diff --git a/src/DSC/DSC_User/Datastream/Palm/PalmCouplingPolicy.hxx b/src/DSC/DSC_User/Datastream/Palm/PalmCouplingPolicy.hxx new file mode 100644 index 000000000..38f781dbf --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/PalmCouplingPolicy.hxx @@ -0,0 +1,167 @@ +// 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 +#include +#include "DataIdFilter.hxx" +#include "DisplayPair.hxx" +#include "CouplingPolicy.hxx" + +class PalmCouplingPolicy: public CouplingPolicy { + + template class InternalDataIdContainer; + template 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 class InternalDataIdContainer { + + std::vector _lTime; + std::vector _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 class DataIdIterator; + typedef DataIdIterator 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 <::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::iterator i=_lTag.begin();i!=_lTag.end();++i) + std::cout << "_lTag["<< c++ << "] : " << *i << std::endl; + } + + // Pas encore testé + InternalDataIdContainer(std::vector const & lTime, std::vector 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 class DataIdIterator { + + private: + typedef typename std::vector::const_iterator ItTime; + typedef typename std::vector::const_iterator ItTag; + ItTime _itTime; + ItTag _itTag; + const InternalDataIdContainer & _pc; + DataIdIterator() {} + + public: + + // Pas encore testé + DataIdIterator(const InternalDataIdContainer & pc): + _pc(pc),_itTime(pc._lTime.begin()),_itTag(pc._lTag.begin()) {} + DataIdIterator(const InternalDataIdContainer & 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 <, + PalmCouplingPolicy > +{ + typedef Ports::Palm_Ports::seq_short CorbaDataType; + typedef seq_u_manipulation 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 diff --git a/src/DSC/DSC_User/Datastream/Palm/palm_data_short_port_provides.hxx b/src/DSC/DSC_User/Datastream/Palm/palm_data_short_port_provides.hxx new file mode 100644 index 000000000..1ee2cc300 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/palm_data_short_port_provides.hxx @@ -0,0 +1,32 @@ +#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 diff --git a/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.cxx b/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.cxx new file mode 100644 index 000000000..48ce8d29b --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.cxx @@ -0,0 +1,30 @@ +// 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; +} diff --git a/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.hxx b/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.hxx new file mode 100644 index 000000000..290c9f116 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/palm_port_factory.hxx @@ -0,0 +1,30 @@ +// 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 + +#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 + diff --git a/src/DSC/DSC_User/Datastream/Palm/test_DataIdContainer.cxx b/src/DSC/DSC_User/Datastream/Palm/test_DataIdContainer.cxx new file mode 100644 index 000000000..b466b7f01 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/Palm/test_DataIdContainer.cxx @@ -0,0 +1,98 @@ +#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 a(1,time);std::vector 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 a(1,time);std::vector 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; +}; + diff --git a/src/DSC/DSC_User/Datastream/ProcessTimeIntervalTraits.hxx b/src/DSC/DSC_User/Datastream/ProcessTimeIntervalTraits.hxx new file mode 100644 index 000000000..f6ddb8b85 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/ProcessTimeIntervalTraits.hxx @@ -0,0 +1,45 @@ +// 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 struct ProcessTimeIntervalTraits { + + template < typename Iterator > + std::pair::value_type > + static inline apply(typename WhatEver::DataId dataId, Iterator it1) { + typedef typename iterator_t::value_type value_type; + return std::make_pair (0,0); + } +}; + +// class CalciumCoulpingPolicy; +// template < typename Iterator > +// typename iterator_t::value_type +// CalciumCoulpingPolicy::processTimeInterval (DataId & dataId, +// Iterator & it1, Iterator & it2); +#include "CalciumCouplingPolicy.hxx" +template <> struct ProcessTimeIntervalTraits { + + template < class Iterator > + std::pair::value_type> + static inline apply(CalciumCouplingPolicy::DataId dataId, Iterator it1) { + + Iterator it2=it1; it2++; + + typedef typename iterator_t::value_type value_type; + return std::make_pair (1,processTimeInterval(dataId,it1,it2)); + } +}; + +#endif diff --git a/src/DSC/DSC_User/Datastream/fake.cc b/src/DSC/DSC_User/Datastream/fake.cc new file mode 100644 index 000000000..6c137b460 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/fake.cc @@ -0,0 +1,3 @@ +void fake_method(void) { +int fake_int; +}; diff --git a/src/DSC/DSC_User/Datastream/lambda.hpp b/src/DSC/DSC_User/Datastream/lambda.hpp new file mode 100644 index 000000000..c44aa854e --- /dev/null +++ b/src/DSC/DSC_User/Datastream/lambda.hpp @@ -0,0 +1,34 @@ +// -- 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 +#include +#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 diff --git a/src/DSC/DSC_User/Datastream/testAdjacentFunctor.cxx b/src/DSC/DSC_User/Datastream/testAdjacentFunctor.cxx new file mode 100644 index 000000000..bc27c3f75 --- /dev/null +++ b/src/DSC/DSC_User/Datastream/testAdjacentFunctor.cxx @@ -0,0 +1,152 @@ +// Eric Fayolle - EDF R&D +// Modified by : $LastChangedBy$ +// Date : $LastChangedDate: 2007-01-08 19:01:14 +0100 (lun, 08 jan 2007) $ +// Id : $Id$ + +#include +#include +#include +#include +#include +#include +#include + +#include "DisplayPair.hxx" +#include "AdjacentFunctor.hxx" + +#include +#include +#include + +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 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(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(std::cout," ")); + std::cout<< std::endl; + + std::vector::iterator it,it1,it2; + AdjacentFunctor ap(valueToFind); + AdjacentFunctor & 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 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 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, double> MapIntDouble_Double; +// MapIntDouble_Double myMapP; +// MapIntDouble_Double::const_iterator itMP1,itMP2; +// for(it=vect.begin(); it!=vect.end(); ++it) myMapP[std::make_pair(*it,myRand())] = myRand(); +// //myMapP[std::make_pair(*(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 > apMap(valueToFind); +// std::pair valuePToFind=std::make_pair(valueToFind,myRand()); +// //std::pair 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; + +}; + diff --git a/src/DSC/DSC_User/Datastream/testAdjacentPredicate.cxx b/src/DSC/DSC_User/Datastream/testAdjacentPredicate.cxx new file mode 100644 index 000000000..273208d6a --- /dev/null +++ b/src/DSC/DSC_User/Datastream/testAdjacentPredicate.cxx @@ -0,0 +1,119 @@ +// 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 + +#include +#include +#include +#include + +#include +#include +#include + +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::const_iterator const & it1) { + return (*it1).second; +}; + +int main() { + typedef int Type; + const int N=20; + std::vector 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(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(std::cout," ")); + std::cout<< std::endl; + + std::vector::iterator it; + AdjacentPredicate 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 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 > 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, double> MapPIntDouble_Double; + MapPIntDouble_Double myMapP; + MapPIntDouble_Double::const_iterator itMP1,itMP2; + // for(it=vect.begin(); it!=vect.end(); ++it) myMapP[std::make_pair(*it,myRand())] = myRand(); + myMapP[std::make_pair(*(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 > apMap(valueToFind); + // std::pair valuePToFind=std::make_pair(valueToFind,myRand()); + std::pair 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(valuePToFind,itMP1); + std::cout<< std::endl; + + std::cout<< std::endl; + +}; + diff --git a/src/DSC/Makefile.am b/src/DSC/Makefile.am index 28473541b..587134f3f 100644 --- a/src/DSC/Makefile.am +++ b/src/DSC/Makefile.am @@ -23,4 +23,4 @@ # Author : André RIBES (EDF) # Module : KERNEL -SUBDIRS = DSC_Basic +SUBDIRS = DSC_Basic DSC_User