source: XIOS/trunk/src/type/type_specialisation.hpp @ 533

Last change on this file since 533 was 533, checked in by rlacroix, 8 years ago

Fix compilation after r532 by adding the new "icdate.hpp" file which had been forgotten.

  • 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: 14.5 KB
Line 
1#ifndef __XIOS_TYPE_SPECIALISATION_HPP__
2#define __XIOS_TYPE_SPECIALISATION_HPP__
3
4#include "xmlioserver_spl.hpp"
5#include "exception.hpp"
6#include "buffer_in.hpp"
7#include "buffer_out.hpp"
8#include "type.hpp"
9#include <string>
10#include <boost/algorithm/string.hpp>
11#include "date.hpp"
12 
13namespace xios
14{
15
16// template specialization for bool
17
18  template <> void CType<bool>::_fromString(const string& str)
19  {
20    string tmpStr=boost::to_lower_copy(boost::trim_copy(str)) ;
21    if (tmpStr=="true" || tmpStr==".true." || tmpStr=="yes" || tmpStr=="y") set(true) ;
22    else if (tmpStr=="false" || tmpStr==".false." || tmpStr=="no" || tmpStr=="n") set(false) ;
23    else ERROR("template <> CType<bool>::fromString(const string& str)",<< tmpStr << " cannot be converted in a boolean value") ;
24  }
25 
26  template <> string CType<bool>::_toString(void) const
27  {
28    if (get()) return string("true") ;
29    else return string("false") ;
30  }
31 
32  template <> void CType_ref<bool>::_fromString(const string& str) const
33  {
34    string tmpStr=boost::to_lower_copy(boost::trim_copy(str)) ;
35    if (tmpStr=="true" || tmpStr==".true." || tmpStr=="yes" || tmpStr=="y") set(true) ;
36    else if (tmpStr=="false" || tmpStr==".false." || tmpStr=="no" || tmpStr=="n") set(false) ;
37    else ERROR("template <> CType<bool>::fromString(const string& str)",<< tmpStr << " cannot be converted in a boolean value") ;
38  }
39 
40  template <> void CType_ref<bool>::_fromString(const string& str)
41  {
42    string tmpStr=boost::to_lower_copy(boost::trim_copy(str)) ;
43    if (tmpStr=="true" || tmpStr==".true." || tmpStr=="yes" || tmpStr=="y") set(true) ;
44    else if (tmpStr=="false" || tmpStr==".false." || tmpStr=="no" || tmpStr=="n") set(false) ;
45    else ERROR("template <> CType<bool>::fromString(const string& str)",<< tmpStr << " cannot be converted in a boolean value") ;
46  }
47 
48  template <> string CType_ref<bool>::_toString(void) const
49  {
50    if (get()) return string("true") ;
51    else return string("false") ;
52  }
53
54// template specialization for string
55
56  template <>
57  size_t CType<string>::_size() const
58  {
59    size_t typeSize=0 ;
60    typeSize+=sizeof(size_t) ;
61    typeSize+=ptrValue->size() ;
62    return typeSize ;
63  }
64
65  template <>
66  size_t CType_ref<string>::_size() const
67  {
68    size_t typeSize=0 ;
69    typeSize+=sizeof(size_t) ;
70    typeSize+=ptrValue->size() ;
71    return typeSize ;
72  }
73 
74  template <>
75  void CType<string>::_fromString(const string& str)
76  {
77    allocate() ;
78    *ptrValue=str ;
79  } 
80
81  template <>
82  void CType_ref<string>::_fromString(const string& str)
83  {
84    checkEmpty() ;
85    *ptrValue=str ;
86  } 
87
88  template <>
89  void CType_ref<string>::_fromString(const string& str) const
90  {
91    checkEmpty() ;
92    *ptrValue=str ;
93  } 
94 
95  template <>
96  bool CType<string>::_toBuffer(CBufferOut& buffer) const
97  {
98    if (buffer.remain()<size()) return false ;
99    else
100    {
101      bool ret=true ;
102      if (ret) ret&=buffer.put(ptrValue->size()) ;
103      if (ret) ret&=buffer.put(ptrValue->data(),ptrValue->size()) ;
104      return ret ;
105    }
106  }
107 
108  template <>
109  bool CType_ref<string>::_toBuffer(CBufferOut& buffer) const
110  {
111    if (buffer.remain()<size()) return false ;
112    else
113    {
114      bool ret=true ;
115      if (ret) ret&=buffer.put(ptrValue->size()) ;
116      if (ret) ret&=buffer.put(ptrValue->data(),ptrValue->size()) ;
117      return ret ;
118    }
119  }
120 
121 
122 
123  template <>
124  bool CType<string>::_fromBuffer(CBufferIn& buffer)
125  {
126    allocate() ;
127    bool ret=true ;
128    size_t typeSize ;
129    if (ret) ret&=buffer.get(typeSize) ;
130   
131    char* str;
132    str= (char*) buffer.ptr() ;
133    if (ret) buffer.advance(typeSize) ;
134    if (ret) *ptrValue=string(str,typeSize) ;
135   
136    return ret ;
137  } 
138
139  template <>
140  bool CType_ref<string>::_fromBuffer(CBufferIn& buffer) const
141  {
142    bool ret=true ;
143    size_t typeSize ;
144    if (ret) ret&=buffer.get(typeSize) ;
145   
146    char* str;
147    str= (char*) buffer.ptr() ;
148    if (ret) buffer.advance(typeSize) ;
149    if (ret) *ptrValue=string(str,typeSize) ;
150   
151    return ret ;
152  }   
153
154  template <>
155  bool CType_ref<string>::_fromBuffer(CBufferIn& buffer)
156  {
157    bool ret=true ;
158    size_t typeSize ;
159    if (ret) ret&=buffer.get(typeSize) ;
160   
161    char* str;
162    str= (char*) buffer.ptr() ;
163    if (ret) buffer.advance(typeSize) ;
164    if (ret) *ptrValue=string(str,typeSize) ;
165   
166    return ret ;
167  }     
168
169// template specializations for CDate
170
171  template <>
172  size_t CType<CDate>::_size() const
173  {
174    return 6 * sizeof(int);
175  }
176
177  template <>
178  size_t CType_ref<CDate>::_size() const
179  {
180    return 6 * sizeof(int);
181  }
182
183  template <>
184  bool CType<CDate>::_toBuffer(CBufferOut& buffer) const
185  {
186    if (buffer.remain() < size()) return false;
187    else
188    {
189      bool ret = true;
190      if (ret) ret &= buffer.put(ptrValue->getYear());
191      if (ret) ret &= buffer.put(ptrValue->getMonth());
192      if (ret) ret &= buffer.put(ptrValue->getDay());
193      if (ret) ret &= buffer.put(ptrValue->getHour());
194      if (ret) ret &= buffer.put(ptrValue->getMinute());
195      if (ret) ret &= buffer.put(ptrValue->getSecond());
196      return ret;
197    }
198  }
199 
200  template <>
201  bool CType_ref<CDate>::_toBuffer(CBufferOut& buffer) const
202  {
203    if (buffer.remain() < size()) return false;
204    else
205    {
206      bool ret = true;
207      if (ret) ret &= buffer.put(ptrValue->getYear());
208      if (ret) ret &= buffer.put(ptrValue->getMonth());
209      if (ret) ret &= buffer.put(ptrValue->getDay());
210      if (ret) ret &= buffer.put(ptrValue->getHour());
211      if (ret) ret &= buffer.put(ptrValue->getMinute());
212      if (ret) ret &= buffer.put(ptrValue->getSecond());
213      return ret;
214    }
215  }
216
217  template <>
218  bool CType<CDate>::_fromBuffer(CBufferIn& buffer)
219  {
220    allocate();
221    bool ret = true;
222
223    int year, month, day, hour, min, sec;
224    if (ret) ret &= buffer.get(year);
225    if (ret) ret &= buffer.get(month);
226    if (ret) ret &= buffer.get(day);
227    if (ret) ret &= buffer.get(hour);
228    if (ret) ret &= buffer.get(min);
229    if (ret) ret &= buffer.get(sec);
230    if (ret)
231    {
232      ptrValue->setYear(year);
233      ptrValue->setMonth(month);
234      ptrValue->setDay(day);
235      ptrValue->setHour(hour);
236      ptrValue->setMinute(min);
237      ptrValue->setSecond(sec);
238    }
239
240    return ret;
241  }
242
243  template <>
244  bool CType_ref<CDate>::_fromBuffer(CBufferIn& buffer) const
245  {
246    bool ret = true;
247   
248    int year, month, day, hour, min, sec;
249    if (ret) ret &= buffer.get(year);
250    if (ret) ret &= buffer.get(month);
251    if (ret) ret &= buffer.get(day);
252    if (ret) ret &= buffer.get(hour);
253    if (ret) ret &= buffer.get(min);
254    if (ret) ret &= buffer.get(sec);
255    if (ret)
256    {
257      ptrValue->setYear(year);
258      ptrValue->setMonth(month);
259      ptrValue->setDay(day);
260      ptrValue->setHour(hour);
261      ptrValue->setMinute(min);
262      ptrValue->setSecond(sec);
263    }
264
265    return ret;
266  }
267
268  template <>
269  bool CType_ref<CDate>::_fromBuffer(CBufferIn& buffer)
270  {
271    bool ret = true;
272   
273    int year, month, day, hour, min, sec;
274    if (ret) ret &= buffer.get(year);
275    if (ret) ret &= buffer.get(month);
276    if (ret) ret &= buffer.get(day);
277    if (ret) ret &= buffer.get(hour);
278    if (ret) ret &= buffer.get(min);
279    if (ret) ret &= buffer.get(sec);
280    if (ret)
281    {
282      ptrValue->setYear(year);
283      ptrValue->setMonth(month);
284      ptrValue->setDay(day);
285      ptrValue->setHour(hour);
286      ptrValue->setMinute(min);
287      ptrValue->setSecond(sec);
288    }
289
290    return ret;
291  }
292
293  // template specialisation for CArray
294/*
295  template<>
296  size_t CType< ARRAY(int, 1)>::size() const
297  {
298     return (*(this->ptrValue))->getSize() ;
299  }
300 
301  template <>
302  bool CType<ARRAY(int, 1)>::toBuffer(CBufferOut& buffer) const
303  {
304      return (*(this->ptrValue))->toBuffer(buffer) ;
305  }
306
307  template <>
308  bool CType<ARRAY(int, 1)>::fromBuffer(CBufferIn& buffer) const
309  {
310    return (*(this->ptrValue))->fromBuffer(buffer) ;
311  }
312
313  template <>
314  void CType<ARRAY(int, 1)>::fromString(const string& str) const
315  {
316 // to implement
317  }
318
319  template <>
320  string CType<ARRAY(int, 1)>::toString(void) const
321  {
322 // to implement
323   return string("") ;
324 
325  }
326*/
327
328
329/*
330template<size_t numDim>
331boost::detail::multi_array::extent_gen<numDim> getExtentNull(void) { return getExtentNull<numDim-1>()[0];}
332
333template<>
334boost::detail::multi_array::extent_gen<1> getExtentNull<1>(void) { return extents[0]; }
335*/
336/*
337#define CTYPE_ARRAY(ValueType,NumsDims)                                \
338                                                                       \
339  template <>                                                          \
340  void CType<ARRAY(ValueType,NumsDims)>::allocate(void)  \
341  {                                                                    \
342    if (empty) ptrValue=new shared_ptr<CArray<ValueType, NumsDims> >(new  CArray<ValueType, NumsDims>()) ;\
343    empty=false ;                                                      \
344  }                                                                    \
345                                                                        \   
346  template<>                                                           \
347  size_t CType< ARRAY(ValueType,NumsDims)>::_size() const               \
348  {                                                                    \
349     return (*(this->ptrValue))->getSize() ;                           \
350  }                                                                    \
351                                                                       \
352  template<>                                                           \
353  size_t CType_ref< ARRAY(ValueType,NumsDims)>::_size() const           \
354  {                                                                    \
355     return (*(this->ptrValue))->getSize() ;                           \
356  }                                                                    \
357                                                                       \
358  template <>                                                          \
359  bool CType<ARRAY(ValueType,NumsDims)>::_toBuffer(CBufferOut& buffer) const        \
360  {                                                                    \
361      return (*(this->ptrValue))->toBuffer(buffer) ;                   \
362  }                                                                    \
363                                                                       \
364  template <>                                                          \
365  bool CType_ref<ARRAY(ValueType,NumsDims)>::_toBuffer(CBufferOut& buffer) const        \
366  {                                                                    \
367      return (*(this->ptrValue))->toBuffer(buffer) ;                   \
368  }                                                                    \
369                                                                       \
370  template <>                                                          \
371  bool CType<ARRAY(ValueType,NumsDims)>::_fromBuffer(CBufferIn& buffer)       \
372  {                                                                    \
373    allocate();                                                        \
374    return (*(ptrValue))->fromBuffer(buffer) ;                         \
375  }                                                                    \
376                                                                       \
377  template <>                                                          \
378  bool CType_ref<ARRAY(ValueType,NumsDims)>::_fromBuffer(CBufferIn& buffer) const  \
379  {                                                                    \
380    checkEmpty() ;                                                     \
381    return (*(this->ptrValue))->fromBuffer(buffer) ;                   \
382  }                                                                    \
383                                                                       \
384 template <>                                                          \
385  bool CType_ref<ARRAY(ValueType,NumsDims)>::_fromBuffer(CBufferIn& buffer)   \
386  {                                                                    \
387    shared_ptr<CArray<ValueType, NumsDims> > tmp(new CArray<ValueType, NumsDims>() ) ; \
388    *(this->ptrValue)=tmp ;\
389    return (*(this->ptrValue))->fromBuffer(buffer) ;                   \
390  }                                                                    \
391                                                                       \
392                                                                       \
393  template <>                                                          \
394  void CType<ARRAY(ValueType,NumsDims)>::_fromString(const string& str)       \
395  {                                                                    \
396                                      \
397  }                                                                    \
398                                                                       \
399  template <>                                                          \
400  void CType_ref<ARRAY(ValueType,NumsDims)>::_fromString(const string& str) const \
401  {                                                                    \
402                                        \
403  }                                                                    \
404  template <>                                                          \
405  void CType_ref<ARRAY(ValueType,NumsDims)>::_fromString(const string& str) \
406  {                                                                    \
407                                                \
408  }                                                                    \
409                                                                          \
410  template <>                                                          \
411  string CType<ARRAY(ValueType,NumsDims)>::_toString(void) const                    \
412  {                                                                    \
413                               \
414   return string("") ;                                                 \
415  }                                                                    \
416                                                                          \
417  template <>                                                          \
418  string CType_ref<ARRAY(ValueType,NumsDims)>::_toString(void) const                    \
419  {                                                                    \
420                                      \
421   return string("") ;                                                 \
422  }
423//CTYPE_ARRAY(double,1)
424
425//CTYPE_ARRAY(double,2)
426
427
428CTYPE_ARRAY(int,1)
429CTYPE_ARRAY(int,2)
430CTYPE_ARRAY(int,3)
431CTYPE_ARRAY(bool,1)
432CTYPE_ARRAY(bool,2)
433CTYPE_ARRAY(bool,3)
434CTYPE_ARRAY(double,1)
435CTYPE_ARRAY(double,2)
436CTYPE_ARRAY(double,3)
437CTYPE_ARRAY(float,1)
438CTYPE_ARRAY(float,2)
439CTYPE_ARRAY(float,3)
440*/
441} 
442
443#endif 
Note: See TracBrowser for help on using the repository browser.