Version: 8.3.0
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
CalciumCxxInterface.hxx
1 // Copyright (C) 2007-2016 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