src/DSC/DSC_User/Datastream/Calcium/CalciumCxxInterface.hxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 //  File   : CalciumCxxInterface.hxx
  21 //  Author : Eric Fayolle (EDF)
  22 //  Module : KERNEL
  23 // Modified by : $LastChangedBy$
  24 // Date        : $LastChangedDate: 2007-03-01 13:27:58 +0100 (jeu, 01 mar 2007) $
  25 // Id          : $Id$
  26 //
  27 #ifndef _CALCIUM_CXXINTERFACE_HXX_
  28 #define _CALCIUM_CXXINTERFACE_HXX_
  29
  30 #if defined(__CONST_H) || defined(__CALCIUM_H)
  31 #error "The header CalciumCxxInterface.hxx must be included before calcium.h"
  32 #endif
  33
  34 #include <string>
  35 #include <vector>
  36 #include <iostream>
  37 #include "Superv_Component_i.hxx"
  38 #include "CalciumException.hxx"
  39 #include "CalciumTypes.hxx"
  40 #include "CalciumGenericUsesPort.hxx"
  41 #include "Copy2UserSpace.hxx"
  42 #include "Copy2CorbaSpace.hxx"
  43 #include "CalciumPortTraits.hxx"
  44
  45 #include <stdio.h>
  46
  47 #include <typeinfo>
  48
  49 template <typename T1, typename T2>
  50 struct IsSameType {
  51   static const bool value = false;
  52 };
  53 template <typename T1>
  54 struct IsSameType<T1,T1> {
  55   static const bool value = true;
  56 };
  57
  58 extern const char * CPMESSAGE[];
  59
  60 //#define MYDEBUG
  61
  62 #include <boost/type_traits/remove_all_extents.hpp>
  63
  64 namespace CalciumInterface {
  65
  66   /********************* CONNECTION INTERFACE *****************/
  67
  68   static inline void
  69   ecp_cd (Superv_Component_i & component, std::string & instanceName)
  70   {
  71     /* TODO : Trouver le nom de l'instance SALOME*/
  72     CORBA::String_var componentName=component.instanceName();
  73     std::string containerName=component.getContainerName();
  74     if (instanceName.empty()) instanceName=componentName;
  75     Engines_DSC_interface::writeEvent("CP_CD",containerName,componentName,"","","");
  76   }
  77
  78   static inline void
  79   ecp_fin (Superv_Component_i & component, bool provideLastGivenValue)
  80   {
  81     CORBA::String_var componentName=component.instanceName();
  82     std::string containerName=component.getContainerName();
  83     Engines_DSC_interface::writeEvent("CP_FIN",containerName,componentName,"","","");
  84
  85     std::vector<std::string> usesPortNames;
  86     std::vector<std::string>::const_iterator it;
  87     component.get_uses_port_names(usesPortNames);
  88
  89     //Récupérer le type de réel du port est un peu difficile
  90     //car l'interface ne donne aucune indication
  91
  92     //     uses_port *myUsesPort;
  93     calcium_uses_port* myCalciumUsesPort;
  94
  95     for (it=usesPortNames.begin(); it != usesPortNames.end(); ++it)
  96       {
  97         try
  98           {
  99             myCalciumUsesPort= component.Superv_Component_i::get_port< calcium_uses_port >((*it).c_str());
 100
 101 //         component.Superv_Component_i::get_port(myUsesPort,(*it).c_str());
 102 //         calcium_uses_port* myCalciumUsesPort=
 103 //           dynamic_cast<calcium_uses_port*>(myUsesPort);
 104
 105 #ifdef MYDEBUG
 106             std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|"<< *it <<"|----"<<
 107           //          typeid(myUsesPort).name() <<"-------------" <<
 108               typeid(myCalciumUsesPort).name() <<"-------------" << std::endl;
 109 #endif
 110
 111 //         if ( !myCalciumUsesPort )
 112 //           throw Superv_Component_i::BadCast(LOC(OSS()<<"Impossible de convertir le port "
 113 //                                                 << *it << " en port de type calcium_uses_port." ));
 114
 115             myCalciumUsesPort->disconnect(provideLastGivenValue);
 116           }
 117         catch ( const Superv_Component_i::BadCast & ex)
 118           {
 119             Engines_DSC_interface::writeEvent("CP_FIN",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 120             throw (CalciumException(CalciumTypes::CPTPVR,ex));
 121           }
 122         catch ( const DSC_Exception & ex)
 123           {
 124             Engines_DSC_interface::writeEvent("CP_FIN",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPOK],ex.what());
 125             // Exception venant de SupervComponent :
 126             //   PortNotDefined(CPNMVR), PortNotConnected(CPLIEN)
 127             // ou du port uses : Dsc_Exception
 128             // On continue à traiter la deconnexion des autres ports uses
 129           }
 130         catch (...)
 131           {
 132             Engines_DSC_interface::writeEvent("CP_FIN",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPATAL],"Unexpected exception");
 133             throw (CalciumException(CalciumTypes::CPATAL,"Unexpected exception"));
 134             // En fonction du mode de gestion des erreurs throw;
 135           }
 136       }
 137   }
 138
 139
 140   /********************* INTERFACES DE DESALLOCATION  *****************/
 141
 142   // Uniquement appelé par l'utilisateur s'il utilise la 0 copie
 143   //   ( pointeur de données data==NULL à l'appel de ecp_lecture )
 144   // Une désallocation aura lieu uniquement si un buffer intermédiaire
 145   // était necessaire (type utilisateur et corba diffférent)
 146   // La propriété du buffer est rendue à CORBA sinon
 147   template <typename T1, typename T2> static void
 148   ecp_free ( T1 * dataPtr )
 149   {
 150     typedef typename ProvidesPortTraits<T2>::PortType     PortType;
 151     typedef typename PortType::DataManipulator            DataManipulator;
 152     typedef typename DataManipulator::Type                DataType; // Attention != T1
 153     typedef typename DataManipulator::InnerType           InnerType;
 154
 155     DeleteTraits<IsSameType<T1,InnerType>::value, DataManipulator >::apply(dataPtr);
 156   }
 157
 158   template <typename T1> static void
 159   ecp_free ( T1 * dataPtr )
 160   {
 161     ecp_free<T1,T1> ( dataPtr );
 162   }
 163
 164
 165   /********************* READING INTERFACE *****************/
 166
 167
 168   // T1 est le type de données
 169   // T2 est un <nom> de type Calcium permettant de sélectionner le port CORBA correspondant
 170   // T1 et T2 sont dissociés pour discriminer par exemple le cas des nombres complexes
 171   //  -> Les données des nombres complexes sont de type float mais
 172   //     le port à utiliser est le port cplx
 173   template <typename T1, typename T2 > static void
 174   ecp_lecture ( Superv_Component_i & component,
 175                int    const  & dependencyType,
 176                double        & ti,
 177                double const  & tf,
 178                long          & i,
 179                const std::string  & nomVar,
 180                size_t          bufferLength,
 181                size_t        & nRead,
 182                T1            * &data )
 183   {
 184
 185     assert(&component);
 186     CORBA::String_var componentName=component.instanceName();
 187     std::string containerName=component.getContainerName();
 188
 189     typedef typename ProvidesPortTraits<T2>::PortType     PortType;
 190     typedef typename PortType::DataManipulator            DataManipulator;
 191     typedef typename DataManipulator::Type                CorbaDataType; // Attention != T1
 192     typedef typename DataManipulator::InnerType           InnerType;
 193     CalciumTypes::DependencyType _dependencyType=
 194       static_cast<CalciumTypes::DependencyType>(dependencyType);
 195
 196     CorbaDataType     corbaData;
 197
 198 #ifdef MYDEBUG
 199     std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl;
 200 #endif
 201
 202     if (nomVar.empty())
 203       {
 204         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 205         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 206       }
 207     PortType * port;
 208 #ifdef MYDEBUG
 209     std::cout << "-------- CalciumInterface(lecture) MARK 2 --"<<typeid(port).name()<<"----------------" << std::endl;
 210     T1 t1;
 211     T2 t2;
 212     std::cout << "-------- CalciumInterface(lecture) MARK 2b1 -----" << typeid(t1).name() << "-------------" << std::endl;
 213     std::cout << "-------- CalciumInterface(lecture) MARK 2b2 -----" << typeid(t2).name() << "-------------" << std::endl;
 214 #endif
 215
 216     try
 217       {
 218         port  = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
 219 #ifdef MYDEBUG
 220         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 3 ------------------" << std::endl;
 221 #endif
 222       }
 223     catch ( const Superv_Component_i::PortNotDefined & ex)
 224       {
 225         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 226         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 227       }
 228     catch ( const Superv_Component_i::PortNotConnected & ex)
 229       {
 230         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 231         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 232         // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
 233       }
 234     catch ( const Superv_Component_i::BadCast & ex)
 235       {
 236         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 237         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 238       }
 239
 240     // mode == mode du port
 241     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 242
 243     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 244       {
 245         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 246         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 247       }
 248
 249     if ( ( portDependencyType != _dependencyType ) && ( _dependencyType != CalciumTypes::SEQUENCE_DEPENDENCY ) )
 250       {
 251         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 252                    "Dependency mode is not the same as the required one");
 253         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 254                                 << portDependencyType << " is not the same as the required one."));
 255       }
 256
 257
 258     std::stringstream msgout,msg;
 259     if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
 260       {
 261         try
 262           {
 263             double   tt=ti;
 264             msg << "ti=" << ti << ", tf=" << tf ;
 265             Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 266             corbaData = port->get(tt,tf, 0);
 267             msgout << "read t=" << tt ;
 268 #ifdef MYDEBUG
 269             std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
 270 #endif
 271           }
 272         catch ( const DSC_Exception & ex)
 273           {
 274             Engines_DSC_interface::writeEvent("END_READ",containerName,componentName,nomVar.c_str(),"",ex.what());
 275             throw;
 276           }
 277       }
 278     else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY )
 279       {
 280         try
 281           {
 282             msg << "i=" << i ;
 283             Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 284             corbaData = port->get(0, i);
 285             msgout << "read i=" << i ;
 286 #ifdef MYDEBUG
 287             std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
 288 #endif
 289           }
 290         catch ( const DSC_Exception & ex)
 291           {
 292             Engines_DSC_interface::writeEvent("END_READ",containerName,componentName,nomVar.c_str(),"",ex.what());
 293             throw;
 294           }
 295       }
 296     else
 297       {
 298         // Sequential read
 299         try
 300           {
 301 #ifdef MYDEBUG
 302             std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
 303 #endif
 304             Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),"","Sequential read");
 305             corbaData = port->next(ti,i);
 306             msgout << "read ";
 307             if(i==0)msgout<< "t=" <<ti;
 308             else msgout<< "i=" <<i;
 309           }
 310         catch ( const DSC_Exception & ex)
 311           {
 312             Engines_DSC_interface::writeEvent("END_READ",containerName,componentName,nomVar.c_str(),"",ex.what());
 313             throw;
 314           }
 315       }
 316
 317 #ifdef MYDEBUG
 318     std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl;
 319 #endif
 320     size_t corbaDataSize = DataManipulator::size(corbaData);
 321 #ifdef MYDEBUG
 322     std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl;
 323 #endif
 324
 325     // Vérifie si l'utilisateur demande du 0 copie
 326     if ( data == NULL )
 327       {
 328         if ( bufferLength != 0 )
 329           {
 330             MESSAGE("bufferLength devrait valoir 0 pour l'utilisation du mode sans copie (data==NULL)");
 331           }
 332         nRead = corbaDataSize;
 333         // Si les types T1 et InnerType sont différents, il faudra effectuer tout de même une recopie
 334         if (!IsSameType<T1,InnerType>::value) data = new T1[nRead];
 335 #ifdef MYDEBUG
 336         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl;
 337 #endif
 338         // On essaye de faire du 0 copy si les types T1 et InnerType sont les mêmes.
 339         // Copy2UserSpace :
 340         // La raison d'être du foncteur Copy2UserSpace est qu'il n'est pas possible de compiler
 341         // une expression d'affectation sur des types incompatibles ; même
 342         // si cette expression se trouve dans une branche non exécuté d'un test
 343         // portant sur la compatibilité des types.
 344         // En utilisant le foncteur Copy2UserSpace, seule la spécialisation en adéquation
 345         // avec la compatibilité des types sera compilée
 346         Copy2UserSpace< IsSameType<T1,InnerType>::value, DataManipulator >::apply(data,corbaData,nRead);
 347 #ifdef MYDEBUG
 348         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl;
 349 #endif
 350         // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
 351         // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
 352         // DataManipulator::delete_data(corbaData);
 353         // ni DataManipulator::getPointer(corbaData,true); qui détruit la sequence lorsque l'on
 354         // prend la propriété du buffer
 355         //  old : Dans les deux cas la structure CORBA n'est plus utile
 356         //  old : Si !IsSameType<T1,InnerType>::value l'objet CORBA est détruit avec son contenu
 357         //  old : Dans l'autre cas seul la coquille CORBA est détruite
 358         //  L'utilisateur devra appeler ecp_free qui déterminera s'il est necessaire
 359         //  de désallouer un buffer intermédiaire ( types différents) ou de rendre la propriété
 360       }
 361     else
 362       {
 363         nRead = std::min < size_t > (corbaDataSize,bufferLength);
 364 #ifdef MYDEBUG
 365         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl;
 366 #endif
 367         Copy2UserSpace<false, DataManipulator >::apply(data,corbaData,nRead);
 368         //Déjà fait ci-dessus :
 369         //DataManipulator::copy(corbaData,data,nRead);
 370 #ifdef MYDEBUG
 371         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl;
 372 #endif
 373       }
 374 #ifdef MYDEBUG
 375     std::cout << "-------- CalciumInterface(ecp_lecture), Valeur de data : " << std::endl;
 376     std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
 377     std::cout << "Ptr :" << data << std::endl;
 378     std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl;
 379 #endif
 380     Engines_DSC_interface::writeEvent("END_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msgout.str().c_str());
 381     return;
 382   }
 383
 384   // T1 is the data type
 385   template <typename T1 > static void
 386   ecp_lecture ( Superv_Component_i & component,
 387                int    const      & dependencyType,
 388                double            & ti,
 389                double const      & tf,
 390                long              & i,
 391                const std::string & nomVar,
 392                size_t              bufferLength,
 393                size_t            & nRead,
 394                T1                * &data )
 395   {
 396     ecp_lecture<T1,T1> (component,dependencyType,ti,tf,
 397                         i,nomVar,bufferLength,nRead,data);
 398
 399   }
 400
 401   /********************* WRITING INTERFACE *****************/
 402
 403   // T1 : DataType
 404   // T2 : PortType
 405   template <typename T1, typename T2> static void
 406   ecp_ecriture ( Superv_Component_i & component,
 407                  int    const      & dependencyType,
 408                  double const      & t,
 409                  long   const      & i,
 410                  const std::string & nomVar,
 411                  size_t              bufferLength,
 412                  T1                  const  & data )
 413   {
 414
 415     assert(&component);
 416     CORBA::String_var componentName=component.instanceName();
 417     std::string containerName=component.getContainerName();
 418
 419     //typedef typename StarTrait<TT>::NonStarType                    T;
 420     typedef typename boost::remove_all_extents< T1 >::type           T1_without_extent;
 421     typedef typename boost::remove_all_extents< T2 >::type           T2_without_extent;
 422     typedef typename UsesPortTraits    <T2_without_extent>::PortType UsesPortType;
 423     typedef typename ProvidesPortTraits<T2_without_extent>::PortType ProvidesPortType;// pour obtenir un manipulateur de données
 424     typedef typename ProvidesPortType::DataManipulator               DataManipulator;
 425     // Verifier que l'on peut définir UsesPortType::DataManipulator
 426     //    typedef typename PortType::DataManipulator            DataManipulator;
 427     typedef typename DataManipulator::Type                           CorbaDataType; // Attention != T1
 428     typedef typename DataManipulator::InnerType                      InnerType;
 429
 430     T1_without_extent const & _data = data;
 431
 432     CalciumTypes::DependencyType _dependencyType=
 433       static_cast<CalciumTypes::DependencyType>(dependencyType);
 434
 435 #ifdef MYDEBUG
 436     std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
 437 #endif
 438     if ( nomVar.empty() )
 439       {
 440         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 441         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 442       }
 443     UsesPortType * port;
 444 #ifdef MYDEBUG
 445     std::cout << "-------- CalciumInterface(ecriture) MARK 2 ---"<<typeid(port).name()<<"---------------" << std::endl;
 446     T1 t1;
 447     T2 t2;
 448     std::cout << "-------- CalciumInterface(ecriture) MARK 2b1 -----" << typeid(t1).name() << "-------------" << std::endl;
 449     std::cout << "-------- CalciumInterface(ecriture) MARK 2b2 -----" << typeid(t2).name() << "-------------" << std::endl;
 450 #endif
 451
 452     try
 453       {
 454         port  = component.Superv_Component_i::get_port< UsesPortType > (nomVar.c_str());
 455 #ifdef MYDEBUG
 456         std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl;
 457 #endif
 458       }
 459     catch ( const Superv_Component_i::PortNotDefined & ex)
 460       {
 461         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 462         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 463       }
 464     catch ( const Superv_Component_i::PortNotConnected & ex)
 465       {
 466         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 467         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 468         // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
 469       }
 470     catch ( const Superv_Component_i::BadCast & ex)
 471       {
 472         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 473         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 474       }
 475
 476     // mode == mode du port
 477     // On pourrait créer la méthode CORBA dans le mode de Couplage CALCIUM.
 478     // et donc ajouter cette cette méthode uniquement dans l'IDL calcium !
 479
 480 //     CalciumTypes::DependencyType portDependencyType;
 481 //     try {
 482 //       portDependencyType = port->getDependencyType();
 483 //       std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
 484 //     } catch ( const DSC_Exception & ex ) {
 485 //       std::cerr << ex.what() << std::endl;;
 486 //       throw (CalciumException(CalciumTypes::CPIT,ex));
 487 //     }
 488
 489     if ( _dependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 490       {
 491         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 492         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 493       }
 494
 495     if ( _dependencyType == CalciumTypes::SEQUENCE_DEPENDENCY )
 496       {
 497         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 498                    "SEQUENCE_DEPENDENCY mode is not possible when writing");
 499         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode SEQUENCE_DEPENDENCY for variable " << nomVar
 500                                << " is not possible when writing."));
 501       }
 502
 503     // Il faudrait que le port provides génère une exception si le mode donnée n'est pas
 504     // le bon. La seule façon de le faire est d'envoyer -1 en temps si on n'est en itération
 505     // et vice-versa pour informer les provides port du mode dans lequel on est. Sinon il faut
 506     // modifier l'interface IDL pour y ajouter un mode de dépendance !
 507     // ---->
 508 //     if ( portDependencyType != _dependencyType )
 509 //       throw CalciumException(CalciumTypes::CPITVR,
 510 //                                 LOC(OSS()<<"Le mode de dépendance de la variable "
 511 //                                     << nomVar << " ne correspond pas au mode demandé."));
 512
 513
 514     if ( bufferLength < 1 )
 515       {
 516         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNTNULL],"Buffer to send is empty");
 517         throw CalciumException(CalciumTypes::CPNTNULL, LOC(OSS()<<"Buffer to send is empty"));
 518       }
 519
 520     CorbaDataType corbaData;
 521 #ifdef MYDEBUG
 522     std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
 523 #endif
 524
 525     // Si les types Utilisateurs et CORBA sont différents
 526     // il faut effectuer une recopie sinon on utilise directement le
 527     // buffer data pour constituer la séquence
 528     // TODO :
 529     // - Attention en mode asynchrone il faudra eventuellement
 530     //   faire une copie des données même si elles sont de même type.
 531     // - OLD : En cas de collocalisation (du port provide et du port uses)
 532     //   OLD : il est necessaire d'effectuer une recopie du buffer car la
 533     //   OLD : séquence est envoyée au port provide par une référence sur
 534     //   OLD : la séquence locale. Or la méthode put récupère le buffer directement
 535     //   OLD : qui est alors le buffer utilisateur. Il pourrait alors arriver que :
 536     //   OLD :   * Le recepteur efface le buffer emetteur
 537     //   OLD :   * Le port lui-même efface le buffer de l'utilisateur !
 538     //   OLD : Cette copie est effectuée dans GenericPortUses::put
 539     //   OLD : en fonction de la collocalisation ou non.
 540     // - OLD :En cas de connection multiples d'un port uses distant vers plusieurs port provides
 541     //   OLD : collocalisés les ports provides partagent la même copie de la donnée !
 542     //   OLD : Il faut effectuer une copie dans le port provides.
 543     //   OLD : Cette copie est effectuée dans GenericPortUses::put
 544     //   OLD : en fonction de la collocalisation ou non.
 545 #ifdef MYDEBUG
 546     T1_without_extent t1b;
 547     InnerType         t2b;
 548     std::cout << "-------- CalciumInterface(ecriture) MARK 4b1 -----" << typeid(t1b).name() << "-------------" << std::endl;
 549     std::cout << "-------- CalciumInterface(ecriture) MARK 4b2 -----" << typeid(t2b).name() << "-------------" << std::endl;
 550 #endif
 551
 552     Copy2CorbaSpace<IsSameType<T1_without_extent,InnerType>::value, DataManipulator >::apply(corbaData,_data,bufferLength);
 553
 554     //TODO : GERER LES EXCEPTIONS ICI : ex le port n'est pas connecte
 555     if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
 556       {
 557         try
 558           {
 559             port->put(*corbaData,t, -1);
 560             std::stringstream msg;
 561             msg << "t=" << t ;
 562             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msg.str().c_str());
 563           }
 564         catch ( const DSC_Exception & ex)
 565           {
 566             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPATAL],ex.what());
 567             throw (CalciumException(CalciumTypes::CPATAL,ex.what()));
 568           }
 569         //Le -1 peut être traité par le cst DataIdContainer et transformé en 0
 570         //Etre obligé de mettre une étoile ds (*corbadata) va poser des pb pour les types <> seq
 571 #ifdef MYDEBUG
 572         std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
 573 #endif
 574       }
 575     else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY )
 576       {
 577         try
 578           {
 579             port->put(*corbaData,-1, i);
 580             std::stringstream msg;
 581             msg << "i=" << i ;
 582             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msg.str().c_str());
 583           }
 584         catch ( const DSC_Exception & ex)
 585           {
 586             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPATAL],ex.what());
 587             throw (CalciumException(CalciumTypes::CPATAL,ex.what()));
 588           }
 589 #ifdef MYDEBUG
 590         std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl;
 591 #endif
 592       }
 593
 594 #ifdef MYDEBUG
 595     std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl;
 596     for (int i = 0; i < corbaData->length(); ++i)
 597       std::cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << std::endl;
 598 #endif
 599
 600     //    if ( !IsSameType<T1,InnerType>::value ) delete corbaData;
 601     // Supprime l'objet CORBA avec eventuellement les données qu'il contient (cas de la recopie)
 602     delete corbaData;
 603
 604 #ifdef MYDEBUG
 605     std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
 606 #endif
 607
 608     return;
 609   };
 610
 611   template <typename T1> static void
 612   ecp_ecriture ( Superv_Component_i & component,
 613                  int    const  & dependencyType,
 614                  double const  & t,
 615                  long   const  & i,
 616                  const std::string  & nomVar,
 617                  size_t bufferLength,
 618                  T1 const & data )
 619   {
 620     ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data);
 621   };
 622
 623   static inline void
 624   ecp_fini(Superv_Component_i & component,const std::string  & nomVar,long const  & i)
 625   {
 626     CORBA::String_var componentName=component.instanceName();
 627     std::string containerName=component.getContainerName();
 628
 629     if (nomVar.empty())
 630       {
 631         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 632         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 633       }
 634
 635     calcium_provides_port* port;
 636
 637     try
 638       {
 639         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 640       }
 641     catch ( const Superv_Component_i::PortNotDefined & ex)
 642       {
 643         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 644         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 645       }
 646     catch ( const Superv_Component_i::PortNotConnected & ex)
 647       {
 648         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 649         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 650       }
 651     catch ( const Superv_Component_i::BadCast & ex)
 652       {
 653         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 654         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 655       }
 656
 657     // get dependency mode
 658     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 659
 660     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 661       {
 662         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 663         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 664       }
 665
 666     if ( portDependencyType != CalciumTypes::ITERATION_DEPENDENCY )
 667       {
 668         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 669                    "Dependency mode must be iteration mode");
 670         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 671                                 << portDependencyType << " must be iteration mode."));
 672       }
 673
 674     port->calcium_erase(0., i,true);
 675
 676     std::stringstream msg;
 677     msg << "i<=" << i ;
 678     Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 679
 680   };
 681
 682   static inline void
 683   ecp_fint(Superv_Component_i & component,const std::string  & nomVar,double const  & t)
 684   {
 685     CORBA::String_var componentName=component.instanceName();
 686     std::string containerName=component.getContainerName();
 687
 688     if (nomVar.empty())
 689       {
 690         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 691         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 692       }
 693
 694     calcium_provides_port* port;
 695
 696     try
 697       {
 698         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 699       }
 700     catch ( const Superv_Component_i::PortNotDefined & ex)
 701       {
 702         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 703         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 704       }
 705     catch ( const Superv_Component_i::PortNotConnected & ex)
 706       {
 707         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 708         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 709       }
 710     catch ( const Superv_Component_i::BadCast & ex)
 711       {
 712         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 713         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 714       }
 715
 716     // get dependency mode
 717     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 718
 719     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 720       {
 721         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 722         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 723       }
 724
 725     if ( portDependencyType != CalciumTypes::TIME_DEPENDENCY )
 726       {
 727         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 728                    "Dependency mode must be time mode");
 729         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 730                                 << portDependencyType << " must be time mode."));
 731       }
 732
 733     port->calcium_erase(t, 0,true);
 734
 735     std::stringstream msg;
 736     msg << "t<=" << t ;
 737     Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 738
 739   };
 740
 741   static inline void
 742   ecp_effi(Superv_Component_i & component,const std::string  & nomVar,long const  & i)
 743   {
 744     CORBA::String_var componentName=component.instanceName();
 745     std::string containerName=component.getContainerName();
 746
 747     if (nomVar.empty())
 748       {
 749         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 750         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 751       }
 752
 753     calcium_provides_port* port;
 754
 755     try
 756       {
 757         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 758       }
 759     catch ( const Superv_Component_i::PortNotDefined & ex)
 760       {
 761         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 762         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 763       }
 764     catch ( const Superv_Component_i::PortNotConnected & ex)
 765       {
 766         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 767         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 768       }
 769     catch ( const Superv_Component_i::BadCast & ex)
 770       {
 771         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 772         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 773       }
 774
 775     // get dependency mode
 776     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 777
 778     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 779       {
 780         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 781         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 782       }
 783
 784     if ( portDependencyType != CalciumTypes::ITERATION_DEPENDENCY )
 785       {
 786         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 787                    "Dependency mode must be iteration mode");
 788         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 789                                 << portDependencyType << " must be iteration mode."));
 790       }
 791
 792     port->calcium_erase(0., i,false);
 793
 794     std::stringstream msg;
 795     msg << "i>=" << i ;
 796     Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 797
 798   };
 799
 800   static inline void
 801   ecp_efft(Superv_Component_i & component,const std::string  & nomVar,double const  & t)
 802   {
 803     CORBA::String_var componentName=component.instanceName();
 804     std::string containerName=component.getContainerName();
 805
 806     if (nomVar.empty())
 807       {
 808         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 809         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 810       }
 811
 812     calcium_provides_port* port;
 813
 814     try
 815       {
 816         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 817       }
 818     catch ( const Superv_Component_i::PortNotDefined & ex)
 819       {
 820         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 821         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 822       }
 823     catch ( const Superv_Component_i::PortNotConnected & ex)
 824       {
 825         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 826         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 827       }
 828     catch ( const Superv_Component_i::BadCast & ex)
 829       {
 830         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 831         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 832       }
 833
 834     // get dependency mode
 835     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 836
 837     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 838       {
 839         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 840         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 841       }
 842
 843     if ( portDependencyType != CalciumTypes::TIME_DEPENDENCY )
 844       {
 845         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 846                    "Dependency mode must be time mode");
 847         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 848                                 << portDependencyType << " must be time mode."));
 849       }
 850
 851     port->calcium_erase(t, 0,false);
 852
 853     std::stringstream msg;
 854     msg << "t>=" << t ;
 855     Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 856
 857   };
 858
 859 };
 860
 861 #endif