source: XIOS/trunk/src/type/type_impl.hpp @ 680

Last change on this file since 680 was 680, checked in by rlacroix, 6 years ago

Rephrase some error messages so that they are clearer.

  • 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: 4.4 KB
Line 
1#ifndef __XIOS_TYPE_IMPL__
2#define __XIOS_TYPE_IMPL__
3
4#include "xios_spl.hpp"
5#include "exception.hpp"
6#include "buffer_in.hpp"
7#include "buffer_out.hpp"
8#include "message.hpp"
9
10
11
12
13namespace xios
14{
15 
16  using namespace std;
17 
18  template <typename T>
19  CType<T>::CType(void)
20  {
21    empty=true ;
22  }
23   
24  template <typename T>
25  CType<T>::CType(const T& val)
26  {
27    empty=true ;
28    set(val) ;
29  }
30 
31  template <typename T>
32  CType<T>::CType(const CType<T>& type)
33  {
34    empty=true ;
35    set(type) ;
36  }
37
38  template <typename T>
39  CType<T>::CType(const CType_ref<T>& type)
40  {
41    empty=true ;
42    set(type) ;
43  } 
44 
45  template <typename T>
46  void CType<T>::set(const T& val)
47  {
48    if (empty) 
49    { 
50      ptrValue = new T(val) ;
51      empty=false ;
52    }
53    else *ptrValue = val ;
54  }
55
56  template <typename T>
57  void CType<T>::set(const CType<T>& type)
58  {
59    if (type.isEmpty()) reset() ;
60    else
61    {
62      if (empty)
63      { 
64        ptrValue = new T(*type.ptrValue) ;
65        empty=false ;
66      }
67      else *ptrValue = *type.ptrValue ;
68    }
69  }
70
71  template <typename T>
72  void CType<T>::set(const CType_ref<T>& type)
73  {
74    if (type.isEmpty()) reset() ;
75    else
76    {
77      if (empty)
78      { 
79        ptrValue = new T(*type.ptrValue) ;
80        empty=false ;
81      }
82      else *ptrValue = *type.ptrValue ;
83    }
84  }
85
86  template <typename T>
87  T& CType<T>::get(void)
88  {
89    checkEmpty();
90   return *ptrValue ;
91  }
92
93  template <typename T>
94  const T& CType<T>::get(void) const
95  {
96    checkEmpty();
97    return *ptrValue ;
98  }
99 
100  template <typename T>
101  CType<T>& CType<T>::operator = (const T& val)
102  {
103    set(val) ;
104    return *this ;
105  }
106 
107  template <typename T>
108  CType<T>& CType<T>::operator = (const CType<T>& type)
109  {
110    set(type) ;
111    return *this ;
112  }
113 
114  template <typename T>
115  CType<T>& CType<T>::operator = (const CType_ref<T>& type)
116  {
117    set(type) ;
118    return *this ;
119  }
120 
121   template <typename T>
122   CType<T>::operator T&()
123   {
124    checkEmpty();
125    return *ptrValue ;
126   }
127
128   template <typename T>
129   CType<T>* CType<T>::_clone(void) const
130   {
131     checkEmpty();
132     return new CType(*this) ;
133   }
134
135 
136  template <typename T>
137  void CType<T>::_fromString(const string& str)
138  {
139    istringstream iss(str);
140    allocate() ;
141    iss>>*ptrValue ;
142  }
143
144  template <typename T>
145  size_t CType<T>::_size(void) const
146  {
147    return sizeof(T) ;
148  }
149 
150  template <typename T>
151  bool CType<T>::_isEmpty(void) const
152  {
153    return empty ;
154  }
155 
156  template <typename T>
157  string CType<T>::_toString(void) const
158  {
159    ostringstream oss;
160    checkEmpty();
161    oss<<*ptrValue ;
162    return oss.str() ;
163  }
164 
165  template <typename T>
166  bool CType<T>::_toBuffer(CBufferOut& buffer) const
167  {
168    checkEmpty();
169    return buffer.put(*ptrValue) ;
170  }
171 
172  template <typename T>
173  bool CType<T>::_fromBuffer(CBufferIn& buffer)
174  {
175    allocate() ;
176    return buffer.get(*ptrValue) ;
177  }
178 
179
180  template <typename T>
181  void CType<T>::allocate(void)
182  {
183    if (empty) 
184    {
185      ptrValue = new T ;
186      empty=false ;
187    }
188  }
189 
190  template <typename T>
191  void CType<T>::_reset(void)
192  {
193    if (!empty) 
194    {
195      delete ptrValue ;
196      empty=true ;
197    }
198  }
199 
200  template <typename T>
201  void CType<T>::checkEmpty(void) const
202  {
203    if (empty) ERROR("template <typename T> void CType<T>::checkEmpty(void) const", << "Data is not initialized") ;
204  } 
205
206 
207  template <typename T>
208  CBufferOut& operator<<(CBufferOut& buffer, const CType<T>& type)
209  {
210    if (!type.toBuffer(buffer)) ERROR("CBuffer& operator<<(CBuffer& buffer, CType<T>& type)",
211                                      << "Not enough free space in buffer to queue the data.");
212    return buffer ;
213  }
214
215
216  template <typename T>
217  CBufferOut& operator<<(CBufferOut& buffer, const T& type)
218  {
219    if (!CType<T>(type).toBuffer(buffer)) ERROR("operator<<(CBuffer& buffer, const T& type)",
220                                                << "Not enough free space in buffer to queue the data.");
221    return buffer ;
222  }
223
224  template <typename T>
225  CBufferIn& operator>>(CBufferIn& buffer, CType<T>& type)
226  {
227    if (! type.fromBuffer(buffer)) ERROR("CBuffer& operator<<(CBuffer& buffer, CType<T>& type)",
228                                         << "Not enough data in buffer to unqueue the data.");
229    return buffer ;
230  }
231
232  template <typename T>
233  CMessage& operator<<(CMessage& msg, const T& type)
234  {
235    msg.push(CType<T>(type)) ;
236    return msg ;
237  }
238
239}
240
241#endif
Note: See TracBrowser for help on using the repository browser.