CORRECTIONS API C++ UTILISATEUR

diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumCxxInterface.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumCxxInterface.hxx
index a0e0a3e2fdbb413108b6c2b799d3aa9f7527a79e..207f2e7496a43dacdaff68730c5b4c0122f0f0d1 100644 (file)
--- a/src/DSC/DSC_User/Datastream/Calcium/CalciumCxxInterface.hxx
+++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumCxxInterface.hxx
@@ -54,11 +54,20 @@ struct IsSameType<T1,T1> {
 };
 
 
+#include <boost/type_traits/remove_all_extents.hpp>
 
 namespace CalciumInterface {
   
   /********************* INTERFACE DE DECONNEXION *****************/
 
+  static void
+  ecp_cd (Superv_Component_i & component, std::string & instanceName)
+  { 
+    /* TODO : Trouver le nom de l'instance SALOME*/
+    if (instanceName.empty()) instanceName="UNDEFINED";
+
+  }
+
   static void
   ecp_fin (Superv_Component_i & component, bool provideLastGivenValue)
   { 
@@ -142,22 +151,6 @@ namespace CalciumInterface {
 
   /********************* INTERFACES DE LECTURE *****************/
 
-  // T1 est le type de données
-  template <typename T1 > static void
-  ecp_lecture ( Superv_Component_i & component,
-              CalciumTypes::DependencyType dependencyType,
-              double        & ti,
-              double const  & tf,
-              long          & i,
-              const string  & nomVar, 
-              size_t          bufferLength,
-              size_t        & nRead, 
-              T1            * &data )
-  {
-    ecp_lecture<T1,T1> (component,dependencyType,ti,tf,
-                       i,nomVar,bufferLength,nRead,data);
-  
-  }
 
   // T1 est le type de données
   // T2 est un <nom> de type Calcium permettant de sélectionner le port CORBA correspondant 
@@ -166,7 +159,7 @@ namespace CalciumInterface {
   //     le port à utiliser est le port cplx
   template <typename T1, typename T2 > static void
   ecp_lecture ( Superv_Component_i & component,
-              CalciumTypes::DependencyType dependencyType,
+              int    const  & dependencyType,
               double        & ti,
               double const  & tf,
               long          & i,
@@ -182,7 +175,9 @@ namespace CalciumInterface {
     typedef typename PortType::DataManipulator            DataManipulator;
     typedef typename DataManipulator::Type                CorbaDataType; // Attention != T1
     typedef typename DataManipulator::InnerType           InnerType;
-
+    CalciumTypes::DependencyType _dependencyType=              
+      static_cast<CalciumTypes::DependencyType>(dependencyType);
+    
     CorbaDataType     corbaData;
 
 #ifdef _DEBUG_
@@ -228,21 +223,21 @@ namespace CalciumInterface {
                             LOC(OSS()<<"Le mode de dépendance de la variable " 
                                 << nomVar << " est indéfini."));
 
-    if ( ( portDependencyType != dependencyType ) && 
-        ( dependencyType != CalciumTypes::SEQUENCE_DEPENDENCY ) ) 
+    if ( ( portDependencyType != _dependencyType ) && 
+        ( _dependencyType != CalciumTypes::SEQUENCE_DEPENDENCY ) ) 
       throw CalciumException(CalciumTypes::CPITVR,
                             LOC(OSS()<<"Le mode de dépendance de la variable " 
                                 << nomVar << ": " << portDependencyType 
                                 << " ne correspond pas au mode demandé."));
 
   
-    if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
+    if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
       corbaData = port->get(ti,tf, 0);
 #ifdef _DEBUG_
       std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
 #endif
     } 
-    else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
+    else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
       corbaData = port->get(0, i);
 #ifdef _DEBUG_
       std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
@@ -323,53 +318,68 @@ namespace CalciumInterface {
     return;
   }
 
+  // T1 est le type de données
+  template <typename T1 > static void
+  ecp_lecture ( Superv_Component_i & component,
+              int    const  & dependencyType,
+              double        & ti,
+              double const  & tf,
+              long          & i,
+              const string  & nomVar, 
+              size_t          bufferLength,
+              size_t        & nRead, 
+              T1            * &data )
+  {
+    ecp_lecture<T1,T1> (component,dependencyType,ti,tf,
+                       i,nomVar,bufferLength,nRead,data);
+  
+  }
 
   /********************* INTERFACES D'ECRITURE *****************/
 
-  template <typename T1> static void
-  ecp_ecriture ( Superv_Component_i & component,
-                CalciumTypes::DependencyType dependencyType,
-                double const  & t,
-                long   const  & i,
-                const string  & nomVar, 
-                size_t bufferLength,
-                T1  & data ) {
-    ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data); 
-  }
-
+  // T1 : DataType
+  // T2 : PortType
   template <typename T1, typename T2> static void
   ecp_ecriture ( Superv_Component_i & component,
-                CalciumTypes::DependencyType dependencyType,
+                int    const  & dependencyType,
                 double const  & t,
                 long   const  & i,
                 const string  & nomVar, 
                 size_t bufferLength,
-                T1  & data ) 
+                T1     const  & data ) 
   {
     
     assert(&component);
 
-    //typedef typename StarTrait<TT>::NonStarType           T;
-    typedef typename UsesPortTraits<T2>::PortType          PortType;
-    typedef typename ProvidesPortTraits<T2>::PortType      ProvidesPortType;
-    typedef typename ProvidesPortType::DataManipulator     DataManipulator;
+    //typedef typename StarTrait<TT>::NonStarType                    T;
+    typedef typename boost::remove_all_extents< T2 >::type           T2_without_extent;
+    typedef typename boost::remove_all_extents< T1 >::type           T1_without_extent;
+
+    typedef typename UsesPortTraits    <T2_without_extent>::PortType UsesPortType;
+    typedef typename ProvidesPortTraits<T2_without_extent>::PortType ProvidesPortType;// pour obtenir un manipulateur de données
+    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;
+    typedef typename DataManipulator::Type                           CorbaDataType; // Attention != T1
+    typedef typename DataManipulator::InnerType                      InnerType;
+    
+    T1_without_extent const & _data = data;
+
+    CalciumTypes::DependencyType _dependencyType=              
+      static_cast<CalciumTypes::DependencyType>(dependencyType);
 
 #ifdef _DEBUG_
     std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
 #endif
     if ( nomVar.empty() ) throw CalciumException(CalciumTypes::CPNMVR,
                                                    LOC("Le nom de la variable est <nul>"));
-    PortType * port;
+    UsesPortType * port;
 #ifdef _DEBUG_
     std::cout << "-------- CalciumInterface(ecriture) MARK 2 ------------------" << std::endl;
 #endif
 
     try {
-      port  = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
+      port  = component.Superv_Component_i::get_port< UsesPortType > (nomVar.c_str());
 #ifdef _DEBUG_
       std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl;
 #endif
@@ -404,12 +414,12 @@ namespace CalciumInterface {
 //       throw (CalciumException(CalciumTypes::CPIT,ex));
 //     }
 
-    if ( dependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
+    if ( _dependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
       throw CalciumException(CalciumTypes::CPIT,
                                LOC(OSS()<<"Le mode de dépendance demandé pour la variable " 
                                    << nomVar << " est indéfini."));
 
-    if ( dependencyType == CalciumTypes::SEQUENCE_DEPENDENCY )
+    if ( _dependencyType == CalciumTypes::SEQUENCE_DEPENDENCY )
       throw CalciumException(CalciumTypes::CPIT,
                                LOC(OSS()<<"Le mode de dépendance SEQUENCE_DEPENDENCY pour la variable " 
                                    << nomVar << " est impossible en écriture."));
@@ -419,7 +429,7 @@ namespace CalciumInterface {
     // 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 ) 
+//     if ( portDependencyType != _dependencyType ) 
 //       throw CalciumException(CalciumTypes::CPITVR,
 //                             LOC(OSS()<<"Le mode de dépendance de la variable " 
 //                                 << nomVar << " ne correspond pas au mode demandé."));
@@ -448,7 +458,7 @@ namespace CalciumInterface {
     //   OLD : la séquence locale. Or la méthode put récupère le buffer directement
     //   OLD : qui est alors le buffer utilisateur. Il pourrait alors arriver que :
     //   OLD :   * Le recepteur efface le buffer emetteur
-    //   OLD :   * Le port lui-même efface le buffer de l'ulisateur !
+    //   OLD :   * Le port lui-même efface le buffer de l'utilisateur !
     //   OLD : Cette copie est effectuée dans GenericPortUses::put 
     //   OLD : en fonction de la collocalisation ou non.
     // - OLD :En cas de connection multiples d'un port uses distant vers plusieurs port provides
@@ -456,10 +466,10 @@ namespace CalciumInterface {
     //   OLD : Il faut effectuer une copie dans le port provides.
     //   OLD : Cette copie est effectuée dans GenericPortUses::put 
     //   OLD : en fonction de la collocalisation ou non.
-    Copy2CorbaSpace<IsSameType<T1,InnerType>::value, DataManipulator >::apply(corbaData,data,bufferLength);
+    Copy2CorbaSpace<IsSameType<T1_without_extent,InnerType>::value, DataManipulator >::apply(corbaData,_data,bufferLength);
  
     //TODO : GERER LES EXCEPTIONS ICI : ex le port n'est pas connecté
-    if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
+    if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
       try
       {
         port->put(*corbaData,t, -1); 
@@ -474,7 +484,7 @@ namespace CalciumInterface {
       std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
 #endif
     } 
-    else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
+    else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
       try
       {
         port->put(*corbaData,-1, i);
@@ -504,7 +514,18 @@ namespace CalciumInterface {
 #endif
    
     return;
-  }
+  };
+  
+  template <typename T1> static void
+  ecp_ecriture ( Superv_Component_i & component,
+                int    const  & dependencyType,
+                double const  & t,
+                long   const  & i,
+                const string  & nomVar, 
+                size_t bufferLength,
+                T1 const & data ) {
+    ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data); 
+  };
 
 };
 

diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx
index 4d0ac6aac6833839d499650bc923ec549b25f226..5732b66018e75eda399cbe734aad56ee6e2d8d85 100644 (file)
--- a/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx
+++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumInterface.hxx
@@ -29,7 +29,7 @@
 #ifndef _CALCIUM_INTERFACE_HXX_
 #define _CALCIUM_INTERFACE_HXX_
 
-//Interface C++
+//Interface CALCIUM des utilisateurs en C++ 
 #include "CalciumCxxInterface.hxx"
 
 #include "CalciumException.hxx"
@@ -37,6 +37,9 @@
 
 #include <stdio.h>
 
+//Ce fichier déclare et défini l'interfaçage entre l'API utilisteur C et C++
+//Les procédures déclarées n'ont pas vocation à être utilisées directement (celà est
+// cependant possible).  
 //#define _DEBUG_
 
 #ifdef _DEBUG_
@@ -94,30 +97,28 @@ ecp_fin_ (void * component, int code) {
     double         _tf=*tf;                                            \
     size_t         _nRead=0;                                           \
     size_t         _bufferLength=bufferLength;                         \
-    CalciumTypes::DependencyType _dependencyType=                      \
-      static_cast<CalciumTypes::DependencyType>(dependencyType);       \
                                                                        \
     if ( IsSameType< _name , cplx >::value ) _bufferLength*=2;         \
     DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" ) \
     try {                                                              \
       CalciumInterface::ecp_lecture< _type, _name >( *_component,      \
-                                                    _dependencyType, \
+                                                    dependencyType,    \
                                                     _ti, _tf, *i,      \
                                                     nomvar,            \
                                                     _bufferLength, _nRead, *data); \
     } catch ( const CalciumException & ex) {                           \
       DEBTRACE( ex.what() );                                           \
       return ex.getInfo();                                             \
-    } catch ( ... ) {                          \
-      std::cerr << "Unexpected exception " << std::endl; \
-      return CalciumTypes::CPATAL;                                             \
+    } catch ( ... ) {                                                  \
+      std::cerr << "Unexpected exception " << std::endl;               \
+      return CalciumTypes::CPATAL;                                     \
     }                                                                  \
     if ( IsSameType< _name , cplx >::value ) { *nRead=_nRead/2;                \
       DEBTRACE( "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" ) \
       DEBTRACE( "-------- CalciumInterface(lecture Inter Part) _nRead  : " << _nRead ) \
       DEBTRACE( "-------- CalciumInterface(lecture Inter Part) *nRead  : " << *nRead ) \
     } else *nRead = _nRead;                                            \
-    if (_dependencyType == CalciumTypes::CP_SEQUENTIEL ) \
+    if (dependencyType == CalciumTypes::CP_SEQUENTIEL ) \
         *ti=(CalTimeType< _type _qual >::TimeType)(_ti);                       \
     DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) \
     return CalciumTypes::CPOK;                                         \
@@ -142,10 +143,9 @@ ecp_fin_ (void * component, int code) {
     DEBTRACE( "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" ) \
     try {                                                              \
       /*printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar);*/ \
-      std::string essai(nomvar);                                       \
-      DEBTRACE( "----------->-" << nomvar )            \
+      DEBTRACE( "----------->-" << nomvar )                            \
       CalciumInterface::ecp_ecriture< _type, _name >( *_component,     \
-                                                     static_cast<CalciumTypes::DependencyType>(dependencyType), \
+                                                     dependencyType,   \
                                                      _t,i,nomvar,_bufferLength,*data); \
     } catch ( const CalciumException & ex) {                           \
       std::cerr << ex.what() << std::endl;                             \
@@ -195,7 +195,7 @@ CALCIUM_C2CPP_INTERFACE_(str,char*,);
 //   double         _tf=*tf;                                           
 //   size_t         _nRead=0;                                          
 //   size_t         _bufferLength=bufferLength;                                
-//   CalciumTypes::DependencyType _dependencyType=                     
+//   CalciumTypes::DependencyType dependencyType=                      
 //     static_cast<CalciumTypes::DependencyType>(dependencyType);      
   
 //   // - GERER POINTEUR NULL : NOTHING TODO 
@@ -204,7 +204,7 @@ CALCIUM_C2CPP_INTERFACE_(str,char*,);
 //   DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" ) 
 //     try {                                                           
 //       CalciumInterface::ecp_lecture< char*, char* >( *_component,   
-//                                                  _dependencyType, 
+//                                                  dependencyType, 
 //                                                  _ti, _tf, *i,      
 //                                                  nomvar,            
 //                                                  _bufferLength, _nRead, *data); 
@@ -215,7 +215,7 @@ CALCIUM_C2CPP_INTERFACE_(str,char*,);
     
 //     *nRead = _nRead;                                                
     
-//     if (_dependencyType == CalciumTypes::CP_SEQUENTIEL ) 
+//     if (dependencyType == CalciumTypes::CP_SEQUENTIEL ) 
 //       *ti=(float)(_ti);                     
     
 //     DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) ;

diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx
index ededf2609efeca5012a411ab4ab241a94fa93e14..874345e3af51ddd839d10faa2110a98c18b5ba42 100644 (file)
--- a/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx
+++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumPortTraits.hxx
@@ -32,9 +32,10 @@
 #include "Superv_Component_i.hxx"
 
 // PROVIDES PORT TRAITS
-struct UnknownProvidesPortType {};
+template <class T> struct UnknownProvidesPortType {};
+
 template <class T> struct ProvidesPortTraits {
-  typedef  UnknownProvidesPortType PortType;
+  typedef  UnknownProvidesPortType<T> PortType;
 };
 template <> struct ProvidesPortTraits<int> {
   typedef  calcium_integer_port_provides PortType;
@@ -70,9 +71,9 @@ template < typename T > struct StarTrait< T * > { typedef  T NonStarType; };
 
 
 // USES PORT TRAITS
-struct UnknownUsesPortType {};
+template <class T> struct UnknownUsesPortType {};
 template <class T> struct UsesPortTraits {
-  typedef  UnknownUsesPortType PortType;
+  typedef  UnknownUsesPortType<T> PortType;
 };
 template <> struct UsesPortTraits<int> {
   typedef  calcium_integer_port_uses PortType;

diff --git a/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx b/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx
index a7210e8515277190e43384d154cfefb2060fcf97..0ff10190db393c7a5d416e4d64829e8c2ab546f1 100644 (file)
--- a/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx
+++ b/src/DSC/DSC_User/Datastream/Calcium/Copy2CorbaSpace.hxx
@@ -37,18 +37,21 @@ template <bool zerocopy, typename DataManipulator>
 struct Copy2CorbaSpace  {
 
   template <class T1, class T2>
-  static void apply( T1 * & corbaData, T2 & data, size_t nRead){
+  static void apply( T1 * & corbaData, T2 const & data, size_t nRead){
 
     typedef typename ProvidesPortTraits<T2>::PortType  PortType;
     //typedef typename UsesPortTraits<T2>::PortType      PortType;
-//ESSAI:     typedef typename PortType::DataManipulator         DataManipulator;
+    //ESSAI:     typedef typename PortType::DataManipulator         DataManipulator;
     typedef typename DataManipulator::InnerType        InnerType;
 
 #ifdef _DEBUG_
     std::cerr << "-------- Copy2CorbaSpace<true> MARK 1 ------------------" << std::endl;
 #endif
-    // Crée le type corba à partir du data sans lui en donner la propriété
-    corbaData = DataManipulator::create(nRead,&data,false);
+    // Crée le type corba à partir du data sans lui en donner la propriété.
+    // Le const_cast supprime le caractère const du type T2 const & de data car 
+    // DataManipulator::create n'a pas le caractère const sur son paramètre data pour le
+    // cas de figure où  la propriété de la donnée lui est donnée.
+    corbaData = DataManipulator::create(nRead,const_cast<T2 * > (&data),false);
 #ifdef _DEBUG_
     std::cerr << "-------- Copy2CorbaSpace<true> MARK 2 --(dataPtr : " 
              << DataManipulator::getPointer(corbaData,false)<<")----------------" << std::endl;
@@ -62,7 +65,7 @@ template <typename DataManipulator> struct
 Copy2CorbaSpace<false, DataManipulator>  {
   
   template <class T1, class T2>
-  static void apply( T1 * & corbaData,  T2 & data, size_t nRead){
+  static void apply( T1 * & corbaData,  T2 const & data, size_t nRead){
 
     typedef typename ProvidesPortTraits<T2>::PortType  PortType;
     // typedef typename UsesPortTraits<T2>::PortType     PortType;