Back to index

salome-kernel  6.5.0
CouplingPolicy.hxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  File   : CouplingPolicy.hxx
00024 //  Author : Eric Fayolle (EDF)
00025 //  Module : KERNEL
00026 // Modified by : $LastChangedBy$
00027 // Date        : $LastChangedDate: 2007-02-28 15:26:32 +0100 (mer, 28 fév 2007) $
00028 // Id          : $Id: CouplingPolicy.hxx,v 1.3.2.1.10.2.12.1 2012-04-12 14:05:06 vsr Exp $
00029 //
00030 #ifndef _COUPLING_POLICY_HXX_
00031 #define _COUPLING_POLICY_HXX_
00032 
00033 #include "IteratorTraits.hxx"
00034 #include "FindKeyPredicate.hxx"
00035 #include <algorithm>
00036 #include <functional>
00037 #include <iterator>
00038 
00039 // La politique de couplage doit définir
00040 // 1) le type DataId qui identifie une instance de données 
00041 // 2) Un container de DataId appelé DataIdContainer et son itérateur
00042 // 3) Un constructeur de DataIdContainer qui  initialise le container à partir d'un DataId
00043 
00045 //   COUPLING_POLICY::DataId 
00046 //   est construit par  DataId(T1 time,T2 tag)
00047 //
00048 //   COUPLING_POLICY::DataIdContainer
00049 //   qui défini  
00050 //   les types    : DataIdContainer::iterator 
00051 //   les méthodes : begin(), end(), empty()
00052 //   COUPLING_POLICY::DataIdContainer::iterator 
00053 //   qui défini 
00054 //   les méthodes : != , == , ++() , ()++, *(), =
00055 
00056 //   COUPLING_POLICY::DataTable
00057 //    std::map< DataId, DataType>      DataTable;
00058 
00059 //   Définir void COUPLING_POLICY::DataIdContainer(const DataId &, CouplingPolicy & )
00060 //   qui initialise le container à partir d'un DataId
00061 
00062 //   Opérateur d'affichage d'un dataId (les types doivent être affichables)
00063 
00064   
00065 class CouplingPolicy {
00066 
00067 public:
00068 
00069   // Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
00070   //   - l'itérateur wDataIt1 pointe alors sur ce dataId
00071   // Cette méthode doit être redéfini dans le mode de couplage s'il veut gérer
00072   // le cas d'un  dataId damandé non trouvé mais encadrable 
00073   // par deux autres dataIds. La méthode renvoie alors isBounded== true et : 
00074   //   - l'itérateur wDataIt1 doit  être tel que :
00075   //     wDataIt1->first < wdataId < (wDataIt1+1)->first
00076   template < typename Container >
00077   bool isDataIdConveniant(Container & storedDatas, 
00078                           const typename Container::key_type & expectedDataId,
00079                           bool & isEqual ,  bool & isBounded, 
00080                           typename Container::iterator & wDataIt1 ) const {
00081     typedef typename Container::key_type   key_type;
00082     typedef typename Container::value_type value_type;
00083     typedef typename Container::iterator iterator;
00084     isBounded = false;
00085     FindKeyPredicate<value_type> fkp(expectedDataId);
00086     wDataIt1  = std::find_if(storedDatas.begin(),storedDatas.end(),fkp);
00087     isEqual   = (wDataIt1 != storedDatas.end());
00088     std::cout << "-------- Generic isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
00089     return isEqual || isBounded;
00090   }
00091 
00092   
00093   // Méthode Vide déclarée ici pour définir son nom dans GenericPort
00094   // Elle profite à tous les modes de couplages n'implémentant pas
00095   // de comportement particulier dans la méthode get pour 
00096   // le cas d'une demande de dataId inexistant mais encadré par deux autres
00097   template <typename DataManipulator, class EnableIf = void >
00098   struct BoundedDataIdProcessor{
00099     BoundedDataIdProcessor(const CouplingPolicy & couplingPolicy) {};
00100     template < typename Iterator, typename DataId > 
00101     void inline apply(typename iterator_t<Iterator>::value_type & data,
00102                       const DataId & dataId,
00103                       const Iterator  & it1) const {
00104       typedef typename iterator_t<Iterator>::value_type value_type;
00105       std::cout << "-------- Generic BoundedDataIdProcessor.apply() called " << std::endl;
00106 
00107     }
00108   };
00109 
00110   // Supprime un DataId et ses données associées
00111   // du container
00112   // Cette méthode utilisée dans GenericPort::Get 
00113   // peut être surchargée pour par exemple
00114   // conserver un historique.
00115   template <typename DataManipulator>
00116   struct EraseDataIdProcessor {
00117 
00118     EraseDataIdProcessor(CouplingPolicy couplingPolicy) {};
00119 
00120     template < typename Container >
00121     void apply(Container & storedDatas, 
00122                typename Container::iterator & wDataIt1 ) const {
00123       typedef typename Container::key_type   key_type;
00124       typedef typename Container::value_type value_type;
00125       typedef typename Container::iterator iterator;
00126 
00127       std::cout << "-------- Generic eraseDataId called " << std::endl;
00128     }
00129   };
00130 
00131   // Lorsque cette méthode est appelée l'expectedDataId n'a pas été trouvé
00132   // et n'est pas non plus encadrée (en mode temporel)
00133   // Si l'on effectue pas de traitement particulier la méthode renvoie false
00134   // Si le port a reçu une directive STOP une exception est levée
00135   // Si le port a reçu une directive CONTINUE, on localise l'expected
00136   template < typename DataManipulator > 
00137   struct DisconnectProcessor {
00138 
00139     DisconnectProcessor(const CouplingPolicy & couplingPolicy) {};
00140 
00141     template < typename Container, typename DataId >
00142     bool apply(Container & storedDatas,
00143                const DataId & expectedDataId,
00144                typename Container::iterator & wDataIt1 ) const {
00145       typedef typename Container::key_type   key_type;
00146       typedef typename Container::value_type value_type;
00147       typedef typename Container::iterator   iterator;
00148 
00149       std::cout << "-------- Generic DisconnectProcessor called " << std::endl;
00150       return true;
00151     }
00152   };
00153 
00154   // Remove all DataId from a container before a given time or tag
00155   template <typename DataManipulator>
00156   struct EraseDataIdBeforeOrAfterTagProcessor {
00157 
00158     EraseDataIdBeforeOrAfterTagProcessor(CouplingPolicy couplingPolicy) {};
00159 
00160     template < typename Container , typename TimeType , typename TagType >
00161     void apply(Container & storedDatas, TimeType time, TagType tag, bool before ) const {
00162       typedef typename Container::key_type   key_type;
00163       typedef typename Container::value_type value_type;
00164       typedef typename Container::iterator iterator;
00165     }
00166   };
00167 
00168   // Permet de réveiller les méthodes d'un GenericPort en attente
00169   // depuis une CouplingPolicy
00170   virtual void wakeupWaiting(){};
00171 
00172   virtual ~CouplingPolicy() {}
00173 
00174 };
00175 
00176 #endif