Version: 8.3.0
CalciumCouplingPolicy.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 
23 // File : CalciumCouplingPolicy.hxx
24 // Author : Eric Fayolle (EDF)
25 // Module : KERNEL
26 // Id : $Id$
27 //
28 #ifndef __CALCIUM_COUPLING_POLICY__
29 #define __CALCIUM_COUPLING_POLICY__
30 
31 #include <vector>
32 #include <map>
33 
34 #include "DisplayPair.hxx"
35 #include "CouplingPolicy.hxx"
36 #include "AdjacentFunctor.hxx"
37 #include <boost/lambda/lambda.hpp>
38 #include <boost/utility/enable_if.hpp>
39 #include <boost/type_traits/is_arithmetic.hpp>
40 #include "CalciumTypes.hxx"
41 #include "CalciumException.hxx"
42 
43 //#define MYDEBUG
44 
45 class CalciumCouplingPolicy : public CouplingPolicy {
46 
47 
48 public:
49 
50  template <typename T_TIME, typename T_TAG > class InternalDataIdContainer;
51  template <typename T_TIME, typename T_TAG > friend class InternalDataIdContainer;
52  template <typename DataManipulator,
53  class EnableIf > friend class BoundedDataIdProcessor;
54  template <typename DataManipulator > friend class EraseDataIdProcessor;
55  template <typename DataManipulator > friend class EraseDataIdBeforeOrAfterTagProcessor;
56  template <typename DataManipulator > friend class DisconnectProcessor;
57 
58  typedef CalciumTypes::DependencyType DependencyType;
59  typedef CalciumTypes::DateCalSchem DateCalSchem;
60  typedef CalciumTypes::InterpolationSchem InterpolationSchem;
61  typedef CalciumTypes::ExtrapolationSchem ExtrapolationSchem;
62  typedef CalciumTypes::DisconnectDirective DisconnectDirective;
63 
64 private:
65 
66  DependencyType _dependencyType;
67  size_t _storageLevel;
68  DateCalSchem _dateCalSchem;
69  InterpolationSchem _interpolationSchem;
70  ExtrapolationSchem _extrapolationSchem;
71  double _alpha;
72  double _deltaT;
73  DisconnectDirective _disconnectDirective;
74 
75 public:
76  CalciumCouplingPolicy();
77 
78  void setDependencyType (DependencyType dependencyType);
79  DependencyType getDependencyType () const;
80 
81  void setStorageLevel (size_t storageLevel);
82  size_t getStorageLevel () const;
83 
84  void setDateCalSchem (DateCalSchem dateCalSchem);
85  DateCalSchem getDateCalSchem () const;
86 
87  void setAlpha(double alpha);
88  double getAlpha() const ;
89 
90  void setDeltaT(double deltaT );
91  double getDeltaT() const ;
92 
93  void setInterpolationSchem (InterpolationSchem interpolationSchem);
94  void setExtrapolationSchem (ExtrapolationSchem extrapolationSchem);
95  InterpolationSchem getInterpolationSchem () const ;
96  ExtrapolationSchem getExtrapolationSchem () const ;
97 
98  // Classe DataId rassemblant les paramètres de la méthode PORT::put
99  // qui identifient l'instance d'une donnée pour Calcium
100  // Rem : Le DataId doit pouvoir être une key dans une map stl
101  typedef double TimeType;
102  typedef long TagType;
103  typedef std::pair< TimeType , TagType > DataId;
104  typedef InternalDataIdContainer < TimeType , TagType > DataIdContainer;
105  typedef std::vector< DataId >::iterator iterator;
106 
107  template <typename T_TIME, typename T_TAG >
108  struct InternalDataIdContainer;
109 
110  inline TimeType getTime(const DataId &dataId) const { return dataId.first;}
111  inline TagType getTag (const DataId &dataId) const { return dataId.second;}
112 
113  template <typename DataManipulator,
114  class EnableIf = void > struct BoundedDataIdProcessor;
115  //template <typename DataManipulator> struct BoundedDataIdProcessor;
116  template <typename DataManipulator> struct EraseDataIdProcessor;
117  template <typename DataManipulator> struct EraseDataIdBeforeOrAfterTagProcessor;
118  template <typename DataManipulator> struct DisconnectProcessor;
119 
120  // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
121  // - l'itérateur wDataIt1 pointe alors sur ce dataId
122  // Renvoie isBounded si le dataId attendu n'est pas trouvé mais encadrable et
123  // que la politique de couplage gére ce cas de figure
124  // - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
125  // Le container doit être associatif
126  template < typename AssocContainer >
127  bool isDataIdConveniant( AssocContainer & storedDatas,
128  const typename AssocContainer::key_type & expectedDataId,
129  bool & isEqual, bool & isBounded,
130  typename AssocContainer::iterator & wDataIt1) const;
131 
132  TimeType getEffectiveTime(TimeType ti, TimeType tf);
133 
134  void disconnect(bool provideLastGivenValue);
135 
136 }; //Fin de CalciumCouplingPolicy
137 
138 
139 
140 //************* DEFINITION DES METHODES ET OBJETS TEMPLATES *************//
141 
142 
143 
144 // Définition du container de DataId pour répondre au concept
145 // de mode de couplage
146 template <typename T_TIME, typename T_TAG >
147 struct CalciumCouplingPolicy::InternalDataIdContainer : public std::vector< std::pair< T_TIME,T_TAG> > {
148  typedef std::vector < DataId > DataIdVect;
149 
150  InternalDataIdContainer(const DataId & dataId,
151  const CalciumCouplingPolicy & policy
152  ):std::vector< std::pair< T_TIME,T_TAG> >() {
153  // Ignore les paramètres qui ne sont pas en rapport avec le type de dépendance
154  switch (policy._dependencyType) {
155  case CalciumTypes::TIME_DEPENDENCY:
156  this->push_back(DataId(dataId.first,0));
157  break;
158  case CalciumTypes::ITERATION_DEPENDENCY:
159  this->push_back(DataId(0,dataId.second));
160  break;
161  default:
162  throw(CalciumException(CalciumTypes::CPIT,LOC("The dependency type must be set by setDependencyType before calling DataIdContainer contructor")));
163  break;
164  }
165  };
166 };
167 
168 
169 template <typename DataManipulator, class EnableIf >
170 struct CalciumCouplingPolicy::BoundedDataIdProcessor{
171  BoundedDataIdProcessor(const CouplingPolicy & couplingPolicy) {};
172  template < typename Iterator, typename DataId >
173  void inline apply(typename iterator_t<Iterator>::value_type & data,
174  const DataId & dataId,
175  const Iterator & it1) const {
176  typedef typename iterator_t<Iterator>::value_type value_type;
177 #ifdef MYDEBUG
178  std::cout << "-------- Calcium Generic BoundedDataIdProcessor.apply() called " << std::endl;
179 #endif
180 
181  }
182 };
183 
184 
185 template <typename DataManipulator >
186 struct CalciumCouplingPolicy::BoundedDataIdProcessor<
187  DataManipulator,
188  typename boost::enable_if< boost::is_float< typename DataManipulator::InnerType> >::type > {
189 
190  const CalciumCouplingPolicy & _couplingPolicy;
191 
192  BoundedDataIdProcessor(const CalciumCouplingPolicy &couplingPolicy):
193  _couplingPolicy(couplingPolicy) {};
194 
195  // Méthode implémentant l'interpolation temporelle
196  template < typename MapIterator >
197  void inline apply (typename iterator_t<MapIterator>::value_type & data,
198  const DataId & dataId, const MapIterator & it1) const {
199 
200  typedef typename iterator_t<MapIterator>::value_type value_type;
201  typedef typename DataManipulator::InnerType InnerType;
202  typedef typename DataManipulator::Type Type;
203 
204  MapIterator it2=it1; ++it2;
205  size_t dataSize1 = DataManipulator::size(it1->second);
206 #ifdef MYDEBUG
207  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId1 : " << dataSize1 << std::endl;
208 #endif
209 
210  // Gérer dans calcium la limite de la taille du buffer donnée par
211  // l'utilisateur.
212  size_t dataSize2 = DataManipulator::size(it2->second);
213 #ifdef MYDEBUG
214  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId2 : " << dataSize2 << std::endl;
215 #endif
216 
217  size_t dataSize = std::min< size_t >( dataSize1, dataSize2 );
218  DataId dataId2 = it2->first;
219  DataId dataId1 = it1->first;
220  TimeType t2 = dataId2.first;
221  TimeType t1 = dataId1.first;
222 #ifdef MYDEBUG
223  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t1 : " << t1 << std::endl;
224  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t2 : " << t2 << std::endl;
225 #endif
226  TimeType t = dataId.first;
227 #ifdef MYDEBUG
228  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t : " << t << std::endl;
229 #endif
230  TimeType timeDiff = t2-t1;
231 #ifdef MYDEBUG
232  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de timeDiff : " << timeDiff << std::endl;
233 #endif
234  TimeType coeff = (t2-t)/timeDiff;
235 #ifdef MYDEBUG
236  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de coeff : " << coeff << std::endl;
237 #endif
238 
239  InnerType const * const InIt1 = DataManipulator::getPointer(it1->second);
240 #ifdef MYDEBUG
241  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t1 : " << std::endl;
242  std::copy(InIt1,InIt1+dataSize1,std::ostream_iterator<InnerType>(std::cout," "));
243  std::cout << std::endl;
244 #endif
245  InnerType const * const InIt2 = DataManipulator::getPointer(it2->second);
246 #ifdef MYDEBUG
247  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t2 : " << std::endl;
248  std::copy(InIt2,InIt2+dataSize2,std::ostream_iterator<InnerType>(std::cout," "));
249  std::cout << std::endl;
250 #endif
251  Type dataOut = DataManipulator::create(dataSize);
252  InnerType * const OutIt = DataManipulator::getPointer(dataOut);
253 
254 #ifdef MYDEBUG
255  std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : interpolationSchem : " << _couplingPolicy._interpolationSchem << std::endl;
256  std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : alpha : " << _couplingPolicy._alpha << std::endl;
257  std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : datecalschem : " << _couplingPolicy._dateCalSchem << std::endl;
258  std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : storageLevel : " << _couplingPolicy._storageLevel << std::endl;
259 #endif
260  if ( timeDiff == 0.0 || _couplingPolicy._interpolationSchem == CalciumTypes::L0_SCHEM ) {
261  std::copy(InIt1,InIt1+dataSize,OutIt);
262  } else {
263 
264  boost::lambda::placeholder1_type _1;
265  boost::lambda::placeholder2_type _2;
266  // OLD: REM : Pour des buffers de type int
267  // OLD: le compilo indiquera warning: converting to `long int' from `Double'
268  std::transform(InIt1,InIt1+dataSize,InIt2,OutIt,
269  ( _1 - _2 ) * coeff + _2 );
270 // for(size_t i =0; i < dataSize3; ++i) {
271 // OutIt[i]=(InIt1[i] - InIt2[i]) * coeff + InIt2[i];
272 // }
273 
274  }
275 #ifdef MYDEBUG
276  std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données calculées à t : " << std::endl;
277  std::copy(OutIt,OutIt+dataSize,std::ostream_iterator<InnerType>(std::cout," "));
278  std::cout << std::endl;
279 #endif
280  data = dataOut;
281 
282  }
283 };
284 
285 // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
286 // - l'itérateur wDataIt1 pointe alors sur ce dataId
287 // Renvoie isBounded si le dataId attendu n'est pas trouvé mais encadrable et
288 // que la politique de couplage gére ce cas de figure
289 // - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
290 // Le container doit être associatif
291 template < typename AssocContainer >
292 bool CalciumCouplingPolicy::isDataIdConveniant( AssocContainer & storedDatas, const typename AssocContainer::key_type & expectedDataId,
293  bool & isEqual, bool & isBounded, typename AssocContainer::iterator & wDataIt1) const {
294 
295  // Rem : le type key_type == DataId
296  typedef typename AssocContainer::key_type key_type;
297  AdjacentFunctor< key_type > af(expectedDataId);
298  if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
299  {
300 #ifdef MYDEBUG
301  std::cout << "-------- time expected : " << expectedDataId.first << std::endl;
302  std::cout << "-------- time expected corrected : " << expectedDataId.first*(1.0-_deltaT) << std::endl;
303 #endif
304  af.setMaxValue(key_type(expectedDataId.first*(1.0-_deltaT),0));
305  }
306  isBounded = false;
307 
308  // Rem 1 :
309  // L'algo adjacent_find ne peut être utilisé avec l'AdjacentPredicate
310  // - si la table contient un seul élément l'algorithme adjacent_find retourne end()
311  // que se soit l'élément attendu ou non
312  // - si la table contient deux éléments dont le dernier est celui recherché
313  // l'algorithme adjacent_find retourne end() aussi
314  // d'ou la necessité d'effectuer un find avant ou d'écrire un algorithme ad hoc
315 
316  // Rem 2 :
317  //
318  // L'algo find_if ne peut être utilisé car il recopie l'AdjacentFunctor
319  // qui ne peut alors pas mémoriser ses états précédents
320  //
321 
322  // Un codage en reverse serait plus efficace
323  typename AssocContainer::iterator prev = storedDatas.begin();
324  typename AssocContainer::iterator current = prev;
325  while ( (current != storedDatas.end()) && !af(current->first) )
326  {
327 #ifdef MYDEBUG
328  std::cerr << "------- stored time : " << current->first << std::endl;
329 #endif
330  // if ( af(current->first) ) break;
331  prev = current++;
332  }
333 
334  isEqual = af.isEqual();
335 
336  // On considère qu'il n'est pas possible d'encadrer en dépendance itérative,
337  // on se veut pas calculer d'interpolation.
338  if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY) isBounded = af.isBounded();
339 
340  if ( isEqual ) wDataIt1 = current;
341  else
342  if (isBounded) wDataIt1 = prev;
343  else
344  wDataIt1 = storedDatas.end();
345 
346 #ifdef MYDEBUG
347  std::cout << "-------- isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
348 #endif
349 
350  return isEqual || isBounded;
351 }
352 
353 //Remove DataId before or after a given time or tag
354 template < typename DataManipulator >
355 struct CalciumCouplingPolicy::EraseDataIdBeforeOrAfterTagProcessor
356 {
357  CalciumCouplingPolicy &_couplingPolicy;
358 
359  EraseDataIdBeforeOrAfterTagProcessor(CalciumCouplingPolicy &couplingPolicy):
360  _couplingPolicy(couplingPolicy) {};
361 
362  template < typename Container,typename TimeType,typename TagType >
363  void apply(Container & storedDatas, TimeType time, TagType tag, bool before) const
364  {
365  typedef typename Container::iterator iterator;
366  typedef typename Container::reverse_iterator riterator;
367 
368  if(_couplingPolicy._dependencyType == CalciumTypes::TIME_DEPENDENCY)
369  {
370  if(before)
371  {
372  iterator it=storedDatas.begin();
373  while(it != storedDatas.end() && it->first.first <= time)
374  {
375  DataManipulator::delete_data(it->second);
376  storedDatas.erase(it);
377  it=storedDatas.begin();
378  }
379  }
380  else
381  {
382  riterator it=storedDatas.rbegin();
383  while(it != storedDatas.rend() && it->first.first >= time)
384  {
385  DataManipulator::delete_data(it->second);
386  storedDatas.erase(it->first);
387  it=storedDatas.rbegin();
388  }
389  }
390  }
391  else
392  {
393  if(before)
394  {
395  iterator it=storedDatas.begin();
396  while(it != storedDatas.end() && it->first.second <= tag)
397  {
398  DataManipulator::delete_data(it->second);
399  storedDatas.erase(it);
400  it=storedDatas.begin();
401  }
402  }
403  else
404  {
405  riterator it=storedDatas.rbegin();
406  while(it != storedDatas.rend() && it->first.second >= tag)
407  {
408  DataManipulator::delete_data(it->second);
409  storedDatas.erase(it->first);
410  it=storedDatas.rbegin();
411  }
412  }
413  }
414  }
415 };
416 
417 // TODO :PAS ENCORE TESTE AVEC UN NIVEAU POSITIONNE
418 // Supprime les DataId et les données associées
419 // du container associatif quand le nombre
420 // de données stockées dépasse le niveau CALCIUM.
421 // Cette méthode est appelée de GenericPort::get et GenericPort::next
422 // TODO : Elle devrait également être appelée dans GenericPort::Put
423 // mais il faut étudier les interactions avec GenericPort::Get et GenericPort::next
424 template < typename DataManipulator >
425 struct CalciumCouplingPolicy::EraseDataIdProcessor {
426 
427  CalciumCouplingPolicy &_couplingPolicy;
428 
429  EraseDataIdProcessor(CalciumCouplingPolicy &couplingPolicy):
430  _couplingPolicy(couplingPolicy) {};
431 
432  template < typename Container >
433  void apply(Container & storedDatas,
434  typename Container::iterator & wDataIt1 ) const {
435 
436  typedef typename Container::key_type key_type;
437  typedef typename Container::value_type value_type;
438  typedef typename Container::iterator iterator;
439 
440 #ifdef MYDEBUG
441  std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl;
442 #endif
443 
444  if ( _couplingPolicy._storageLevel == CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return;
445 
446  size_t storedDatasSize = storedDatas.size();
447  long s = storedDatasSize - _couplingPolicy._storageLevel;
448  if (s > 0 ) {
449  size_t dist=distance(storedDatas.begin(),wDataIt1);
450  for (int i=0; i<s; ++i) {
451  //no bug if removed : DataManipulator::delete_data((*storedDatas.begin()).second);
452  DataManipulator::delete_data((*storedDatas.begin()).second);
453  storedDatas.erase(storedDatas.begin());
454  }
455  // Si l'itérateur pointait sur une valeur que l'on vient de supprimer
456  if (dist < s ) {
457  throw(CalciumException(CalciumTypes::CPNTNULL,LOC(OSS()<< "StorageLevel management "
458  << _couplingPolicy._storageLevel <<
459  " has just removed the data to send")));
460  }
461  }
462 #ifdef MYDEBUG
463  std::cout << "-------- CalciumCouplingPolicy::eraseDataId, new storedDatasSize : " << storedDatas.size() << std::endl;
464 #endif
465  return;
466 
467  }
468 };
469 
470 
471 // Lorsque cette méthode est appelée depuis GenericPort::Get
472 // l'expectedDataId n'a pas été trouvé et n'est pas non plus
473 // encadré (en mode temporel).
474 // Si apply n'effectue pas de traitement particulier la méthode renvoie false
475 // Si le port a déjà reçu une directive de deconnexion STOP une exception est levée
476 // Si le port a déjà reçu une directive de deconnexion CONTINUE,
477 // on donne la dernière valeur connu et on renvoie true.
478 template < typename DataManipulator >
479 struct CalciumCouplingPolicy::DisconnectProcessor {
480 
481  const CalciumCouplingPolicy & _couplingPolicy;
482 
483  DisconnectProcessor(const CalciumCouplingPolicy & couplingPolicy):
484  _couplingPolicy(couplingPolicy) {};
485 
486  template < typename Container, typename DataId >
487  bool apply(Container & storedDatas,
488  const DataId & expectedDataId,
489  typename Container::iterator & wDataIt1 ) const {
490 
491  typedef typename Container::key_type key_type;
492  typedef typename Container::value_type value_type;
493  typedef typename Container::iterator iterator;
494 
495  // Pas de traitement particulier a effectuer
496 #ifdef MYDEBUG
497  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK1 ("<< _couplingPolicy._disconnectDirective<<") --------" << std::endl;
498 #endif
499  if ( (_couplingPolicy._disconnectDirective) == (CalciumTypes::UNDEFINED_DIRECTIVE) ) return false;
500 
501 #ifdef MYDEBUG
502  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK2 --------" << std::endl;
503 #endif
504 
505  // TODO : Ds GenericPort::next il faut convertir en CPSTOPSEQ
506  if ( _couplingPolicy._disconnectDirective == CalciumTypes::CP_ARRET )
507  throw(CalciumException(CalciumTypes::CPINARRET,LOC(OSS()<< "CP_ARRET directive"
508  << " interrupts all further data reading")));
509 #ifdef MYDEBUG
510  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK3 --------" << std::endl;
511 #endif
512 
513 
514  // S'il n'y a plus de données indique que l'on a pas pu effectuer de traitement
515  // TODO : Dans la gestion des niveaux il faut peut être interdire un niveau == 0
516  if ( storedDatas.empty() )
517  throw(CalciumException(CalciumTypes::CPNTNULL,LOC(OSS()<< "CP_CONT directive"
518  << " is active but no data is available.")));
519 
520  // expectedDataId n'a ni été trouvé dans storedDataIds ni encadré mais il se peut
521  // qu'en mode itératif il ne soit pas plus grand que le plus grand DataId stocké auquel
522  // cas on doit renvoyer une expection car on n'est plus connecté et on ne pourra jamais
523  // fournir de données pour ce dataId.
524 #ifdef MYDEBUG
525  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK4 " << expectedDataId <<" --------" << std::endl;
526 #endif
527 
528  // >= expectedDataId
529  iterator it1 = storedDatas.lower_bound(expectedDataId);
530 #ifdef MYDEBUG
531  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK5 " << std::endl;
532  for (iterator it=storedDatas.begin();it!=storedDatas.end();++it)
533  std::cout <<" "<<(*it).first ;
534  std::cout <<std::endl;
535 #endif
536 
537  // TODO : Il faut en fait renvoyer le plus proche cf IT ou DT
538  if (it1 == storedDatas.end())
539  throw(CalciumException(CalciumTypes::CPNTNULL,LOC(OSS()<< "CP_CONT directive"
540  << " is active but the requested dataId is less or equal to the last one received.")));
541 
542 #ifdef MYDEBUG
543  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK6 " << std::endl;
544 #endif
545 
546  wDataIt1 = storedDatas.end();
547  --wDataIt1;
548 #ifdef MYDEBUG
549  std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor, CP_CONT : " << (*wDataIt1).first << std::endl;
550 #endif
551 
552  return true;
553  }
554 };
555 
556 #endif