src/MEDMEM/MEDMEM_TypeMeshDriver.hxx

   1 #ifndef TYPE_MESH_DRIVER_HXX
   2 #define TYPE_MESH_DRIVER_HXX
   3
   4 #include <string>
   5 #include <vector>
   6
   7 #include "MEDMEM_define.hxx"
   8 #include "MEDMEM_GenDriver.hxx"
   9
  10 #include "MEDMEM_STRING.hxx"
  11 #include "MEDMEM_Exception.hxx"
  12 #include "utilities.h"
  13
  14 using namespace MEDMEM;
  15
  16 /*!
  17
  18   Driver TYPE for MESH.
  19
  20   Generic part : implement the readopen and close methods.
  21
  22 */
  23
  24
  25 namespace MEDMEM {
  26 class MESH;
  27 class FAMILY;
  28 class GROUP;
  29 class CONNECTIVITY;
  30 class TYPE_MESH_DRIVER : public GENDRIVER
  31 {
  32 protected:
  33
  34   MESH *          _ptrMesh;
  35   // A VOIR FILE DESCRIPTEUR ? MED_FR::med_idt _medIdt;
  36   string          _meshName;
  37
  38 public :
  39
  40   /*!
  41     Constructor.
  42   */
  43   TYPE_MESH_DRIVER() ;
  44   /*!
  45     Constructor.
  46   */
  47   TYPE_MESH_DRIVER(const string & fileName,
  48                   MESH * ptrMesh,
  49                   med_mode_acces accessMode) ;
  50   /*!
  51     Copy constructor.
  52   */
  53   TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver) ;
  54
  55   /*!
  56     Destructor.
  57   */
  58   virtual ~TYPE_MESH_DRIVER() ;
  59
  60   void open() throw (MEDEXCEPTION);
  61   void close() throw (MEDEXCEPTION);
  62
  63   virtual void write( void ) const = 0 ;
  64   virtual void read ( void ) = 0 ;
  65
  66   /*!
  67     Set the name of the MESH asked in file.
  68
  69     It could be different than the name of the MESH object.
  70   */
  71   void   setMeshName(const string & meshName) ;
  72   /*!
  73     Get the name of the MESH asked in file.
  74   */
  75   string getMeshName() const ;
  76
  77 private:
  78   virtual GENDRIVER * copy ( void ) const = 0 ;
  79
  80 };
  81
  82
  83 class TYPE_MESH_RDONLY_DRIVER : public virtual TYPE_MESH_DRIVER
  84 {
  85
  86 public :
  87
  88   /*!
  89     Constructor.
  90   */
  91   TYPE_MESH_RDONLY_DRIVER() ;
  92   /*!
  93     Constructor.
  94   */
  95   TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh) ;
  96   /*!
  97     Copy constructor.
  98   */
  99   TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver) ;
 100
 101   /*!
 102     Destructor.
 103   */
 104   virtual ~TYPE_MESH_RDONLY_DRIVER() ;
 105
 106   /*!
 107     Return a MEDEXCEPTION : it is the read-only driver.
 108   */
 109   void write( void ) const throw (MEDEXCEPTION);
 110   /*!
 111     Read MESH in the specified file.
 112   */
 113   void read ( void ) throw (MEDEXCEPTION);
 114
 115 private:
 116
 117   GENDRIVER * copy ( void ) const ;
 118
 119 };
 120
 121 /*!
 122
 123   Driver Med for MESH : Write only.
 124
 125   Implement write method.
 126
 127 */
 128
 129 class TYPE_MESH_WRONLY_DRIVER : public virtual TYPE_MESH_DRIVER {
 130
 131 public :
 132
 133   /*!
 134     Constructor.
 135   */
 136   TYPE_MESH_WRONLY_DRIVER() ;
 137   /*!
 138     Constructor.
 139   */
 140   TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) ;
 141   /*!
 142     Copy constructor.
 143   */
 144   TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver) ;
 145
 146   /*!
 147     Destructor.
 148   */
 149   virtual ~TYPE_MESH_WRONLY_DRIVER() ;
 150
 151   /*!
 152     Write MESH in the specified file.
 153   */
 154   void write( void ) const throw (MEDEXCEPTION);
 155   /*!
 156     Return a MEDEXCEPTION : it is the write-only driver.
 157   */
 158   void read ( void ) throw (MEDEXCEPTION);
 159
 160 private:
 161
 162   GENDRIVER * copy ( void ) const ;
 163 };
 164
 165
 166 /*!
 167
 168   Driver TYPE for MESH : Read write.
 169   - Use read method from TYPE_MESH_RDONLY_DRIVER
 170   - Use write method from TYPE_MESH_WRONLY_DRIVER
 171
 172 */
 173
 174 class TYPE_MESH_RDWR_DRIVER : public TYPE_MESH_RDONLY_DRIVER, public TYPE_MESH_WRONLY_DRIVER {
 175
 176 public :
 177
 178   /*!
 179     Constructor.
 180   */
 181   TYPE_MESH_RDWR_DRIVER() ;
 182   /*!
 183     Constructor.
 184   */
 185   TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) ;
 186   /*!
 187     Copy constructor.
 188   */
 189   TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver) ;
 190
 191   /*!
 192     Destructor.
 193   */
 194   ~TYPE_MESH_RDWR_DRIVER() ;
 195
 196   /*!
 197     Write MESH in the specified file.
 198   */
 199   void write(void) const throw (MEDEXCEPTION);
 200   /*!
 201     Read MESH in the specified file.
 202   */
 203   void read (void) throw (MEDEXCEPTION);
 204
 205 private:
 206   GENDRIVER * copy(void) const ;
 207
 208 };
 209 };
 210
 211
 212 #endif /* TYPE_MESH_DRIVER_HXX */