src/MEDMEM/MEDMEM_MedMedDriver.hxx

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