source: XIOS/dev/dev_olga/src/attribute_template_impl.hpp @ 1612

Last change on this file since 1612 was 1612, checked in by oabramkina, 21 months ago

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 11.8 KB
Line 
1#ifndef __XIOS_CAttributeTemplate_impl__
2#define __XIOS_CAttributeTemplate_impl__
3
4#include "type.hpp"
5#include "buffer_in.hpp"
6#include "buffer_out.hpp"
7#include "generate_interface.hpp"
8#include "attribute_template.hpp"
9
10
11namespace xios
12{
13
14      /// ////////////////////// Définitions ////////////////////// ///
15      template <class T>
16         CAttributeTemplate<T>::CAttributeTemplate(const StdString & id)
17         : CAttribute(id)
18      { /* Ne rien faire de plus */ }
19
20      template <class T>
21         CAttributeTemplate<T>::CAttributeTemplate(const StdString & id, const T & value)
22         : CAttribute(id)
23      {
24         this->setValue(value);
25      }
26/*
27      template <class T>
28         CAttributeTemplate<T>::CAttributeTemplate(const CAttribute & attribut)
29         throw (CException)
30         : CAttribute(attribut)
31      {
32         if (!attribut.isEmpty() && !attribut.isType<T>())
33            ERROR("CAttributeTemplate", << "Invalid instantiation !");
34      }
35*/
36      template <class T>
37         CAttributeTemplate<T>::CAttributeTemplate(const StdString & id,
38                              xios_map<StdString, CAttribute*> & umap)
39         : CAttribute(id)
40      {
41         umap.insert(umap.end(), std::make_pair(id, this));
42      }
43
44      template <class T>
45         CAttributeTemplate<T>::CAttributeTemplate
46            (const StdString & id, const T & value,
47             xios_map<StdString, CAttribute*> & umap)
48         : CAttribute(id)
49      {
50         this->setValue(value);
51         umap.insert(umap.end(), std::make_pair(id, this));
52      }
53/*
54      template <class T>
55      CAttributeTemplate<T>::~CAttributeTemplate(void)
56      {
57//         this->CType<T>::reset() ;
58//         this->clear();
59      }
60*/
61      ///--------------------------------------------------------------
62      template <class T>
63      void CAttributeTemplate<T>::reset(void)
64      {
65        CType<T>::reset() ;
66        inheritedValue.reset() ;
67      }
68
69      template <class T>
70      void CAttributeTemplate<T>::checkEmpty(void) const
71      {
72        if (CType<T>::empty)
73        {
74          StdString msg("On checking attribute with id=");
75          msg.append(this->getId());
76          msg.append(" : ");
77          msg.append("data is not initialized\n");
78          ERROR("template <typename T> void CType<T>::checkEmpty(void) const", << msg);
79        }
80      }
81
82
83      template <class T>
84         T CAttributeTemplate<T>::getValue(void) const
85      {
86        return CType<T>::get() ;
87
88/*
89        if (SuperClass::isEmpty())
90        {
91           ERROR("T CAttributeTemplate<T>::getValue(void) const",
92                 << "[ id = " << this->getId() << "]"
93                 << " L'attribut est requis mais n'est pas défini !");
94         }
95        return (SuperClass::getValue<T>());
96*/
97      }
98
99/*
100      template <class T>
101         T* CAttributeTemplate<T>::getRef(void)
102      {
103         if (SuperClass::isEmpty())
104         {
105            ERROR("T CAttributeTemplate<T>::getValue(void) const",
106                  << "[ id = " << this->getId() << "]"
107                  << " L'attribut est requis mais n'est pas défini !");
108          }
109         return (SuperClass::getRef<T>());
110      }
111*/
112
113      template <class T>
114         void CAttributeTemplate<T>::setValue(const T & value)
115      {
116         CType<T>::set(value) ;
117//         SuperClass::setValue<T>(value);
118      }
119
120    template <class T>
121    void CAttributeTemplate<T>::set(const CAttribute& attr)
122    {
123      this->set(dynamic_cast<const CAttributeTemplate<T>& >(attr)) ;
124    }
125
126   template <class T>
127    void CAttributeTemplate<T>::set(const CAttributeTemplate& attr)
128    {
129      CType<T>::set(attr) ;
130    }
131
132    template <class T>
133    void CAttributeTemplate<T>::setInheritedValue(const CAttribute& attr)
134    {
135      this->setInheritedValue(dynamic_cast<const CAttributeTemplate<T>& >(attr)) ;
136    }
137
138    template <class T>
139    void CAttributeTemplate<T>::setInheritedValue(const CAttributeTemplate& attr)
140    {
141      if (this->isEmpty() && _canInherite && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()) ;
142    }
143
144    template <class T>
145    T CAttributeTemplate<T>::getInheritedValue(void) const
146    {
147      if (this->isEmpty()) return inheritedValue.get() ;
148      else return getValue() ;
149    }
150
151    template <class T>
152    bool CAttributeTemplate<T>::hasInheritedValue(void) const
153    {
154      return !this->isEmpty() || !inheritedValue.isEmpty() ;
155    }
156
157    template <class T>
158    bool CAttributeTemplate<T>::isEqual(const CAttribute& attr)
159    {
160      const CAttributeTemplate<T>& tmp = dynamic_cast<const CAttributeTemplate<T>& >(attr);
161      return this->isEqual_(tmp);
162    }
163
164    template <class T>
165    bool CAttributeTemplate<T>::isEqual_(const CAttributeTemplate& attr)
166    {
167      if ((!this->hasInheritedValue() && !attr.hasInheritedValue()))
168          return true;
169      if (this->hasInheritedValue() && attr.hasInheritedValue())
170          return (this->getInheritedValue() == attr.getInheritedValue());
171      else 
172        return false;
173    }
174
175      //---------------------------------------------------------------
176
177      template <class T>
178         CAttributeTemplate<T>& CAttributeTemplate<T>::operator=(const T & value)
179      {
180         this->setValue(value);
181//         return (this->getValue());
182         return *this;
183      }
184
185      //---------------------------------------------------------------
186
187      template <class T>
188         StdString CAttributeTemplate<T>::_toString(void) const
189      {
190         StdOStringStream oss;
191         if (!CType<T>::isEmpty() && this->hasId())
192            oss << this->getName() << "=\"" << CType<T>::toString() << "\"";
193         return (oss.str());
194      }
195
196      template <class T>
197         void CAttributeTemplate<T>::_fromString(const StdString & str)
198      {
199        CType<T>::fromString(str) ;
200      }
201
202      //---------------------------------------------------------------
203
204      template <class T>
205         StdString CAttributeTemplate<T>::_dump(void) const
206      {
207         StdOStringStream oss;
208         if (!CType<T>::isEmpty() && this->hasId())
209            oss << this->getName() << "=\"" << CType<T>::dump() << "\"";
210         return (oss.str());
211      }
212
213
214      //---------------------------------------------------------------
215/*
216      template <class T>
217         void CAttributeTemplate<T>::toBinary (StdOStream & os) const
218      {
219         this->getValue()->toBinary(os);
220      }
221
222      template <class T>
223         void CAttributeTemplate<T>::fromBinary(StdIStream & is)
224      {
225         T value;
226         FromBinary(is, value);
227         this->setValue(value);
228      }
229*/
230      template <class T>
231         bool CAttributeTemplate<T>::_toBuffer (CBufferOut& buffer) const
232      {
233         return CType<T>::toBuffer(buffer) ;
234/*
235         if (isEmpty()) return buffer.put(true) ;
236         else
237         {
238           bool ret=true ;
239           CType<T> val(*boost::any_cast<T>(&value)) ;
240           ret&=buffer.put(false) ;
241           ret&=val.toBuffer(buffer) ;
242           return ret ;
243         }
244*/
245      }
246
247      template <class T>
248      bool CAttributeTemplate<T>::_fromBuffer(CBufferIn& buffer)
249      {
250        return CType<T>::fromBuffer(buffer) ;
251/*
252        bool empty ;
253        bool ret=true ;
254        ret&=buffer.get(empty) ;
255        if (empty)
256        {
257          clear() ;
258          return ret ;
259        }
260        else
261        {
262          if (isEmpty())
263          {
264            T val ;
265            setValue(val) ;
266          }
267          T* V=const_cast<T*>(boost::any_cast<T>(&value)) ;
268          CType<T> val(*V) ;
269          return val.fromBuffer(buffer) ;
270        }
271*/
272      }
273/*
274      template <class T>
275      size_t CAttributeTemplate<T>::size(void) const
276      {
277        return CType<T>::size() ;*/
278/*
279        if (isEmpty()) return sizeof(bool) ;
280        else
281        {
282          CType<T> val(*const_cast<T*>(boost::any_cast<T>(&value))) ;
283          return val.size()+sizeof(bool) ;
284        }
285*/
286 /*     }*/
287
288      template <typename T>
289      void CAttributeTemplate<T>::generateCInterface(ostream& oss,const string& className)
290      {
291        CInterface::AttributeCInterface<T>(oss, className, this->getName());
292      }
293
294      template <typename T>
295      void CAttributeTemplate<T>::generateFortran2003Interface(ostream& oss,const string& className)
296      {
297        CInterface::AttributeFortran2003Interface<T>(oss, className, this->getName());
298      }
299
300      template <typename T>
301      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className)
302      {
303        CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName() + "_");
304      }
305
306      template <typename T>
307      void CAttributeTemplate<T>::generateFortranInterfaceBody_(ostream& oss,const string& className)
308      {
309        CInterface::AttributeFortranInterfaceBody<T>(oss, className, this->getName());
310      }
311
312      template <typename T>
313      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className)
314      {
315        CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName());
316      }
317
318      template <typename T>
319      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className)
320      {
321        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName() + "_");
322      }
323
324
325      template <typename T>
326      void CAttributeTemplate<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className)
327      {
328        CInterface::AttributeFortranInterfaceGetBody<T>(oss, className, this->getName());
329      }
330
331      template <typename T>
332      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className)
333      {
334        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName());
335      }
336
337
338/*
339      //---------------------------------------------------------------
340
341      // Spécialisations des templates pour la fonction [toString]
342
343      template <>
344         StdString CAttributeTemplate<bool>::toString(void) const;
345
346      //---------------------------------------------------------------
347
348      // Spécialisations des templates pour la fonction [fromString]
349
350      template <> // Chaîne de caractÚres.
351         void CAttributeTemplate<StdString>::fromString(const StdString & str);
352
353      template <> // Entier
354         void CAttributeTemplate<int>::fromString(const StdString & str);
355
356      template <> // Booléen
357         void CAttributeTemplate<bool>::fromString(const StdString & str);
358
359      template <> // Double
360         void CAttributeTemplate<double>::fromString(const StdString & str);
361
362      template<> // Tableau
363         void CAttributeTemplate<ARRAY(double, 1)>::fromString(const StdString & str);
364
365      //---------------------------------------------------------------
366
367      // Spécialisations des templates pour la fonction [toBinary] //
368
369      template <> // Chaîne de caractÚres.
370         void CAttributeTemplate<StdString>::toBinary (StdOStream & os) const;
371
372      template <> // Entier
373         void CAttributeTemplate<int>::toBinary(StdOStream & os) const;
374
375      template <> // Booléen
376         void CAttributeTemplate<bool>::toBinary(StdOStream & os) const;
377
378      template <> // Double
379         void CAttributeTemplate<double>::toBinary(StdOStream & os) const;
380
381      //---------------------------------------------------------------
382
383      // Spécialisations des templates pour la fonction [fromBinary] //
384
385      template <> // Chaîne de caractÚres.
386         void CAttributeTemplate<StdString>::fromBinary(StdIStream & is);
387
388      template <> // Entier
389         void CAttributeTemplate<int>::fromBinary(StdIStream & is);
390
391      template <> // Booléen
392         void CAttributeTemplate<bool>::fromBinary(StdIStream & is);
393
394      template <> // Double
395         void CAttributeTemplate<double>::fromBinary(StdIStream & is);
396
397      ///--------------------------------------------------------------
398*/
399} // namespace xios
400
401#endif // __XIOS_CAttributeTemplate_impl__
Note: See TracBrowser for help on using the repository browser.