src/MEDMEM/MEDMEM_MedMedDriver.hxx

   1 //  Copyright (C) 2007-2008  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.
  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 #ifndef MED_MED_DRIVER_HXX
  23 #define MED_MED_DRIVER_HXX
  24
  25 #include "MEDMEM.hxx"
  26
  27 #include <string>
  28 #include "MEDMEM_STRING.hxx"
  29 #include "MEDMEM_Utilities.hxx"
  30 #include "MEDMEM_Exception.hxx"
  31 #include "MEDMEM_GenDriver.hxx"
  32 #include "MEDMEM_define.hxx"
  33
  34 /*!
  35
  36   Driver Med for MED.
  37
  38   Generic part : implement open and close methods.
  39
  40 */
  41
  42 // This driver pilots within a MED class read/write accesses of fields/meshes
  43 namespace MEDMEM {
  44 class MESH;
  45 class FIELD_;
  46 class MED;
  47
  48 class MEDMEM_EXPORT MED_MED_DRIVER : public GENDRIVER
  49 {
  50 protected:
  51
  52   MED * const       _ptrMed;         // Store 'MED_DRIVER (0..n)----(1) MED' associations
  53   GENDRIVER * _concreteMedDrv;
  54
  55 public :
  56   /*!
  57     Constructor.
  58   */
  59   MED_MED_DRIVER();
  60   /*!
  61     Constructor.
  62   */
  63   MED_MED_DRIVER(const string & fileName,  MED * const ptrMed);
  64   /*!
  65     Constructor.
  66   */
  67   MED_MED_DRIVER(const string & fileName,  MED * const ptrMed,
  68                  MED_EN::med_mode_acces accessMode);
  69
  70   // OPERATEUR DE RECOPIE AVEC _medIdt ??
  71   /*!
  72     Copy constructor.
  73   */
  74   MED_MED_DRIVER(const MED_MED_DRIVER & driver);
  75
  76   /*!
  77     Destructor.
  78   */
  79   virtual ~MED_MED_DRIVER() ;
  80
  81   virtual void open() throw (MEDEXCEPTION) = 0  ;
  82   virtual void close() = 0 ;
  83   virtual void write          ( void ) const = 0 ;
  84   virtual void writeFrom      ( void ) const = 0 ;
  85   virtual void read           ( void ) = 0 ;
  86   virtual void readFileStruct ( void ) = 0 ;
  87   virtual void setFileName ( const string & fileName) {_concreteMedDrv->setFileName(fileName); }
  88
  89 protected:
  90   virtual GENDRIVER * copy ( void ) const = 0 ;
  91
  92   friend class MED_MED_RDONLY_DRIVER;
  93   friend class MED_MED_WRONLY_DRIVER;
  94   friend class MED_MED_RDWR_DRIVER;
  95 };
  96
  97 /*!
  98
  99   Driver Med for MED : Read only.
 100
 101   Implement read method.
 102
 103 */
 104
 105 class MEDMEM_EXPORT IMED_MED_RDONLY_DRIVER : public virtual MED_MED_DRIVER
 106 {
 107 public :
 108   /*!
 109     Constructor.
 110   */
 111   IMED_MED_RDONLY_DRIVER();
 112   /*!
 113     Constructor.
 114   */
 115   IMED_MED_RDONLY_DRIVER(const string & fileName,  MED * const ptrMed);
 116   /*!
 117     Copy constructor.
 118   */
 119   IMED_MED_RDONLY_DRIVER(const IMED_MED_RDONLY_DRIVER & driver);
 120
 121   /*!
 122     Destructor.
 123   */
 124   virtual ~IMED_MED_RDONLY_DRIVER();
 125
 126   /*!
 127     Return a MEDEXCEPTION : it is the read-only driver.
 128   */
 129   void write          ( void ) const throw (MEDEXCEPTION) ;
 130   /*!
 131     Return a MEDEXCEPTION : it is the read-only driver.
 132   */
 133   void writeFrom      ( void ) const throw (MEDEXCEPTION) ;
 134
 135 protected:
 136   // PAL14192: to allow painless repeated readFileStruct() calls
 137   bool _fileStructIsRead;
 138 };
 139
 140 /*!
 141
 142   Driver Med for MED : Write only.
 143
 144   Implement write method.
 145
 146 */
 147
 148 class MEDMEM_EXPORT IMED_MED_WRONLY_DRIVER : public virtual MED_MED_DRIVER
 149 {
 150
 151 public :
 152   /*!
 153     Constructor.
 154   */
 155   IMED_MED_WRONLY_DRIVER();
 156   /*!
 157     Constructor.
 158   */
 159   IMED_MED_WRONLY_DRIVER(const string & fileName,  MED * const ptrMed);
 160   /*!
 161     Copy constructor.
 162   */
 163   IMED_MED_WRONLY_DRIVER(const IMED_MED_WRONLY_DRIVER & driver);
 164
 165   /*!
 166     Destructor.
 167   */
 168   virtual ~IMED_MED_WRONLY_DRIVER();
 169
 170   /*!
 171     Return a MEDEXCEPTION : it is the write-only driver.
 172   */
 173   void read           ( void ) throw (MEDEXCEPTION) ;
 174   /*!
 175     Return a MEDEXCEPTION : it is the write-only driver.
 176   */
 177   void readFileStruct ( void ) throw (MEDEXCEPTION) ;
 178
 179 };
 180
 181 /*!
 182
 183   Driver Med for MED : Read write.
 184   - Use read method from MED_MED_RDONLY_DRIVER
 185   - Use write method from MED_MED_WDONLY_DRIVER
 186
 187 */
 188
 189 class MEDMEM_EXPORT IMED_MED_RDWR_DRIVER : public virtual IMED_MED_RDONLY_DRIVER,
 190                              public virtual IMED_MED_WRONLY_DRIVER
 191 {
 192
 193 public :
 194   /*!
 195     Constructor.
 196   */
 197   IMED_MED_RDWR_DRIVER();
 198   /*!
 199     Constructor.
 200   */
 201   IMED_MED_RDWR_DRIVER(const string & fileName,  MED * const ptrMed);
 202   /*!
 203     Copy constructor.
 204   */
 205   IMED_MED_RDWR_DRIVER(const IMED_MED_RDWR_DRIVER & driver);
 206
 207   /*!
 208     Destructor.
 209   */
 210   ~IMED_MED_RDWR_DRIVER();
 211
 212 };
 213
 214 class MEDMEM_EXPORT MED_MED_RDONLY_DRIVER : public virtual IMED_MED_RDONLY_DRIVER
 215 {
 216 public :
 217   MED_MED_RDONLY_DRIVER();
 218   MED_MED_RDONLY_DRIVER(const string & fileName,  MED * const ptrMed);
 219   MED_MED_RDONLY_DRIVER(const MED_MED_RDONLY_DRIVER & driver);
 220   virtual ~MED_MED_RDONLY_DRIVER();
 221   void write          ( void ) const throw (MEDEXCEPTION) ;
 222   void writeFrom      ( void ) const throw (MEDEXCEPTION) ;
 223   virtual void open() throw (MEDEXCEPTION) ;
 224   virtual void close() ;
 225   virtual void read           ( void ) ;
 226   virtual void readFileStruct ( void ) ;
 227 private:
 228   GENDRIVER * copy ( void ) const;
 229 };
 230
 231 class MEDMEM_EXPORT MED_MED_WRONLY_DRIVER : public virtual IMED_MED_WRONLY_DRIVER
 232 {
 233
 234 public :
 235   MED_MED_WRONLY_DRIVER();
 236   MED_MED_WRONLY_DRIVER(const string & fileName,  MED * const ptrMed);
 237   MED_MED_WRONLY_DRIVER(const MED_MED_WRONLY_DRIVER & driver);
 238   virtual ~MED_MED_WRONLY_DRIVER();
 239   void write          ( void ) const throw (MEDEXCEPTION) ;
 240   void writeFrom      ( void ) const throw (MEDEXCEPTION) ;
 241   virtual void open() throw (MEDEXCEPTION) ;
 242   virtual void close() ;
 243   virtual void read           ( void ) throw (MEDEXCEPTION) ;
 244   virtual void readFileStruct ( void ) throw (MEDEXCEPTION) ;
 245 private:
 246   GENDRIVER * copy ( void ) const;
 247 };
 248
 249 class MEDMEM_EXPORT MED_MED_RDWR_DRIVER : public IMED_MED_RDWR_DRIVER
 250 {
 251
 252 public :
 253   MED_MED_RDWR_DRIVER();
 254   MED_MED_RDWR_DRIVER(const string & fileName,  MED * const ptrMed);
 255   MED_MED_RDWR_DRIVER(const MED_MED_RDWR_DRIVER & driver);
 256   ~MED_MED_RDWR_DRIVER();
 257   void write          ( void ) const throw (MEDEXCEPTION) ;
 258   void writeFrom      ( void ) const throw (MEDEXCEPTION) ;
 259   virtual void open() throw (MEDEXCEPTION) ;
 260   virtual void close() ;
 261   virtual void read           ( void ) throw (MEDEXCEPTION) ;
 262   virtual void readFileStruct ( void ) throw (MEDEXCEPTION) ;
 263 private:
 264   GENDRIVER * copy ( void ) const;
 265 };
 266 }
 267
 268 #endif /* MED_MED_DRIVER_HXX */