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

   1 // Copyright (C) 2007-2023  CEA, EDF, 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
  61 #include <boost/type_traits/remove_all_extents.hpp>
  62
  63 namespace CalciumInterface {
  64
  65   /********************* CONNECTION INTERFACE *****************/
  66
  67   static inline void
  68   ecp_cd (Superv_Component_i & component, std::string & instanceName)
  69   {
  70     /* TODO : Trouver le nom de l'instance SALOME*/
  71     CORBA::String_var componentName=component.instanceName();
  72     std::string containerName=component.getContainerName();
  73     if (instanceName.empty()) instanceName=componentName;
  74     Engines_DSC_interface::writeEvent("CP_CD",containerName,componentName,"","","");
  75   }
  76
  77   static inline void
  78   ecp_fin (Superv_Component_i & component, bool provideLastGivenValue)
  79   {
  80     CORBA::String_var componentName=component.instanceName();
  81     std::string containerName=component.getContainerName();
  82     Engines_DSC_interface::writeEvent("CP_FIN",containerName,componentName,"","","");
  83
  84     std::vector<std::string> usesPortNames;
  85     std::vector<std::string>::const_iterator it;
  86     component.get_uses_port_names(usesPortNames);
  87
  88     //Récupérer le type de réel du port est un peu difficile
  89     //car l'interface ne donne aucune indication
  90
  91     //     uses_port *myUsesPort;
  92     calcium_uses_port* myCalciumUsesPort;
  93
  94     for (it=usesPortNames.begin(); it != usesPortNames.end(); ++it)
  95       {
  96         try
  97           {
  98             myCalciumUsesPort= component.Superv_Component_i::get_port< calcium_uses_port >((*it).c_str());
  99
 100 //         component.Superv_Component_i::get_port(myUsesPort,(*it).c_str());
 101 //         calcium_uses_port* myCalciumUsesPort=
 102 //           dynamic_cast<calcium_uses_port*>(myUsesPort);
 103
 104           if (SALOME::VerbosityActivated())
 105           {
 106             std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|" << *it << "|----" <<
 107               //typeid(myUsesPort).name() <<"-------------" <<
 108               typeid(myCalciumUsesPort).name() << "-------------" << std::endl;
 109           }
 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     if (SALOME::VerbosityActivated())
 199       std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl;
 200
 201     if (nomVar.empty())
 202       {
 203         Engines_DSC_interface::writeEvent("BEGIN_READ",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 204         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 205       }
 206     PortType * port;
 207
 208     if (SALOME::VerbosityActivated())
 209     {
 210       std::cout << "-------- CalciumInterface(lecture) MARK 2 --"<<typeid(port).name()<<"----------------" << std::endl;
 211       T1 t1;
 212       T2 t2;
 213       std::cout << "-------- CalciumInterface(lecture) MARK 2b1 -----" << typeid(t1).name() << "-------------" << std::endl;
 214       std::cout << "-------- CalciumInterface(lecture) MARK 2b2 -----" << typeid(t2).name() << "-------------" << std::endl;
 215     }
 216
 217     try
 218       {
 219         port  = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
 220         if (SALOME::VerbosityActivated())
 221           std::cout << "-------- CalciumInterface(ecp_lecture) MARK 3 ------------------" << std::endl;
 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
 269             if (SALOME::VerbosityActivated())
 270               std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
 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
 287             if (SALOME::VerbosityActivated())
 288               std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
 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             if (SALOME::VerbosityActivated())
 302               std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
 303
 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     if (SALOME::VerbosityActivated())
 318       std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl;
 319
 320     size_t corbaDataSize = DataManipulator::size(corbaData);
 321
 322     if (SALOME::VerbosityActivated())
 323       std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl;
 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
 336         if (SALOME::VerbosityActivated())
 337           std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl;
 338
 339         // On essaye de faire du 0 copy si les types T1 et InnerType sont les mêmes.
 340         // Copy2UserSpace :
 341         // La raison d'être du foncteur Copy2UserSpace est qu'il n'est pas possible de compiler
 342         // une expression d'affectation sur des types incompatibles ; même
 343         // si cette expression se trouve dans une branche non exécuté d'un test
 344         // portant sur la compatibilité des types.
 345         // En utilisant le foncteur Copy2UserSpace, seule la spécialisation en adéquation
 346         // avec la compatibilité des types sera compilée
 347         Copy2UserSpace< IsSameType<T1,InnerType>::value, DataManipulator >::apply(data,corbaData,nRead);
 348
 349         if (SALOME::VerbosityActivated())
 350           std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl;
 351
 352         // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
 353         // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
 354         // DataManipulator::delete_data(corbaData);
 355         // ni DataManipulator::getPointer(corbaData,true); qui détruit la sequence lorsque l'on
 356         // prend la propriété du buffer
 357         //  old : Dans les deux cas la structure CORBA n'est plus utile
 358         //  old : Si !IsSameType<T1,InnerType>::value l'objet CORBA est détruit avec son contenu
 359         //  old : Dans l'autre cas seul la coquille CORBA est détruite
 360         //  L'utilisateur devra appeler ecp_free qui déterminera s'il est necessaire
 361         //  de désallouer un buffer intermédiaire ( types différents) ou de rendre la propriété
 362       }
 363     else
 364     {
 365       nRead = std::min < size_t > (corbaDataSize,bufferLength);
 366
 367       if (SALOME::VerbosityActivated())
 368         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl;
 369
 370       Copy2UserSpace<false, DataManipulator >::apply(data,corbaData,nRead);
 371       //Déjà fait ci-dessus :
 372       //DataManipulator::copy(corbaData,data,nRead);
 373
 374       if (SALOME::VerbosityActivated())
 375         std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl;
 376     }
 377
 378     if (SALOME::VerbosityActivated())
 379     {
 380       std::cout << "-------- CalciumInterface(ecp_lecture), Valeur de data : " << std::endl;
 381       std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
 382       std::cout << "Ptr :" << data << std::endl;
 383       std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl;
 384     }
 385
 386     Engines_DSC_interface::writeEvent("END_READ",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msgout.str().c_str());
 387     return;
 388   }
 389
 390   // T1 is the data type
 391   template <typename T1 > static void
 392   ecp_lecture ( Superv_Component_i & component,
 393                int    const      & dependencyType,
 394                double            & ti,
 395                double const      & tf,
 396                long              & i,
 397                const std::string & nomVar,
 398                size_t              bufferLength,
 399                size_t            & nRead,
 400                T1                * &data )
 401   {
 402     ecp_lecture<T1,T1> (component,dependencyType,ti,tf,
 403                         i,nomVar,bufferLength,nRead,data);
 404
 405   }
 406
 407   /********************* WRITING INTERFACE *****************/
 408
 409   // T1 : DataType
 410   // T2 : PortType
 411   template <typename T1, typename T2> static void
 412   ecp_ecriture ( Superv_Component_i & component,
 413                  int    const      & dependencyType,
 414                  double const      & t,
 415                  long   const      & i,
 416                  const std::string & nomVar,
 417                  size_t              bufferLength,
 418                  T1                  const  & data )
 419   {
 420
 421     assert(&component);
 422     CORBA::String_var componentName=component.instanceName();
 423     std::string containerName=component.getContainerName();
 424
 425     //typedef typename StarTrait<TT>::NonStarType                    T;
 426     typedef typename boost::remove_all_extents< T1 >::type           T1_without_extent;
 427     typedef typename boost::remove_all_extents< T2 >::type           T2_without_extent;
 428     typedef typename UsesPortTraits    <T2_without_extent>::PortType UsesPortType;
 429     typedef typename ProvidesPortTraits<T2_without_extent>::PortType ProvidesPortType;// pour obtenir un manipulateur de données
 430     typedef typename ProvidesPortType::DataManipulator               DataManipulator;
 431     // Verifier que l'on peut définir UsesPortType::DataManipulator
 432     //    typedef typename PortType::DataManipulator            DataManipulator;
 433     typedef typename DataManipulator::Type                           CorbaDataType; // Attention != T1
 434     typedef typename DataManipulator::InnerType                      InnerType;
 435
 436     T1_without_extent const & _data = data;
 437
 438     CalciumTypes::DependencyType _dependencyType=
 439       static_cast<CalciumTypes::DependencyType>(dependencyType);
 440
 441     if (SALOME::VerbosityActivated())
 442       std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
 443
 444     if ( nomVar.empty() )
 445       {
 446         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 447         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 448       }
 449     UsesPortType * port;
 450
 451     if (SALOME::VerbosityActivated())
 452     {
 453       std::cout << "-------- CalciumInterface(ecriture) MARK 2 ---"<<typeid(port).name()<<"---------------" << std::endl;
 454       T1 t1;
 455       T2 t2;
 456       std::cout << "-------- CalciumInterface(ecriture) MARK 2b1 -----" << typeid(t1).name() << "-------------" << std::endl;
 457       std::cout << "-------- CalciumInterface(ecriture) MARK 2b2 -----" << typeid(t2).name() << "-------------" << std::endl;
 458     }
 459
 460     try
 461       {
 462         port  = component.Superv_Component_i::get_port< UsesPortType > (nomVar.c_str());
 463
 464         if (SALOME::VerbosityActivated())
 465           std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl;
 466       }
 467     catch ( const Superv_Component_i::PortNotDefined & ex)
 468       {
 469         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 470         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 471       }
 472     catch ( const Superv_Component_i::PortNotConnected & ex)
 473       {
 474         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 475         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 476         // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
 477       }
 478     catch ( const Superv_Component_i::BadCast & ex)
 479       {
 480         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 481         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 482       }
 483
 484     // mode == mode du port
 485     // On pourrait créer la méthode CORBA dans le mode de Couplage CALCIUM.
 486     // et donc ajouter cette cette méthode uniquement dans l'IDL calcium !
 487
 488 //     CalciumTypes::DependencyType portDependencyType;
 489 //     try {
 490 //       portDependencyType = port->getDependencyType();
 491 //       std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
 492 //     } catch ( const DSC_Exception & ex ) {
 493 //       std::cerr << ex.what() << std::endl;;
 494 //       throw (CalciumException(CalciumTypes::CPIT,ex));
 495 //     }
 496
 497     if ( _dependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 498       {
 499         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 500         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 501       }
 502
 503     if ( _dependencyType == CalciumTypes::SEQUENCE_DEPENDENCY )
 504       {
 505         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 506                    "SEQUENCE_DEPENDENCY mode is not possible when writing");
 507         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode SEQUENCE_DEPENDENCY for variable " << nomVar
 508                                << " is not possible when writing."));
 509       }
 510
 511     // Il faudrait que le port provides génère une exception si le mode donnée n'est pas
 512     // le bon. La seule façon de le faire est d'envoyer -1 en temps si on n'est en itération
 513     // et vice-versa pour informer les provides port du mode dans lequel on est. Sinon il faut
 514     // modifier l'interface IDL pour y ajouter un mode de dépendance !
 515     // ---->
 516 //     if ( portDependencyType != _dependencyType )
 517 //       throw CalciumException(CalciumTypes::CPITVR,
 518 //                                 LOC(OSS()<<"Le mode de dépendance de la variable "
 519 //                                     << nomVar << " ne correspond pas au mode demandé."));
 520
 521
 522     if ( bufferLength < 1 )
 523       {
 524         Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNTNULL],"Buffer to send is empty");
 525         throw CalciumException(CalciumTypes::CPNTNULL, LOC(OSS()<<"Buffer to send is empty"));
 526       }
 527
 528     CorbaDataType corbaData;
 529
 530     if (SALOME::VerbosityActivated())
 531       std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
 532
 533     // Si les types Utilisateurs et CORBA sont différents
 534     // il faut effectuer une recopie sinon on utilise directement le
 535     // buffer data pour constituer la séquence
 536     // TODO :
 537     // - Attention en mode asynchrone il faudra eventuellement
 538     //   faire une copie des données même si elles sont de même type.
 539     // - OLD : En cas de collocalisation (du port provide et du port uses)
 540     //   OLD : il est necessaire d'effectuer une recopie du buffer car la
 541     //   OLD : séquence est envoyée au port provide par une référence sur
 542     //   OLD : la séquence locale. Or la méthode put récupère le buffer directement
 543     //   OLD : qui est alors le buffer utilisateur. Il pourrait alors arriver que :
 544     //   OLD :   * Le recepteur efface le buffer emetteur
 545     //   OLD :   * Le port lui-même efface le buffer de l'utilisateur !
 546     //   OLD : Cette copie est effectuée dans GenericPortUses::put
 547     //   OLD : en fonction de la collocalisation ou non.
 548     // - OLD :En cas de connection multiples d'un port uses distant vers plusieurs port provides
 549     //   OLD : collocalisés les ports provides partagent la même copie de la donnée !
 550     //   OLD : Il faut effectuer une copie dans le port provides.
 551     //   OLD : Cette copie est effectuée dans GenericPortUses::put
 552     //   OLD : en fonction de la collocalisation ou non.
 553     if (SALOME::VerbosityActivated())
 554     {
 555       T1_without_extent t1b;
 556       InnerType         t2b;
 557       std::cout << "-------- CalciumInterface(ecriture) MARK 4b1 -----" << typeid(t1b).name() << "-------------" << std::endl;
 558       std::cout << "-------- CalciumInterface(ecriture) MARK 4b2 -----" << typeid(t2b).name() << "-------------" << std::endl;
 559     }
 560
 561     Copy2CorbaSpace<IsSameType<T1_without_extent,InnerType>::value, DataManipulator >::apply(corbaData,_data,bufferLength);
 562
 563     //TODO : GERER LES EXCEPTIONS ICI : ex le port n'est pas connecte
 564     if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
 565       {
 566         try
 567           {
 568             port->put(*corbaData,t, -1);
 569             std::stringstream msg;
 570             msg << "t=" << t ;
 571             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msg.str().c_str());
 572           }
 573         catch ( const DSC_Exception & ex)
 574           {
 575             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPATAL],ex.what());
 576             throw (CalciumException(CalciumTypes::CPATAL,ex.what()));
 577           }
 578         //Le -1 peut être traité par le cst DataIdContainer et transformé en 0
 579         //Etre obligé de mettre une étoile ds (*corbadata) va poser des pb pour les types <> seq
 580         if (SALOME::VerbosityActivated())
 581           std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
 582       }
 583     else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY )
 584       {
 585         try
 586           {
 587             port->put(*corbaData,-1, i);
 588             std::stringstream msg;
 589             msg << "i=" << i ;
 590             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPOK],msg.str().c_str());
 591           }
 592         catch ( const DSC_Exception & ex)
 593           {
 594             Engines_DSC_interface::writeEvent("WRITE",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPATAL],ex.what());
 595             throw (CalciumException(CalciumTypes::CPATAL,ex.what()));
 596           }
 597
 598         if (SALOME::VerbosityActivated())
 599           std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl;
 600       }
 601
 602     if (SALOME::VerbosityActivated())
 603     {
 604       std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl;
 605       for (int i = 0; i < corbaData->length(); ++i)
 606         std::cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << std::endl;
 607     }
 608
 609     //    if ( !IsSameType<T1,InnerType>::value ) delete corbaData;
 610     // Supprime l'objet CORBA avec eventuellement les données qu'il contient (cas de la recopie)
 611     delete corbaData;
 612
 613     if (SALOME::VerbosityActivated())
 614       std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
 615
 616     return;
 617   }
 618
 619   template <typename T1> static void
 620   ecp_ecriture ( Superv_Component_i & component,
 621                  int    const  & dependencyType,
 622                  double const  & t,
 623                  long   const  & i,
 624                  const std::string  & nomVar,
 625                  size_t bufferLength,
 626                  T1 const & data )
 627   {
 628     ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data);
 629   }
 630
 631   static inline void
 632   ecp_fini(Superv_Component_i & component,const std::string  & nomVar,long const  & i)
 633   {
 634     CORBA::String_var componentName=component.instanceName();
 635     std::string containerName=component.getContainerName();
 636
 637     if (nomVar.empty())
 638       {
 639         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 640         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 641       }
 642
 643     calcium_provides_port* port;
 644
 645     try
 646       {
 647         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 648       }
 649     catch ( const Superv_Component_i::PortNotDefined & ex)
 650       {
 651         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 652         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 653       }
 654     catch ( const Superv_Component_i::PortNotConnected & ex)
 655       {
 656         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 657         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 658       }
 659     catch ( const Superv_Component_i::BadCast & ex)
 660       {
 661         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 662         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 663       }
 664
 665     // get dependency mode
 666     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 667
 668     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 669       {
 670         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 671         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 672       }
 673
 674     if ( portDependencyType != CalciumTypes::ITERATION_DEPENDENCY )
 675       {
 676         Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 677                    "Dependency mode must be iteration mode");
 678         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 679                                 << portDependencyType << " must be iteration mode."));
 680       }
 681
 682     port->calcium_erase(0., i,true);
 683
 684     std::stringstream msg;
 685     msg << "i<=" << i ;
 686     Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 687
 688   }
 689
 690   static inline void
 691   ecp_fint(Superv_Component_i & component,const std::string  & nomVar,double const  & t)
 692   {
 693     CORBA::String_var componentName=component.instanceName();
 694     std::string containerName=component.getContainerName();
 695
 696     if (nomVar.empty())
 697       {
 698         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 699         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 700       }
 701
 702     calcium_provides_port* port;
 703
 704     try
 705       {
 706         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 707       }
 708     catch ( const Superv_Component_i::PortNotDefined & ex)
 709       {
 710         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 711         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 712       }
 713     catch ( const Superv_Component_i::PortNotConnected & ex)
 714       {
 715         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 716         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 717       }
 718     catch ( const Superv_Component_i::BadCast & ex)
 719       {
 720         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 721         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 722       }
 723
 724     // get dependency mode
 725     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 726
 727     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 728       {
 729         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 730         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 731       }
 732
 733     if ( portDependencyType != CalciumTypes::TIME_DEPENDENCY )
 734       {
 735         Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 736                    "Dependency mode must be time mode");
 737         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 738                                 << portDependencyType << " must be time mode."));
 739       }
 740
 741     port->calcium_erase(t, 0,true);
 742
 743     std::stringstream msg;
 744     msg << "t<=" << t ;
 745     Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 746
 747   }
 748
 749   static inline void
 750   ecp_effi(Superv_Component_i & component,const std::string  & nomVar,long const  & i)
 751   {
 752     CORBA::String_var componentName=component.instanceName();
 753     std::string containerName=component.getContainerName();
 754
 755     if (nomVar.empty())
 756       {
 757         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 758         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 759       }
 760
 761     calcium_provides_port* port;
 762
 763     try
 764       {
 765         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 766       }
 767     catch ( const Superv_Component_i::PortNotDefined & ex)
 768       {
 769         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 770         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 771       }
 772     catch ( const Superv_Component_i::PortNotConnected & ex)
 773       {
 774         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 775         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 776       }
 777     catch ( const Superv_Component_i::BadCast & ex)
 778       {
 779         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 780         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 781       }
 782
 783     // get dependency mode
 784     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 785
 786     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 787       {
 788         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 789         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 790       }
 791
 792     if ( portDependencyType != CalciumTypes::ITERATION_DEPENDENCY )
 793       {
 794         Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 795                    "Dependency mode must be iteration mode");
 796         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 797                                 << portDependencyType << " must be iteration mode."));
 798       }
 799
 800     port->calcium_erase(0., i,false);
 801
 802     std::stringstream msg;
 803     msg << "i>=" << i ;
 804     Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 805
 806   }
 807
 808   static inline void
 809   ecp_efft(Superv_Component_i & component,const std::string  & nomVar,double const  & t)
 810   {
 811     CORBA::String_var componentName=component.instanceName();
 812     std::string containerName=component.getContainerName();
 813
 814     if (nomVar.empty())
 815       {
 816         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
 817         throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
 818       }
 819
 820     calcium_provides_port* port;
 821
 822     try
 823       {
 824         port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
 825       }
 826     catch ( const Superv_Component_i::PortNotDefined & ex)
 827       {
 828         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
 829         throw (CalciumException(CalciumTypes::CPNMVR,ex));
 830       }
 831     catch ( const Superv_Component_i::PortNotConnected & ex)
 832       {
 833         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
 834         throw (CalciumException(CalciumTypes::CPLIEN,ex));
 835       }
 836     catch ( const Superv_Component_i::BadCast & ex)
 837       {
 838         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
 839         throw (CalciumException(CalciumTypes::CPTPVR,ex));
 840       }
 841
 842     // get dependency mode
 843     CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
 844
 845     if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
 846       {
 847         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
 848         throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
 849       }
 850
 851     if ( portDependencyType != CalciumTypes::TIME_DEPENDENCY )
 852       {
 853         Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
 854                    "Dependency mode must be time mode");
 855         throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
 856                                 << portDependencyType << " must be time mode."));
 857       }
 858
 859     port->calcium_erase(t, 0,false);
 860
 861     std::stringstream msg;
 862     msg << "t>=" << t ;
 863     Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
 864
 865   }
 866
 867 }
 868
 869 #endif