src/MEDMEM/MEDMEM_MedFieldDriver.hxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20 #ifndef MED_FIELD_DRIVER_HXX
  21 #define MED_FIELD_DRIVER_HXX
  22
  23 #include <string>
  24
  25 #include "MEDMEM_define.hxx"
  26
  27 #include "MEDMEM_GenDriver.hxx"
  28 #include "MEDMEM_Utilities.hxx"
  29
  30 #include "MEDMEM_STRING.hxx"
  31 #include "MEDMEM_Exception.hxx"
  32 #include "MEDMEM_Unit.hxx"
  33 #include "MEDMEM_Array.hxx"
  34 #include "MEDMEM_Support.hxx"
  35 #include "MEDMEM_Mesh.hxx"
  36 #include "MEDMEM_Compatibility21_22.hxx"
  37
  38 namespace MEDMEM {
  39 template <class T> class FIELD;
  40 template <class T> class MED_FIELD_RDWR_DRIVER;
  41 template <class T> class MED_FIELD_RDONLY_DRIVER;
  42 template <class T> class MED_FIELD_WRONLY_DRIVER;
  43
  44 template <class T> class MED_FIELD_DRIVER : public GENDRIVER
  45 {
  46 protected:
  47   FIELD<T> *     _ptrField;
  48   string         _fieldName;
  49   int            _fieldNum;
  50   void search_field() ;
  51
  52 public :
  53
  54   // all MED cell type ?? Classe de Définition ??
  55   //   static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
  56
  57   //   static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
  58
  59   /*!
  60     Constructor.
  61   */
  62   MED_FIELD_DRIVER():_ptrField((FIELD<T> *) NULL),
  63                      _fieldName(""),_fieldNum(MED_INVALID)
  64   {}
  65   /*!
  66     Constructor.
  67   */
  68   MED_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField,
  69                    MED_EN::med_mode_acces accessMode)
  70     : GENDRIVER(fileName,accessMode),
  71       _ptrField((FIELD<T> *) ptrField),
  72       _fieldName(fileName),_fieldNum(MED_INVALID)
  73   {
  74   }
  75
  76   /*!
  77     Copy constructor.
  78   */
  79   MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
  80     GENDRIVER(fieldDriver),
  81     _ptrField(fieldDriver._ptrField),
  82     _fieldName(fieldDriver._fieldName),
  83     _fieldNum(fieldDriver._fieldNum)
  84   {
  85   }
  86
  87   /*!
  88     Destructor.
  89   */
  90   virtual ~MED_FIELD_DRIVER()
  91   {
  92     MESSAGE("MED_FIELD_DRIVER::~MED_FIELD_DRIVER() has been destroyed");
  93   }
  94
  95   virtual void open() throw (MEDEXCEPTION) = 0;
  96   virtual void close() =0;
  97   virtual void write( void ) const = 0 ;
  98   virtual void read ( void ) = 0 ;
  99   /*!
 100     Set the name of the FIELD asked in file.
 101
 102     It could be different than the name of the FIELD object.
 103   */
 104   virtual void   setFieldName(const string & fieldName) { _fieldName = fieldName; }
 105   /*!
 106     Get the name of the FIELD asked in file.
 107   */
 108   virtual string getFieldName() const { return _fieldName; }
 109 protected:
 110   virtual GENDRIVER * copy ( void ) const = 0 ;
 111   friend class MED_FIELD_RDWR_DRIVER<T>;
 112   friend class MED_FIELD_RDONLY_DRIVER<T>;
 113   friend class MED_FIELD_WRONLY_DRIVER<T>;
 114 };
 115
 116 /*!
 117
 118   Driver Med for FIELD : Read only.
 119
 120   Implement read method.
 121
 122 */
 123
 124 template <class T> class IMED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
 125 {
 126
 127 public :
 128
 129   /*!
 130     Constructor.
 131   */
 132   IMED_FIELD_RDONLY_DRIVER() {}
 133
 134   /*!
 135     Constructor.
 136   */
 137   IMED_FIELD_RDONLY_DRIVER(const string & fileName,  FIELD<T> * ptrField):
 138     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDONLY) {
 139     BEGIN_OF("IMED_FIELD_RDONLY_DRIVER::IMED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 140     END_OF("IMED_FIELD_RDONLY_DRIVER::IMED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 141   }
 142
 143   /*!
 144     Copy constructor.
 145   */
 146   IMED_FIELD_RDONLY_DRIVER(const IMED_FIELD_RDONLY_DRIVER & fieldDriver):
 147     MED_FIELD_DRIVER<T>(fieldDriver) {}
 148
 149   /*!
 150     Destructor.
 151   */
 152   virtual ~IMED_FIELD_RDONLY_DRIVER() {}
 153
 154   // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
 155
 156   /*!
 157     Return a MEDEXCEPTION : it is the read-only driver.
 158   */
 159   void write( void ) const throw (MEDEXCEPTION) ;
 160
 161   friend class MED_FIELD_RDONLY_DRIVER<T>;
 162 };
 163
 164 /*!
 165
 166   Driver Med for FIELD : Write only.
 167
 168   Implement write method.
 169
 170 */
 171
 172 template <class T> class IMED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
 173
 174 public :
 175
 176   /*!
 177     Constructor.
 178   */
 179   IMED_FIELD_WRONLY_DRIVER() {}
 180
 181   /*!
 182     Constructor.
 183   */
 184   IMED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
 185     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_WRONLY)
 186   {
 187     BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 188     END_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 189   }
 190
 191   /*!
 192     Copy constructor.
 193   */
 194   IMED_FIELD_WRONLY_DRIVER(const IMED_FIELD_WRONLY_DRIVER & fieldDriver):
 195     MED_FIELD_DRIVER<T>(fieldDriver) {}
 196
 197   /*!
 198     Destructor.
 199   */
 200   virtual ~IMED_FIELD_WRONLY_DRIVER() {};
 201   /*!
 202     Return a MEDEXCEPTION : it is the write-only driver.
 203   */
 204   void read ( void ) throw (MEDEXCEPTION) ;
 205
 206   friend class MED_FIELD_WRONLY_DRIVER<T>;
 207 };
 208
 209
 210 /*!
 211
 212   Driver Med for FIELD : Read write.
 213   - Use read method from MED_FIELD_RDONLY_DRIVER
 214   - Use write method from MED_FIELD_WDONLY_DRIVER
 215
 216 */
 217
 218 template <class T> class IMED_FIELD_RDWR_DRIVER : public virtual IMED_FIELD_RDONLY_DRIVER<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
 219
 220 public :
 221
 222   /*!
 223     Constructor.
 224   */
 225   IMED_FIELD_RDWR_DRIVER() {}
 226
 227   /*!
 228     Constructor.
 229   */
 230   IMED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField):
 231     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDWR)
 232   {
 233     BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 234     //_accessMode = MED_RDWR ;
 235     END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 236   }
 237
 238   /*!
 239     Copy constructor.
 240   */
 241   IMED_FIELD_RDWR_DRIVER(const IMED_FIELD_RDWR_DRIVER & fieldDriver):
 242     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),MED_FIELD_DRIVER<T>(fieldDriver) {}
 243
 244   /*!
 245     Destructor.
 246   */
 247   ~IMED_FIELD_RDWR_DRIVER() {}
 248
 249   friend class MED_FIELD_RDWR_DRIVER<T>;
 250 };
 251
 252 }
 253
 254 namespace MEDMEM {
 255
 256 template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual IMED_FIELD_RDONLY_DRIVER<T>
 257 {
 258
 259 public :
 260   MED_FIELD_RDONLY_DRIVER();
 261   MED_FIELD_RDONLY_DRIVER(const string & fileName,  FIELD<T> * ptrField);
 262
 263   MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver):IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver) { _concreteFieldDrv = fieldDriver._concreteFieldDrv->copy(); }
 264   virtual ~MED_FIELD_RDONLY_DRIVER() {     if (_concreteFieldDrv) delete _concreteFieldDrv; }
 265   virtual void read ( void ) throw (MEDEXCEPTION) { _concreteFieldDrv->read(); }
 266   virtual void write( void ) const throw (MEDEXCEPTION) { _concreteFieldDrv->write(); }
 267   virtual void open() throw (MEDEXCEPTION) { _concreteFieldDrv->open(); }
 268   virtual void close() { _concreteFieldDrv->close(); }
 269   virtual void   setFieldName(const string & fieldName) { _concreteFieldDrv->setFieldName(fieldName); }
 270   virtual string getFieldName() const { return MED_FIELD_DRIVER<T>::getFieldName(); }
 271 private:
 272   virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_RDONLY_DRIVER<T>(*this); }
 273 protected:
 274   GENDRIVER * _concreteFieldDrv;
 275 };
 276
 277 template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual IMED_FIELD_WRONLY_DRIVER<T> {
 278 public :
 279   MED_FIELD_WRONLY_DRIVER();
 280   MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField);
 281
 282   MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver):IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver) { _concreteFieldDrv = fieldDriver._concreteFieldDrv->copy(); }
 283   virtual ~MED_FIELD_WRONLY_DRIVER() {    if (_concreteFieldDrv) delete _concreteFieldDrv;}
 284   virtual void read ( void ) throw (MEDEXCEPTION) { _concreteFieldDrv->read(); }
 285   virtual void write( void ) const throw (MEDEXCEPTION) { _concreteFieldDrv->write(); }
 286   virtual void open() throw (MEDEXCEPTION) { _concreteFieldDrv->open(); }
 287   virtual void close() { _concreteFieldDrv->close(); }
 288   virtual void   setFieldName(const string & fieldName) { _concreteFieldDrv->setFieldName(fieldName); }
 289   virtual string getFieldName() const { return MED_FIELD_DRIVER<T>::getFieldName(); }
 290 private:
 291   virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_WRONLY_DRIVER<T>(*this); }
 292 protected:
 293   GENDRIVER * _concreteFieldDrv;
 294 };
 295
 296 template <class T> class MED_FIELD_RDWR_DRIVER : public virtual IMED_FIELD_RDWR_DRIVER<T> {
 297 public:
 298   MED_FIELD_RDWR_DRIVER();
 299   /*!
 300     Constructor.
 301   */
 302   MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField);
 303
 304   MED_FIELD_RDWR_DRIVER(const MED_FIELD_RDWR_DRIVER & fieldDriver):
 305     IMED_FIELD_RDWR_DRIVER<T>(fieldDriver)
 306   { _concreteFieldDrv = fieldDriver._concreteFieldDrv->copy(); }
 307   ~MED_FIELD_RDWR_DRIVER() {    if (_concreteFieldDrv) delete _concreteFieldDrv;}
 308   virtual void read ( void ) throw (MEDEXCEPTION) { _concreteFieldDrv->read(); }
 309   virtual void write( void ) const throw (MEDEXCEPTION) { _concreteFieldDrv->write(); }
 310   virtual void open() throw (MEDEXCEPTION) { _concreteFieldDrv->open(); }
 311   virtual void close() { _concreteFieldDrv->close(); }
 312   virtual void   setFieldName(const string & fieldName) { _concreteFieldDrv->setFieldName(fieldName); }
 313   virtual string getFieldName() const { return MED_FIELD_DRIVER<T>::getFieldName(); }
 314 private:
 315   virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_RDWR_DRIVER<T>(*this); }
 316 protected:
 317   GENDRIVER * _concreteFieldDrv;
 318 };
 319 }
 320
 321 /*-------------------------*/
 322 /* template implementation */
 323 /*-------------------------*/
 324 /*--------------------- DRIVER PART -------------------------------*/
 325
 326 // template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
 327 // {
 328 //   _fieldName = fieldName;
 329 // }
 330
 331 // template <class T> string  MED_FIELD_DRIVER<T>::getFieldName() const
 332 // {
 333 //   return _fieldName;
 334 // }
 335
 336 #include "MEDMEM_DriverFactory.hxx"
 337 #include "MEDMEM_MedFieldDriver21.hxx"
 338 #include "MEDMEM_MedFieldDriver22.hxx"
 339
 340
 341 /*--------------------- RDONLY PART -------------------------------*/
 342 namespace MEDMEM {
 343
 344 template <class T> void IMED_FIELD_RDONLY_DRIVER<T>::write( void ) const
 345   throw (MEDEXCEPTION)
 346 {
 347   throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 348 }
 349
 350 template <class T>  MED_FIELD_RDONLY_DRIVER<T>::MED_FIELD_RDONLY_DRIVER() {
 351     MESSAGE("You are using the default constructor of the Field read only Driver and it is 2.1 one");
 352     _concreteFieldDrv=new MED_FIELD_RDONLY_DRIVER21<T>();
 353 }
 354
 355 template <class T>  MED_FIELD_RDONLY_DRIVER<T>::MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField)
 356 {
 357     BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 358
 359     _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_LECT);
 360
 361     END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 362 }
 363
 364 /*--------------------- WRONLY PART -------------------------------*/
 365
 366 template <class T> void IMED_FIELD_WRONLY_DRIVER<T>::read (void)
 367   throw (MEDEXCEPTION)
 368 {
 369   throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 370 }
 371
 372 template <class T>  MED_FIELD_WRONLY_DRIVER<T>::MED_FIELD_WRONLY_DRIVER() {
 373     MESSAGE("You are using the default constructor of the Field write only Driver and it is 2.1 one");
 374
 375     _concreteFieldDrv=new MED_FIELD_WRONLY_DRIVER21<T>();
 376 }
 377
 378 template <class T>  MED_FIELD_WRONLY_DRIVER<T>::MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField)
 379   {
 380     BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 381
 382     _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_ECRI);
 383
 384     END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 385 }
 386
 387 /*--------------------- RDWR PART -------------------------------*/
 388
 389 template <class T>  MED_FIELD_RDWR_DRIVER<T>::MED_FIELD_RDWR_DRIVER() {
 390     MESSAGE("You are using the default constructor of the Field read/write Driver and it is 2.1 one");
 391
 392     _concreteFieldDrv=new MED_FIELD_RDWR_DRIVER21<T>();
 393 }
 394
 395 template <class T>  MED_FIELD_RDWR_DRIVER<T>::MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField)
 396   {
 397     BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 398
 399     _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_REMP);
 400
 401     END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
 402 }
 403
 404
 405 }//End namespace MEDMEM
 406 /*-----------------------------------------------------------------*/
 407
 408 #endif /* MED_FIELD_DRIVER_HXX */