Back to index

salome-kernel  6.5.0
PalmCouplingPolicy.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   : PalmCouplingPolicy.hxx
00024 //  Author : Eric Fayolle (EDF)
00025 //  Module : KERNEL
00026 // Modified by : $LastChangedBy$
00027 // Date        : $LastChangedDate: 2007-01-29 16:12:41 +0100 (lun, 29 jan 2007) $
00028 // Id          : $Id: PalmCouplingPolicy.hxx,v 1.3.2.1.10.2.12.1 2012-04-12 14:05:08 vsr Exp $
00029 //
00030 #ifndef _PALM_COUPLING_POLICIES_HXX_
00031 #define _PALM_COUPLING_POLICIES_HXX_
00032 
00033 #include <SALOMEconfig.h>
00034 
00035 #include <CORBA.h>
00036 #include <vector>
00037 #include "DataIdFilter.hxx"
00038 #include "DisplayPair.hxx"
00039 #include "CouplingPolicy.hxx"
00040 
00041 class PalmCouplingPolicy: public CouplingPolicy {
00042 
00043   // Objet de filtrage et conversion d'un TIME
00044   filtre_conversion filtre_convert_TIME ;
00045   // Objet de filtrage et conversion d'un TAG
00046   filtre_conversion filtre_convert_TAG ;
00047 
00048 public:
00049 
00050   template <typename T_TIME, typename T_TAG >        class InternalDataIdContainer;
00051   template <typename T_TIME, typename T_TAG > friend class InternalDataIdContainer;
00052 
00053   filtre_conversion * get_filtre_convert_TIME() { return &filtre_convert_TIME; }
00054   filtre_conversion * get_filtre_convert_TAG()  { return &filtre_convert_TAG;  }
00055  
00056   // Classe DataId rassemblant les paramètres de la méthode PORT::put 
00057   // qui identifient l'instance d'une donnée pour Palm
00058   // Rem : Le DataId doit pouvoir être une key dans une map stl
00059   typedef CORBA::Long TimeType;
00060   typedef CORBA::Long TagType;
00061   typedef std::pair               < TimeType , TagType > DataId;
00062   typedef InternalDataIdContainer < TimeType , TagType > DataIdContainer;
00063 
00064   TimeType getTime(const DataId &dataId) const { return dataId.first;}
00065   TagType  getTag (const DataId &dataId) const { return dataId.second;}
00066 
00067   // Container qui permet d'itérer sur l'ensemble des DataId générés par les
00068   // eventuelles conversions
00069   template <typename T_TIME, typename T_TAG > class InternalDataIdContainer {
00070 
00071     std::vector<T_TIME>  _lTime;
00072     std::vector<T_TAG>   _lTag;
00073     
00074     // Interdit la construction d'un container vide car
00075     // aucune méthode d'ajout d'élément n'a été implémentée
00076     InternalDataIdContainer() {}
00077  
00078   public:
00079     typedef DataId                                   value_type;
00080     template <typename TTIME, typename TTAG>   class DataIdIterator;
00081     typedef  DataIdIterator<T_TIME, T_TAG>           iterator;                  
00082     typedef value_type &                             reference;
00083     typedef value_type const &                       const_reference;
00084  
00085     // Remplit le container d'identificateurs après avoir appliqué
00086     // les filtres/convertions  des paramètres "TIMEs" et des "TAGs"
00087     InternalDataIdContainer(const DataId & dataId, const PalmCouplingPolicy & policy ) {
00088       std::cout << "----Cst ----  InternalDataIdContainer(const DataId & dataId..) " << dataId <<std::endl;
00089       policy.filtre_convert_TIME.applique_filtre_conversion(dataId.first, _lTime);
00090       int c=0;
00091       for(std::vector<CORBA::Long>::iterator i=_lTime.begin();i!=_lTime.end();++i)
00092         std::cout << "_lTime["<< c++ << "] : " << *i << std::endl;
00093       policy.filtre_convert_TAG.applique_filtre_conversion(dataId.second, _lTag);
00094       c=0;
00095       for(std::vector<CORBA::Long>::iterator i=_lTag.begin();i!=_lTag.end();++i)
00096         std::cout << "_lTag["<< c++ << "] : " << *i << std::endl;
00097     }
00098 
00099     // Pas encore testé
00100     InternalDataIdContainer(std::vector<T_TIME> const & lTime, std::vector<T_TAG> const & lTag):
00101       _lTime(lTime),_lTag(lTag) {}
00102   
00103 
00104     // Pas encore testé
00105     InternalDataIdContainer( InternalDataIdContainer const & pc):
00106       _lTime(pc._lTime), _lTag(pc._lTag) {}
00107 
00108 
00109     // Pas encore testé
00110     InternalDataIdContainer & operator=(const InternalDataIdContainer & pc) {
00111       if (this != &pc) { _lTime=pc._lTime; _lTag=pc._lTag; }
00112       return *this;
00113     }
00114     
00115     virtual ~InternalDataIdContainer() {}
00116 
00117     iterator begin() { return iterator(*this);  }
00118     iterator end()   { return iterator(*this,_lTime.end(),_lTag.end()); }
00119     // En Palm les deux paramètres du couple (temps,tag) doivent
00120     // exister (un seul paramètre n'est pas recevable) 
00121     bool     empty() const { return _lTime.empty() || _lTag.empty(); }
00122 
00123     // Définition de l'itérateur du container
00124     template <typename TTIME, typename TTAG> class DataIdIterator {
00125 
00126     public:
00127 
00128       typedef typename std::vector<TTIME>::const_iterator ItTime;
00129       typedef typename std::vector<TTAG >::const_iterator ItTag;
00130 
00131     private:
00132       ItTime _itTime;
00133       ItTag  _itTag;
00134       const InternalDataIdContainer<TTIME,TTAG> & _pc;
00135       DataIdIterator() {}
00136 
00137     public:
00138  
00139  
00140       // Pas encore testé
00141       DataIdIterator(const InternalDataIdContainer<TTIME,TTAG> & pc):
00142         _pc(pc),_itTime(pc._lTime.begin()),_itTag(pc._lTag.begin()) {}
00143       DataIdIterator(const InternalDataIdContainer<TTIME,TTAG> & pc, ItTime itTime, ItTag itTag):
00144         _pc(pc),_itTime(itTime),_itTag(itTag) {}
00145       // Pas encore testé
00146       DataIdIterator(const DataIdIterator & dIt):
00147         _pc(dIt._pc),_itTime(dIt._itTime),_itTag(dIt._itTag) {}
00148       ~DataIdIterator() {}
00149       
00150 
00151       // Pas encore testé
00152       DataIdIterator & operator=(const DataIdIterator & dIt) {
00153         if (this != &dIt) {
00154           _pc=dIt._pc;_itTime=dIt._itTime;_itTag=dIt._itTag;
00155         }
00156         return *this;
00157       }
00158 
00159       DataId operator*() const {
00160         std::cout << "-------- operator*(),  *_itTime : " << *_itTime << " *_itTag " <<  *_itTag <<std::endl;
00161         return DataId(*_itTime,*_itTag); }
00162    
00163       bool operator==( const DataIdIterator  & dIt) const {
00164         return (_itTime == dIt._itTime) && (_itTag == dIt._itTag) && (&_pc == &dIt._pc);
00165       }
00166 
00167       bool operator!=( const DataIdIterator  & dIt) const { 
00168         return (_itTime != dIt._itTime) || (_itTag != dIt._itTag) || (&_pc != &dIt._pc);
00169       }
00170 
00171       // Notation préfixé
00172       DataIdIterator & operator++() {
00173         if ( _itTag != _pc._lTag.end() ) { 
00174           ++_itTag;
00175           if (_itTag != _pc._lTag.end() ) return *this;
00176         }
00177         if ( _itTime != _pc._lTime.end() )  { 
00178           ++_itTime;
00179           if (_itTime != _pc._lTime.end() ) _itTag=_pc._lTag.begin();
00180         }
00181         return *this;
00182       }
00183 
00184       // Notation postfixé
00185       DataIdIterator operator++(int fake) { 
00186         DataIdIterator tmpIt=*this; ++*this; return tmpIt; 
00187       }
00188       
00189     }; //Fin de la classe de l'itérateur
00190   };   //Fin de la classe du container
00191 
00192 
00193 
00194 };
00195 
00196 #endif