SALOME documentation central

src/DSC/DSC_User/Datastream/Palm/PalmCouplingPolicy.hxx

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