source: XIOS/trunk/src/attribute_template_impl.hpp @ 775

Last change on this file since 775 was 775, checked in by mhnguyen, 7 years ago

Implementing the reading of attributes of an axis from a file

+) 3d grid can be read directly from a file
+) Clean some redundant codes
+) Add new attribute declaration that allows to output only desired attributes

Test
+) On Curie
+) test_remap passes and result is correct

  • 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.0 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
70      template <class T>
71         T CAttributeTemplate<T>::getValue(void) const
72      {
73         return CType<T>::get() ;
74/*
75         if (SuperClass::isEmpty())
76         {
77            ERROR("T CAttributeTemplate<T>::getValue(void) const",
78                  << "[ id = " << this->getId() << "]"
79                  << " L'attribut est requis mais n'est pas défini !");
80          }
81         return (SuperClass::getValue<T>());
82*/
83      }
84
85/*
86      template <class T>
87         T* CAttributeTemplate<T>::getRef(void)
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::getRef<T>());
96      }
97*/
98
99      template <class T>
100         void CAttributeTemplate<T>::setValue(const T & value)
101      {
102         CType<T>::set(value) ;
103//         SuperClass::setValue<T>(value);
104      }
105
106    template <class T>
107    void CAttributeTemplate<T>::set(const CAttribute& attr)
108    {
109      this->set(dynamic_cast<const CAttributeTemplate<T>& >(attr)) ;
110    }
111
112   template <class T>
113    void CAttributeTemplate<T>::set(const CAttributeTemplate& attr)
114    {
115      CType<T>::set(attr) ;
116    }
117
118    template <class T>
119    void CAttributeTemplate<T>::setInheritedValue(const CAttribute& attr)
120    {
121      this->setInheritedValue(dynamic_cast<const CAttributeTemplate<T>& >(attr)) ;
122    }
123
124    template <class T>
125    void CAttributeTemplate<T>::setInheritedValue(const CAttributeTemplate& attr)
126    {
127      if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()) ;
128    }
129
130    template <class T>
131    T CAttributeTemplate<T>::getInheritedValue(void) const
132    {
133      if (this->isEmpty()) return inheritedValue.get() ;
134      else return getValue() ;
135    }
136
137    template <class T>
138    bool CAttributeTemplate<T>::hasInheritedValue(void) const
139    {
140      return !this->isEmpty() || !inheritedValue.isEmpty() ;
141    }
142
143      //---------------------------------------------------------------
144
145      template <class T>
146         CAttributeTemplate<T>& CAttributeTemplate<T>::operator=(const T & value)
147      {
148         this->setValue(value);
149//         return (this->getValue());
150         return *this;
151      }
152
153      //---------------------------------------------------------------
154
155      template <class T>
156         StdString CAttributeTemplate<T>::_toString(void) const
157      {
158         StdOStringStream oss;
159         if (!CType<T>::isEmpty() && this->hasId())
160            oss << this->getName() << "=\"" << CType<T>::toString() << "\"";
161         return (oss.str());
162      }
163
164      template <class T>
165         void CAttributeTemplate<T>::_fromString(const StdString & str)
166      {
167        CType<T>::fromString(str) ;
168      }
169
170      //---------------------------------------------------------------
171/*
172      template <class T>
173         void CAttributeTemplate<T>::toBinary (StdOStream & os) const
174      {
175         this->getValue()->toBinary(os);
176      }
177
178      template <class T>
179         void CAttributeTemplate<T>::fromBinary(StdIStream & is)
180      {
181         T value;
182         FromBinary(is, value);
183         this->setValue(value);
184      }
185*/
186      template <class T>
187         bool CAttributeTemplate<T>::_toBuffer (CBufferOut& buffer) const
188      {
189         return CType<T>::toBuffer(buffer) ;
190/*
191         if (isEmpty()) return buffer.put(true) ;
192         else
193         {
194           bool ret=true ;
195           CType<T> val(*boost::any_cast<T>(&value)) ;
196           ret&=buffer.put(false) ;
197           ret&=val.toBuffer(buffer) ;
198           return ret ;
199         }
200*/
201      }
202
203      template <class T>
204      bool CAttributeTemplate<T>::_fromBuffer(CBufferIn& buffer)
205      {
206        return CType<T>::fromBuffer(buffer) ;
207/*
208        bool empty ;
209        bool ret=true ;
210        ret&=buffer.get(empty) ;
211        if (empty)
212        {
213          clear() ;
214          return ret ;
215        }
216        else
217        {
218          if (isEmpty())
219          {
220            T val ;
221            setValue(val) ;
222          }
223          T* V=const_cast<T*>(boost::any_cast<T>(&value)) ;
224          CType<T> val(*V) ;
225          return val.fromBuffer(buffer) ;
226        }
227*/
228      }
229/*
230      template <class T>
231      size_t CAttributeTemplate<T>::size(void) const
232      {
233        return CType<T>::size() ;*/
234/*
235        if (isEmpty()) return sizeof(bool) ;
236        else
237        {
238          CType<T> val(*const_cast<T*>(boost::any_cast<T>(&value))) ;
239          return val.size()+sizeof(bool) ;
240        }
241*/
242 /*     }*/
243
244      template <typename T>
245      void CAttributeTemplate<T>::generateCInterface(ostream& oss,const string& className)
246      {
247        if (this->isAttributePublic())
248          CInterface::AttributeCInterface<T>(oss, className, this->getName()) ;
249//        CInterface::AttributeIsDefinedCInterface(oss, className, this->getName()) ;
250      }
251
252      template <typename T>
253      void CAttributeTemplate<T>::generateFortran2003Interface(ostream& oss,const string& className)
254      {
255        if (this->isAttributePublic())
256          CInterface::AttributeFortran2003Interface<T>(oss, className, this->getName()) ;
257//        CInterface::AttributeIsDefinedFortran2003Interface(oss, className, this->getName()) ;
258      }
259
260      template <typename T>
261      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className)
262      {
263        if (this->isAttributePublic())
264          CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName()+"_") ;
265      }
266
267      template <typename T>
268      void CAttributeTemplate<T>::generateFortranInterfaceBody_(ostream& oss,const string& className)
269      {
270        if (this->isAttributePublic())
271          CInterface::AttributeFortranInterfaceBody<T>(oss, className, this->getName()) ;
272      }
273
274      template <typename T>
275      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className)
276      {
277        if (this->isAttributePublic())
278          CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName()) ;
279      }
280
281      template <typename T>
282      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className)
283      {
284        if (this->isAttributePublic())
285          CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName()+"_") ;
286      }
287
288
289      template <typename T>
290      void CAttributeTemplate<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className)
291      {
292        if (this->isAttributePublic())
293          CInterface::AttributeFortranInterfaceGetBody<T>(oss, className, this->getName()) ;
294      }
295
296      template <typename T>
297      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className)
298      {
299        if (this->isAttributePublic())
300          CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName()) ;
301      }
302
303
304/*
305      //---------------------------------------------------------------
306
307      // Spécialisations des templates pour la fonction [toString]
308
309      template <>
310         StdString CAttributeTemplate<bool>::toString(void) const;
311
312      //---------------------------------------------------------------
313
314      // Spécialisations des templates pour la fonction [fromString]
315
316      template <> // Chaîne de caractÚres.
317         void CAttributeTemplate<StdString>::fromString(const StdString & str);
318
319      template <> // Entier
320         void CAttributeTemplate<int>::fromString(const StdString & str);
321
322      template <> // Booléen
323         void CAttributeTemplate<bool>::fromString(const StdString & str);
324
325      template <> // Double
326         void CAttributeTemplate<double>::fromString(const StdString & str);
327
328      template<> // Tableau
329         void CAttributeTemplate<ARRAY(double, 1)>::fromString(const StdString & str);
330
331      //---------------------------------------------------------------
332
333      // Spécialisations des templates pour la fonction [toBinary] //
334
335      template <> // Chaîne de caractÚres.
336         void CAttributeTemplate<StdString>::toBinary (StdOStream & os) const;
337
338      template <> // Entier
339         void CAttributeTemplate<int>::toBinary(StdOStream & os) const;
340
341      template <> // Booléen
342         void CAttributeTemplate<bool>::toBinary(StdOStream & os) const;
343
344      template <> // Double
345         void CAttributeTemplate<double>::toBinary(StdOStream & os) const;
346
347      //---------------------------------------------------------------
348
349      // Spécialisations des templates pour la fonction [fromBinary] //
350
351      template <> // Chaîne de caractÚres.
352         void CAttributeTemplate<StdString>::fromBinary(StdIStream & is);
353
354      template <> // Entier
355         void CAttributeTemplate<int>::fromBinary(StdIStream & is);
356
357      template <> // Booléen
358         void CAttributeTemplate<bool>::fromBinary(StdIStream & is);
359
360      template <> // Double
361         void CAttributeTemplate<double>::fromBinary(StdIStream & is);
362
363      ///--------------------------------------------------------------
364*/
365} // namespace xios
366
367#endif // __XIOS_CAttributeTemplate_impl__
Note: See TracBrowser for help on using the repository browser.