src/MEDMEM/MEDMEM_MedFieldDriver.hxx

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