src/MEDMEM/MEDMEM_MedMedDriver.cxx

   1 #include "MEDMEM_MedMedDriver.hxx"
   2 #include "MEDMEM_Compatibility21_22.hxx"
   3 #include "MEDMEM_MedMedDriver21.hxx"
   4 #include "MEDMEM_MedMedDriver22.hxx"
   5 #include "MEDMEM_DriverFactory.hxx"
   6 #include "MEDMEM_define.hxx"
   7
   8 using namespace std;
   9 using namespace MED_EN;
  10 using namespace MEDMEM;
  11
  12 MED_MED_DRIVER::MED_MED_DRIVER(): GENDRIVER(),
  13                                   _ptrMed((MED * const)MED_NULL),
  14                                   _concreteMedDrv((GENDRIVER *) MED_NULL)
  15 {}
  16
  17 MED_MED_DRIVER::MED_MED_DRIVER(const string & fileName,  MED * const ptrMed):
  18   GENDRIVER(fileName,MED_EN::MED_RDWR), _ptrMed(ptrMed),
  19   _concreteMedDrv((GENDRIVER *) MED_NULL)
  20 {
  21   //_ptrMed->addDriver(*this); // The specific MED driver id is set within the addDriver method.
  22 }
  23
  24 MED_MED_DRIVER::MED_MED_DRIVER(const string & fileName,
  25                                MED * const ptrMed,
  26                                MED_EN::med_mode_acces accessMode):
  27   GENDRIVER(fileName,accessMode), _ptrMed(ptrMed),
  28   _concreteMedDrv((GENDRIVER *) MED_NULL)
  29 {
  30 }
  31 //REM :  As t'on besoin du champ _status :  _medIdt <-> _status  ?  Oui
  32
  33 MED_MED_DRIVER::MED_MED_DRIVER(const MED_MED_DRIVER & driver):
  34   GENDRIVER(driver),
  35   _ptrMed(driver._ptrMed),
  36   _concreteMedDrv(driver._concreteMedDrv->copy())
  37 {
  38 }
  39
  40 MED_MED_DRIVER::~MED_MED_DRIVER()
  41 {
  42   MESSAGE("MED_MED_DRIVER::~MED_MED_DRIVER() has been destroyed");
  43   if (_concreteMedDrv) delete _concreteMedDrv;
  44 }
  45
  46 // ------------- Read Only Part --------------
  47
  48 IMED_MED_RDONLY_DRIVER::IMED_MED_RDONLY_DRIVER():MED_MED_DRIVER()
  49 {
  50 }
  51
  52 IMED_MED_RDONLY_DRIVER::IMED_MED_RDONLY_DRIVER(const string & fileName,  MED * const ptrMed):
  53   MED_MED_DRIVER(fileName,ptrMed,MED_EN::MED_RDONLY)
  54 {
  55   MESSAGE("MED_MED_RDONLY_DRIVER::MED_MED_RDONLY_DRIVER(const string & fileName,  MED * const ptrMed) Constructeur read only");
  56 }
  57
  58 IMED_MED_RDONLY_DRIVER::IMED_MED_RDONLY_DRIVER(const IMED_MED_RDONLY_DRIVER & driver):
  59   MED_MED_DRIVER(driver)
  60 {
  61 }
  62
  63 IMED_MED_RDONLY_DRIVER::~IMED_MED_RDONLY_DRIVER()
  64 {
  65   MESSAGE("MED_MED_RDONLY_DRIVER::~MED_MED_RDONLY_DRIVER() has been destroyed");
  66 }
  67
  68 void IMED_MED_RDONLY_DRIVER::write(void) const
  69   throw (MEDEXCEPTION)
  70 {
  71   throw MEDEXCEPTION("MED_MED_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
  72 }
  73
  74 void IMED_MED_RDONLY_DRIVER::writeFrom(void) const
  75   throw (MEDEXCEPTION)
  76 {
  77   throw MEDEXCEPTION("MED_MED_RDONLY_DRIVER::writeFrom : Can't write with a RDONLY driver !");
  78 }
  79
  80 // ------------- Write Only Part --------------
  81
  82 IMED_MED_WRONLY_DRIVER::IMED_MED_WRONLY_DRIVER()
  83 {
  84 }
  85
  86 IMED_MED_WRONLY_DRIVER::IMED_MED_WRONLY_DRIVER(const string & fileName,  MED * const ptrMed):
  87   MED_MED_DRIVER(fileName,ptrMed,MED_EN::MED_ECRI)
  88 {}
  89
  90 IMED_MED_WRONLY_DRIVER::IMED_MED_WRONLY_DRIVER(const IMED_MED_WRONLY_DRIVER & driver):
  91   MED_MED_DRIVER(driver)
  92 {}
  93
  94 IMED_MED_WRONLY_DRIVER::~IMED_MED_WRONLY_DRIVER()
  95 {
  96   MESSAGE("MED_MED_WRONLY_DRIVER::~MED_MED_WRONLY_DRIVER() has been destroyed");
  97 }
  98
  99 void IMED_MED_WRONLY_DRIVER::read(void)
 100   throw (MEDEXCEPTION)
 101 {
 102   throw MEDEXCEPTION("MED_MED_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 103 }
 104
 105 void IMED_MED_WRONLY_DRIVER::readFileStruct(void)
 106   throw (MEDEXCEPTION)
 107 {
 108   throw MEDEXCEPTION("MED_MED_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 109 }
 110
 111 // ------------- Read Write Part --------------
 112
 113 IMED_MED_RDWR_DRIVER::IMED_MED_RDWR_DRIVER()
 114 {}
 115
 116 IMED_MED_RDWR_DRIVER::IMED_MED_RDWR_DRIVER(const string & fileName,  MED * const ptrMed):
 117   IMED_MED_RDONLY_DRIVER(fileName,ptrMed),IMED_MED_WRONLY_DRIVER(fileName,ptrMed),MED_MED_DRIVER(fileName,ptrMed,MED_REMP)
 118 {}
 119
 120 IMED_MED_RDWR_DRIVER::IMED_MED_RDWR_DRIVER(const IMED_MED_RDWR_DRIVER & driver):
 121   IMED_MED_RDONLY_DRIVER(driver),IMED_MED_WRONLY_DRIVER(driver),MED_MED_DRIVER(driver)
 122 {}
 123
 124 IMED_MED_RDWR_DRIVER::~IMED_MED_RDWR_DRIVER() {
 125   MESSAGE("MED_MED_RDWR_DRIVER::~MED_MED_RDWR_DRIVER() has been destroyed");
 126 }
 127
 128 MED_MED_RDONLY_DRIVER::MED_MED_RDONLY_DRIVER()
 129 {
 130   MESSAGE("You are using the default constructor of the Med read only Driver and it is 2.1 one");
 131   _concreteMedDrv = new MED_MED_RDONLY_DRIVER21();
 132 }
 133
 134 MED_MED_RDONLY_DRIVER::MED_MED_RDONLY_DRIVER(const string & fileName,  MED * const ptrMed)
 135 {
 136   _concreteMedDrv = DRIVERFACTORY::buildMedDriverFromFile(fileName,ptrMed,MED_LECT);
 137 }
 138
 139 MED_MED_RDONLY_DRIVER::MED_MED_RDONLY_DRIVER(const MED_MED_RDONLY_DRIVER & driver):MED_MED_DRIVER(driver)
 140 {
 141 }
 142
 143 MED_MED_RDONLY_DRIVER::~MED_MED_RDONLY_DRIVER()
 144 {
 145 }
 146
 147 void MED_MED_RDONLY_DRIVER::write          ( void ) const throw (MEDEXCEPTION)
 148 {
 149   _concreteMedDrv->write();
 150 }
 151
 152 void MED_MED_RDONLY_DRIVER::writeFrom      ( void ) const throw (MEDEXCEPTION)
 153 {
 154   _concreteMedDrv->writeFrom();
 155 }
 156
 157 void MED_MED_RDONLY_DRIVER::open() throw (MEDEXCEPTION)
 158 {
 159   _concreteMedDrv->open();
 160 }
 161
 162 void MED_MED_RDONLY_DRIVER::close()
 163 {
 164   _concreteMedDrv->close();
 165 }
 166 void MED_MED_RDONLY_DRIVER::read           ( void )
 167 {
 168   _concreteMedDrv->read();
 169 }
 170
 171 void MED_MED_RDONLY_DRIVER::readFileStruct ( void )
 172 {
 173   _concreteMedDrv->readFileStruct();
 174 }
 175
 176 GENDRIVER * MED_MED_RDONLY_DRIVER::copy ( void ) const
 177 {
 178   return new MED_MED_RDONLY_DRIVER(*this);
 179 }
 180
 181 MED_MED_WRONLY_DRIVER::MED_MED_WRONLY_DRIVER()
 182 {
 183   MESSAGE("You are using the default constructor of the Med write only Driver and it is 2.1 one");
 184
 185   _concreteMedDrv = new MED_MED_WRONLY_DRIVER21();
 186 }
 187
 188 MED_MED_WRONLY_DRIVER::MED_MED_WRONLY_DRIVER(const string & fileName,  MED * const ptrMed)
 189 {
 190   _concreteMedDrv = DRIVERFACTORY::buildMedDriverFromFile(fileName,ptrMed,MED_ECRI);
 191 }
 192
 193 MED_MED_WRONLY_DRIVER::MED_MED_WRONLY_DRIVER(const MED_MED_WRONLY_DRIVER & driver):MED_MED_DRIVER(driver)
 194 {
 195 }
 196
 197 MED_MED_WRONLY_DRIVER::~MED_MED_WRONLY_DRIVER()
 198 {
 199 }
 200
 201 void MED_MED_WRONLY_DRIVER::write          ( void ) const throw (MEDEXCEPTION)
 202 {
 203   _concreteMedDrv->write();
 204 }
 205
 206 void MED_MED_WRONLY_DRIVER::writeFrom      ( void ) const throw (MEDEXCEPTION)
 207 {
 208   _concreteMedDrv->writeFrom();
 209 }
 210
 211 void MED_MED_WRONLY_DRIVER::open() throw (MEDEXCEPTION)
 212 {
 213   _concreteMedDrv->open();
 214 }
 215
 216 void MED_MED_WRONLY_DRIVER::close()
 217 {
 218   _concreteMedDrv->close();
 219 }
 220
 221 void MED_MED_WRONLY_DRIVER::read           ( void ) throw (MEDEXCEPTION)
 222 {
 223   _concreteMedDrv->read();
 224 }
 225
 226 void MED_MED_WRONLY_DRIVER::readFileStruct ( void ) throw (MEDEXCEPTION)
 227 {
 228   _concreteMedDrv->readFileStruct();
 229 }
 230
 231 GENDRIVER * MED_MED_WRONLY_DRIVER::copy ( void ) const
 232 {
 233   return _concreteMedDrv->copy();
 234 }
 235
 236 MED_MED_RDWR_DRIVER::MED_MED_RDWR_DRIVER()
 237 {
 238   MESSAGE("You are using the default constructor of the Med read write Driver and it is 2.1 one");
 239   _concreteMedDrv = new MED_MED_RDWR_DRIVER21();
 240 }
 241
 242 MED_MED_RDWR_DRIVER::MED_MED_RDWR_DRIVER(const string & fileName,  MED * const ptrMed)
 243 {
 244   _concreteMedDrv = DRIVERFACTORY::buildMedDriverFromFile(fileName,ptrMed,MED_REMP);
 245 }
 246
 247 MED_MED_RDWR_DRIVER::MED_MED_RDWR_DRIVER(const MED_MED_RDWR_DRIVER & driver):
 248   MED_MED_DRIVER(driver)
 249 {
 250 }
 251
 252 MED_MED_RDWR_DRIVER::~MED_MED_RDWR_DRIVER()
 253 {
 254 }
 255
 256 void MED_MED_RDWR_DRIVER::write          ( void ) const throw (MEDEXCEPTION)
 257 {
 258   _concreteMedDrv->write();
 259 }
 260
 261 void MED_MED_RDWR_DRIVER::writeFrom      ( void ) const throw (MEDEXCEPTION)
 262 {
 263   _concreteMedDrv->writeFrom();
 264 }
 265
 266 void MED_MED_RDWR_DRIVER::open() throw (MEDEXCEPTION)
 267 {
 268   _concreteMedDrv->open();
 269 }
 270
 271 void MED_MED_RDWR_DRIVER::close()
 272 {
 273   _concreteMedDrv->close();
 274 }
 275
 276 void MED_MED_RDWR_DRIVER::read           ( void ) throw (MEDEXCEPTION)
 277 {
 278   _concreteMedDrv->read();
 279 }
 280
 281 void MED_MED_RDWR_DRIVER::readFileStruct ( void ) throw (MEDEXCEPTION)
 282 {
 283   _concreteMedDrv->readFileStruct();
 284 }
 285
 286 GENDRIVER * MED_MED_RDWR_DRIVER::copy ( void ) const
 287 {
 288   return _concreteMedDrv->copy();
 289 }