1 #ifndef MED_FIELD_DRIVER_HXX
2 #define MED_FIELD_DRIVER_HXX
6 #include "MEDMEM_define.hxx"
8 #include "MEDMEM_GenDriver.hxx"
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"
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;
25 template <class T> class MED_FIELD_DRIVER : public GENDRIVER
35 // all MED cell type ?? Classe de Définition ??
36 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
38 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
43 MED_FIELD_DRIVER():_ptrField((FIELD<T> *) NULL),
44 _fieldName(""),_fieldNum(MED_INVALID)
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)
60 MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
61 GENDRIVER(fieldDriver),
62 _ptrField(fieldDriver._ptrField),
63 _fieldName(fieldDriver._fieldName),
64 _fieldNum(fieldDriver._fieldNum)
71 virtual ~MED_FIELD_DRIVER()
73 MESSAGE("MED_FIELD_DRIVER::~MED_FIELD_DRIVER() has been destroyed");
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 ;
81 Set the name of the FIELD asked in file.
83 It could be different than the name of the FIELD object.
85 virtual void setFieldName(const string & fieldName) { _fieldName = fieldName; }
87 Get the name of the FIELD asked in file.
89 virtual string getFieldName() const { return _fieldName; }
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>;
99 Driver Med for FIELD : Read only.
101 Implement read method.
105 template <class T> class IMED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
113 IMED_FIELD_RDONLY_DRIVER() {}
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)");
127 IMED_FIELD_RDONLY_DRIVER(const IMED_FIELD_RDONLY_DRIVER & fieldDriver):
128 MED_FIELD_DRIVER<T>(fieldDriver) {}
133 virtual ~IMED_FIELD_RDONLY_DRIVER() {}
135 // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
138 Return a MEDEXCEPTION : it is the read-only driver.
140 void write( void ) const throw (MEDEXCEPTION) ;
142 friend class MED_FIELD_RDONLY_DRIVER<T>;
147 Driver Med for FIELD : Write only.
149 Implement write method.
153 template <class T> class IMED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
160 IMED_FIELD_WRONLY_DRIVER() {}
165 IMED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
166 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_WRONLY)
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)");
175 IMED_FIELD_WRONLY_DRIVER(const IMED_FIELD_WRONLY_DRIVER & fieldDriver):
176 MED_FIELD_DRIVER<T>(fieldDriver) {}
181 virtual ~IMED_FIELD_WRONLY_DRIVER() {};
183 Return a MEDEXCEPTION : it is the write-only driver.
185 void read ( void ) throw (MEDEXCEPTION) ;
187 friend class MED_FIELD_WRONLY_DRIVER<T>;
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
199 template <class T> class IMED_FIELD_RDWR_DRIVER : public virtual IMED_FIELD_RDONLY_DRIVER<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
206 IMED_FIELD_RDWR_DRIVER() {}
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)
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)");
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) {}
228 ~IMED_FIELD_RDWR_DRIVER() {}
230 friend class MED_FIELD_RDWR_DRIVER<T>;
237 template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual IMED_FIELD_RDONLY_DRIVER<T>
241 MED_FIELD_RDONLY_DRIVER();
242 MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField);
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(); }
253 virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_RDONLY_DRIVER<T>(*this); }
255 GENDRIVER * _concreteFieldDrv;
258 template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual IMED_FIELD_WRONLY_DRIVER<T> {
260 MED_FIELD_WRONLY_DRIVER();
261 MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField);
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(); }
272 virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_WRONLY_DRIVER<T>(*this); }
274 GENDRIVER * _concreteFieldDrv;
277 template <class T> class MED_FIELD_RDWR_DRIVER : public virtual IMED_FIELD_RDWR_DRIVER<T> {
279 MED_FIELD_RDWR_DRIVER();
283 MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField);
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(); }
296 virtual GENDRIVER * copy ( void ) const { return new MED_FIELD_RDWR_DRIVER<T>(*this); }
298 GENDRIVER * _concreteFieldDrv;
302 /*-------------------------*/
303 /* template implementation */
304 /*-------------------------*/
305 /*--------------------- DRIVER PART -------------------------------*/
307 // template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
309 // _fieldName = fieldName;
312 // template <class T> string MED_FIELD_DRIVER<T>::getFieldName() const
314 // return _fieldName;
317 #include "MEDMEM_DriverFactory.hxx"
318 #include "MEDMEM_MedFieldDriver21.hxx"
319 #include "MEDMEM_MedFieldDriver22.hxx"
322 /*--------------------- RDONLY PART -------------------------------*/
325 template <class T> void IMED_FIELD_RDONLY_DRIVER<T>::write( void ) const
328 throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
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>();
336 template <class T> MED_FIELD_RDONLY_DRIVER<T>::MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField)
338 BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
340 _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_LECT);
342 END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
345 /*--------------------- WRONLY PART -------------------------------*/
347 template <class T> void IMED_FIELD_WRONLY_DRIVER<T>::read (void)
350 throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
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");
356 _concreteFieldDrv=new MED_FIELD_WRONLY_DRIVER21<T>();
359 template <class T> MED_FIELD_WRONLY_DRIVER<T>::MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField)
361 BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
363 _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_ECRI);
365 END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
368 /*--------------------- RDWR PART -------------------------------*/
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");
373 _concreteFieldDrv=new MED_FIELD_RDWR_DRIVER21<T>();
376 template <class T> MED_FIELD_RDWR_DRIVER<T>::MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField)
378 BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
380 _concreteFieldDrv = DRIVERFACTORY::buildFieldDriverFromFile(fileName,ptrField,MED_EN::MED_REMP);
382 END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
386 }//End namespace MEDMEM
387 /*-----------------------------------------------------------------*/
389 #endif /* MED_FIELD_DRIVER_HXX */