src/MEDMEM/MEDMEM_MedFieldDriver.hxx

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