src/MEDMEM/MEDMEM_TypeMeshDriver.cxx

   1 #include "MEDMEM_TypeMeshDriver.hxx"
   2 #include "MEDMEM_DriversDef.hxx"
   3
   4 #include "MEDMEM_Family.hxx"
   5 #include "MEDMEM_Group.hxx"
   6 #include "MEDMEM_Coordinate.hxx"
   7 #include "MEDMEM_Connectivity.hxx"
   8 #include "MEDMEM_Mesh.hxx"
   9 #include "MEDMEM_CellModel.hxx"
  10
  11 using namespace std;
  12 using namespace MEDMEM;
  13
  14 // Every memory allocation made in the MedDriver members function are desallocated in the Mesh destructor
  15
  16 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER():
  17   GENDRIVER(),
  18   _ptrMesh(( MESH *)MED_NULL),
  19   // A VOIR _medIdt(MED_INVALID),
  20   _meshName("")
  21 {
  22 }
  23
  24 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER(const string & fileName,
  25                                    MESH * ptrMesh,
  26                                    MED_EN::med_mode_acces accessMode):
  27   GENDRIVER(fileName,accessMode),
  28   _ptrMesh(ptrMesh),
  29   // A VOIR _medIdt(MED_INVALID),
  30   _meshName("")
  31 {
  32 }
  33
  34 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver):
  35   GENDRIVER(driver),
  36   _ptrMesh(driver._ptrMesh),
  37   // A VOIR _medIdt(MED_INVALID),
  38   _meshName(driver._meshName)
  39 {
  40 }
  41
  42 TYPE_MESH_DRIVER::~TYPE_MESH_DRIVER()
  43 {
  44 }
  45
  46 void TYPE_MESH_DRIVER::open()
  47   throw (MEDEXCEPTION)
  48 {
  49   const char * LOC = "TYPE_MESH_DRIVER::open()" ;
  50   BEGIN_OF(LOC);
  51
  52 //   if (_medIdt > 0)
  53 //     _status = MED_OPENED;
  54 //   else {
  55 //     _medIdt = MED_INVALID;
  56 //     _status = MED_CLOSED;
  57 //     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Could not open file "<<_fileName<<" in mode "<<_accessMode));
  58 //   }
  59
  60   END_OF(LOC);
  61 }
  62
  63 void TYPE_MESH_DRIVER::close()
  64   throw (MEDEXCEPTION)
  65 {
  66   const char * LOC = "TYPE_MESH_DRIVER::close() " ;
  67   BEGIN_OF(LOC);
  68
  69 //   int err = 0;
  70 //   if ( _status == MED_OPENED) {
  71 //     err=MED_FR::MEDfermer(_medIdt);
  72 //     H5close(); // If we call H5close() all the files are closed.
  73 //     if (err != 0)
  74 //       throw MEDEXCEPTION( LOCALIZED(STRING(LOC)
  75 //                                  <<" Error when closing file !"
  76 //                                  )
  77 //                        );
  78 //     _status = MED_CLOSED;
  79 //     _medIdt = MED_INVALID;
  80 //   }
  81
  82   END_OF(LOC);
  83 }
  84
  85 void    TYPE_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
  86 string  TYPE_MESH_DRIVER::getMeshName() const { return _meshName; };
  87
  88
  89 //---------------------------------- RDONLY PART -------------------------------------------------------------
  90
  91 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(): TYPE_MESH_DRIVER()
  92 {
  93 }
  94
  95 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const string & fileName,
  96                                                  MESH * ptrMesh):
  97   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_RDONLY)
  98 {
  99   MESSAGE("TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 100 }
 101
 102 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver):
 103   TYPE_MESH_DRIVER(driver)
 104 {
 105 }
 106
 107 TYPE_MESH_RDONLY_DRIVER::~TYPE_MESH_RDONLY_DRIVER()
 108 {
 109   //MESSAGE("TYPE_MESH_RDONLY_DRIVER::~TYPE_MESH_RDONLY_DRIVER() has been destroyed");
 110 }
 111
 112 GENDRIVER * TYPE_MESH_RDONLY_DRIVER::copy(void) const
 113 {
 114   return new TYPE_MESH_RDONLY_DRIVER(*this);
 115 }
 116
 117 void TYPE_MESH_RDONLY_DRIVER::read(void)
 118   throw (MEDEXCEPTION)
 119 {
 120   const char * LOC = "TYPE_MESH_RDONLY_DRIVER::read() : " ;
 121   BEGIN_OF(LOC);
 122
 123   if (_status!=MED_OPENED)
 124     throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "The _idt of file " << _fileName << " is : "  <<  " (the file is not opened)." )) ;
 125
 126   _ptrMesh->_name =  _meshName;
 127
 128
 129   END_OF(LOC);
 130 }
 131
 132 void TYPE_MESH_RDONLY_DRIVER::write( void ) const
 133   throw (MEDEXCEPTION)
 134 {
 135   throw MEDEXCEPTION("TYPE_MESH_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 136 }
 137
 138
 139 /*--------------------- WRONLY PART -------------------------------*/
 140
 141 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER():TYPE_MESH_DRIVER()
 142 {
 143 }
 144
 145 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName,
 146                                                  MESH * ptrMesh):
 147   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_WRONLY)
 148 {
 149   MESSAGE("TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 150 }
 151
 152 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver):
 153   TYPE_MESH_DRIVER(driver)
 154 {
 155 }
 156
 157 TYPE_MESH_WRONLY_DRIVER::~TYPE_MESH_WRONLY_DRIVER()
 158 {
 159   //MESSAGE("TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 160 }
 161
 162 GENDRIVER * TYPE_MESH_WRONLY_DRIVER::copy(void) const
 163 {
 164   return new TYPE_MESH_WRONLY_DRIVER(*this);
 165 }
 166
 167 void TYPE_MESH_WRONLY_DRIVER::read (void)
 168   throw (MEDEXCEPTION)
 169 {
 170   throw MEDEXCEPTION("TYPE_MESH_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 171 }
 172
 173 void TYPE_MESH_WRONLY_DRIVER::write(void) const
 174   throw (MEDEXCEPTION)
 175 {
 176   const char * LOC = "void TYPE_MESH_WRONLY_DRIVER::write(void) const : ";
 177   BEGIN_OF(LOC);
 178
 179   throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<< "Write Driver isn\'t implemented"));
 180
 181   END_OF(LOC);
 182 }
 183
 184
 185
 186 /*--------------------- RDWR PART -------------------------------*/
 187
 188 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER():TYPE_MESH_DRIVER()
 189 {
 190 }
 191
 192 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName,
 193                                            MESH * ptrMesh):
 194   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_RDWR)
 195 {
 196   MESSAGE("TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 197 }
 198
 199 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver):
 200   TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_DRIVER(driver)
 201 {
 202 }
 203
 204 TYPE_MESH_RDWR_DRIVER::~TYPE_MESH_RDWR_DRIVER() {
 205   //MESSAGE("TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 206 }
 207
 208 GENDRIVER * TYPE_MESH_RDWR_DRIVER::copy(void) const
 209 {
 210   return new TYPE_MESH_RDWR_DRIVER(*this);
 211 }
 212
 213 void TYPE_MESH_RDWR_DRIVER::write(void) const
 214   throw (MEDEXCEPTION)
 215 {
 216   TYPE_MESH_WRONLY_DRIVER::write();
 217 }
 218 void TYPE_MESH_RDWR_DRIVER::read (void)
 219   throw (MEDEXCEPTION)
 220 {
 221   TYPE_MESH_RDONLY_DRIVER::read();
 222 }