source: XIOS/dev/XIOS_DEV_CMIP6/src/attribute_template_impl.hpp @ 1478

Last change on this file since 1478 was 1478, checked in by oabramkina, 2 years ago

Exception handling for attributes by means of dynamic binding. This assures that attribute's id will always be printed in the error message.

Replacing changes done in r1477.

  • 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.5 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         void CAttributeTemplate<T>::toBinary (StdOStream & os) const
206      {
207         this->getValue()->toBinary(os);
208      }
209
210      template <class T>
211         void CAttributeTemplate<T>::fromBinary(StdIStream & is)
212      {
213         T value;
214         FromBinary(is, value);
215         this->setValue(value);
216      }
217*/
218      template <class T>
219         bool CAttributeTemplate<T>::_toBuffer (CBufferOut& buffer) const
220      {
221         return CType<T>::toBuffer(buffer) ;
222/*
223         if (isEmpty()) return buffer.put(true) ;
224         else
225         {
226           bool ret=true ;
227           CType<T> val(*boost::any_cast<T>(&value)) ;
228           ret&=buffer.put(false) ;
229           ret&=val.toBuffer(buffer) ;
230           return ret ;
231         }
232*/
233      }
234
235      template <class T>
236      bool CAttributeTemplate<T>::_fromBuffer(CBufferIn& buffer)
237      {
238        return CType<T>::fromBuffer(buffer) ;
239/*
240        bool empty ;
241        bool ret=true ;
242        ret&=buffer.get(empty) ;
243        if (empty)
244        {
245          clear() ;
246          return ret ;
247        }
248        else
249        {
250          if (isEmpty())
251          {
252            T val ;
253            setValue(val) ;
254          }
255          T* V=const_cast<T*>(boost::any_cast<T>(&value)) ;
256          CType<T> val(*V) ;
257          return val.fromBuffer(buffer) ;
258        }
259*/
260      }
261/*
262      template <class T>
263      size_t CAttributeTemplate<T>::size(void) const
264      {
265        return CType<T>::size() ;*/
266/*
267        if (isEmpty()) return sizeof(bool) ;
268        else
269        {
270          CType<T> val(*const_cast<T*>(boost::any_cast<T>(&value))) ;
271          return val.size()+sizeof(bool) ;
272        }
273*/
274 /*     }*/
275
276      template <typename T>
277      void CAttributeTemplate<T>::generateCInterface(ostream& oss,const string& className)
278      {
279        CInterface::AttributeCInterface<T>(oss, className, this->getName());
280      }
281
282      template <typename T>
283      void CAttributeTemplate<T>::generateFortran2003Interface(ostream& oss,const string& className)
284      {
285        CInterface::AttributeFortran2003Interface<T>(oss, className, this->getName());
286      }
287
288      template <typename T>
289      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className)
290      {
291        CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName() + "_");
292      }
293
294      template <typename T>
295      void CAttributeTemplate<T>::generateFortranInterfaceBody_(ostream& oss,const string& className)
296      {
297        CInterface::AttributeFortranInterfaceBody<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>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className)
308      {
309        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName() + "_");
310      }
311
312
313      template <typename T>
314      void CAttributeTemplate<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className)
315      {
316        CInterface::AttributeFortranInterfaceGetBody<T>(oss, className, this->getName());
317      }
318
319      template <typename T>
320      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className)
321      {
322        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName());
323      }
324
325
326/*
327      //---------------------------------------------------------------
328
329      // Spécialisations des templates pour la fonction [toString]
330
331      template <>
332         StdString CAttributeTemplate<bool>::toString(void) const;
333
334      //---------------------------------------------------------------
335
336      // Spécialisations des templates pour la fonction [fromString]
337
338      template <> // Chaîne de caractÚres.
339         void CAttributeTemplate<StdString>::fromString(const StdString & str);
340
341      template <> // Entier
342         void CAttributeTemplate<int>::fromString(const StdString & str);
343
344      template <> // Booléen
345         void CAttributeTemplate<bool>::fromString(const StdString & str);
346
347      template <> // Double
348         void CAttributeTemplate<double>::fromString(const StdString & str);
349
350      template<> // Tableau
351         void CAttributeTemplate<ARRAY(double, 1)>::fromString(const StdString & str);
352
353      //---------------------------------------------------------------
354
355      // Spécialisations des templates pour la fonction [toBinary] //
356
357      template <> // Chaîne de caractÚres.
358         void CAttributeTemplate<StdString>::toBinary (StdOStream & os) const;
359
360      template <> // Entier
361         void CAttributeTemplate<int>::toBinary(StdOStream & os) const;
362
363      template <> // Booléen
364         void CAttributeTemplate<bool>::toBinary(StdOStream & os) const;
365
366      template <> // Double
367         void CAttributeTemplate<double>::toBinary(StdOStream & os) const;
368
369      //---------------------------------------------------------------
370
371      // Spécialisations des templates pour la fonction [fromBinary] //
372
373      template <> // Chaîne de caractÚres.
374         void CAttributeTemplate<StdString>::fromBinary(StdIStream & is);
375
376      template <> // Entier
377         void CAttributeTemplate<int>::fromBinary(StdIStream & is);
378
379      template <> // Booléen
380         void CAttributeTemplate<bool>::fromBinary(StdIStream & is);
381
382      template <> // Double
383         void CAttributeTemplate<double>::fromBinary(StdIStream & is);
384
385      ///--------------------------------------------------------------
386*/
387} // namespace xios
388
389#endif // __XIOS_CAttributeTemplate_impl__
Note: See TracBrowser for help on using the repository browser.