Version: 8.3.0
CouplingPolicy.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 : CouplingPolicy.hxx
24 // Author : Eric Fayolle (EDF)
25 // Module : KERNEL
26 // Modified by : $LastChangedBy$
27 // Date : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
28 // Id : $Id$
29 //
30 #ifndef _COUPLING_POLICY_HXX_
31 #define _COUPLING_POLICY_HXX_
32 
33 #include "IteratorTraits.hxx"
34 #include "FindKeyPredicate.hxx"
35 #include <algorithm>
36 #include <functional>
37 #include <iterator>
38 
39 // La politique de couplage doit définir
40 // 1) le type DataId qui identifie une instance de données
41 // 2) Un container de DataId appelé DataIdContainer et son itérateur
42 // 3) Un constructeur de DataIdContainer qui initialise le container à partir d'un DataId
43 
45 // COUPLING_POLICY::DataId
46 // est construit par DataId(T1 time,T2 tag)
47 //
48 // COUPLING_POLICY::DataIdContainer
49 // qui défini
50 // les types : DataIdContainer::iterator
51 // les méthodes : begin(), end(), empty()
52 // COUPLING_POLICY::DataIdContainer::iterator
53 // qui défini
54 // les méthodes : != , == , ++() , ()++, *(), =
55 
56 // COUPLING_POLICY::DataTable
57 // std::map< DataId, DataType> DataTable;
58 
59 // Définir void COUPLING_POLICY::DataIdContainer(const DataId &, CouplingPolicy & )
60 // qui initialise le container à partir d'un DataId
61 
62 // Opérateur d'affichage d'un dataId (les types doivent être affichables)
63 
64 
65 class CouplingPolicy {
66 
67 public:
68 
69  // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
70  // - l'itérateur wDataIt1 pointe alors sur ce dataId
71  // Cette méthode doit être redéfini dans le mode de couplage s'il veut gérer
72  // le cas d'un dataId damandé non trouvé mais encadrable
73  // par deux autres dataIds. La méthode renvoie alors isBounded== true et :
74  // - l'itérateur wDataIt1 doit être tel que :
75  // wDataIt1->first < wdataId < (wDataIt1+1)->first
76  template < typename Container >
77  bool isDataIdConveniant(Container & storedDatas,
78  const typename Container::key_type & expectedDataId,
79  bool & isEqual , bool & isBounded,
80  typename Container::iterator & wDataIt1 ) const {
81  typedef typename Container::key_type key_type;
82  typedef typename Container::value_type value_type;
83  typedef typename Container::iterator iterator;
84  isBounded = false;
85  FindKeyPredicate<value_type> fkp(expectedDataId);
86  wDataIt1 = std::find_if(storedDatas.begin(),storedDatas.end(),fkp);
87  isEqual = (wDataIt1 != storedDatas.end());
88  std::cout << "-------- Generic isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
89  return isEqual || isBounded;
90  }
91 
92 
93  // Méthode Vide déclarée ici pour définir son nom dans GenericPort
94  // Elle profite à tous les modes de couplages n'implémentant pas
95  // de comportement particulier dans la méthode get pour
96  // le cas d'une demande de dataId inexistant mais encadré par deux autres
97  template <typename DataManipulator, class EnableIf = void >
98  struct BoundedDataIdProcessor{
99  BoundedDataIdProcessor(const CouplingPolicy & couplingPolicy) {};
100  template < typename Iterator, typename DataId >
101  void inline apply(typename iterator_t<Iterator>::value_type & data,
102  const DataId & dataId,
103  const Iterator & it1) const {
104  typedef typename iterator_t<Iterator>::value_type value_type;
105  std::cout << "-------- Generic BoundedDataIdProcessor.apply() called " << std::endl;
106 
107  }
108  };
109 
110  // Supprime un DataId et ses données associées
111  // du container
112  // Cette méthode utilisée dans GenericPort::Get
113  // peut être surchargée pour par exemple
114  // conserver un historique.
115  template <typename DataManipulator>
116  struct EraseDataIdProcessor {
117 
118  EraseDataIdProcessor(CouplingPolicy couplingPolicy) {};
119 
120  template < typename Container >
121  void apply(Container & storedDatas,
122  typename Container::iterator & wDataIt1 ) const {
123  typedef typename Container::key_type key_type;
124  typedef typename Container::value_type value_type;
125  typedef typename Container::iterator iterator;
126 
127  std::cout << "-------- Generic eraseDataId called " << std::endl;
128  }
129  };
130 
131  // Lorsque cette méthode est appelée l'expectedDataId n'a pas été trouvé
132  // et n'est pas non plus encadrée (en mode temporel)
133  // Si l'on effectue pas de traitement particulier la méthode renvoie false
134  // Si le port a reçu une directive STOP une exception est levée
135  // Si le port a reçu une directive CONTINUE, on localise l'expected
136  template < typename DataManipulator >
137  struct DisconnectProcessor {
138 
139  DisconnectProcessor(const CouplingPolicy & couplingPolicy) {};
140 
141  template < typename Container, typename DataId >
142  bool apply(Container & storedDatas,
143  const DataId & expectedDataId,
144  typename Container::iterator & wDataIt1 ) const {
145  typedef typename Container::key_type key_type;
146  typedef typename Container::value_type value_type;
147  typedef typename Container::iterator iterator;
148 
149  std::cout << "-------- Generic DisconnectProcessor called " << std::endl;
150  return true;
151  }
152  };
153 
154  // Remove all DataId from a container before a given time or tag
155  template <typename DataManipulator>
156  struct EraseDataIdBeforeOrAfterTagProcessor {
157 
158  EraseDataIdBeforeOrAfterTagProcessor(CouplingPolicy couplingPolicy) {};
159 
160  template < typename Container , typename TimeType , typename TagType >
161  void apply(Container & storedDatas, TimeType time, TagType tag, bool before ) const {
162  typedef typename Container::key_type key_type;
163  typedef typename Container::value_type value_type;
164  typedef typename Container::iterator iterator;
165  }
166  };
167 
168  // Permet de réveiller les méthodes d'un GenericPort en attente
169  // depuis une CouplingPolicy
170  virtual void wakeupWaiting(){};
171 
172  virtual ~CouplingPolicy() {}
173 
174 };
175 
176 #endif