source: XIOS/dev/dev_olga/src/type/type.hpp @ 1158

Last change on this file since 1158 was 1158, checked in by oabramkina, 3 years ago

Two server levels: merging with trunk r1137.
There are bugs.

  • 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: 5.5 KB
Line 
1#ifndef __XIOS_TYPE__
2#define __XIOS_TYPE__
3
4#include "xios_spl.hpp"
5#include "exception.hpp"
6#include "buffer_in.hpp"
7#include "buffer_out.hpp"
8#include "base_type.hpp"
9
10
11namespace xios
12{
13
14  template <typename T> class CType_ref ;
15
16  template <typename T>
17  class CType : public  virtual CBaseType
18  {
19    public:
20
21    CType(void) ;
22    CType(const T& val) ;
23    CType(const CType& type) ;
24    CType(const CType_ref<T>& type) ;
25    virtual ~CType() { _reset() ; }
26
27    T& get(void) ;
28    const T& get(void) const;
29
30    void set(const T& val) ;
31    void set(const CType& val) ;
32    void set(const CType_ref<T>& val) ;
33    CType& operator = (const T& val) ;
34    CType& operator = (const CType& val) ;
35    CType& operator = (const CType_ref<T>& val) ;
36    operator T&() ;
37    operator const T&() const ;
38
39    inline virtual CBaseType* clone(void) const   { return _clone(); }
40    virtual void fromString(const string& str)   { _fromString(str); }
41    virtual string toString(void) const { return _toString(); }
42    virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer) ; }
43    virtual bool toBuffer(CBufferOut& buffer) const { return _toBuffer(buffer); }
44    virtual void reset(void) { _reset(); }
45    virtual bool isEmpty() const { return _isEmpty(); }
46    virtual size_t size(void) const { return _size(); }
47
48    void allocate(void) ;
49    void checkEmpty(void) const;
50
51    T* ptrValue ;
52    bool empty ;
53
54    friend class CType_ref<T> ;
55
56    private :
57
58    CType* _clone(void) const;
59    void _fromString(const string& str) ;
60    string _toString(void) const;
61    bool _fromBuffer(CBufferIn& buffer) ;
62    bool _toBuffer(CBufferOut& buffer) const;
63    void _reset(void) ;
64    bool _isEmpty() const ;
65    size_t _size(void) const ;
66
67  } ;
68
69
70  template<typename T> class CType ;
71
72  template <typename T>
73  class CType_ref : public virtual CBaseType
74  {
75    public:
76
77    CType_ref(void) ;
78    CType_ref(T& val) ;
79    CType_ref(CType<T>& type) ;
80    CType_ref(const CType_ref& type) ;
81    virtual ~CType_ref() {};
82
83    T& get(void) const;
84
85    void set(const T& val) const ;
86    void set(const CType<T>& val) const ;
87    void set(const CType_ref& val) const ;
88
89    void set_ref(T& val) ;
90    void set_ref(CType<T>& val) ;
91    void set_ref(const CType_ref& val) ;
92
93    const CType_ref& operator = (T& val) const ;
94    const CType_ref& operator = (CType<T>& val) const ;
95    const CType_ref& operator = (const CType_ref& val) const;
96    operator T&() const;   
97
98    inline virtual CBaseType* clone(void) const   { return _clone(); }
99    virtual void fromString(const string& str)   { _fromString(str); }
100    virtual void fromString(const string& str) const  { _fromString(str); }
101    virtual string toString(void) const { return _toString(); }
102    virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer) ; }
103    virtual bool fromBuffer(CBufferIn& buffer) const { return _fromBuffer(buffer); }
104    virtual bool toBuffer(CBufferOut& buffer) const { return _toBuffer(buffer); }
105    virtual void reset(void) { _reset(); }
106    virtual bool isEmpty() const { return _isEmpty(); }
107    virtual size_t size(void) const { return _size(); }
108
109    void checkEmpty(void) const;
110
111
112    T mutable * ptrValue ;
113    bool empty ;
114    friend class CType<T> ;
115
116    private :
117
118    CType_ref* _clone(void) const;
119    void _fromString(const string& str) ;
120    void _fromString(const string& str) const;
121    string _toString(void) const;
122    bool _fromBuffer(CBufferIn& buffer) ;
123    bool _fromBuffer(CBufferIn& buffer) const ;
124    bool _toBuffer(CBufferOut& buffer) const;
125    void _reset(void) ;
126    bool _isEmpty() const ;
127    size_t _size(void) const ;
128  } ;
129
130  template <typename T> bool operator==(const CType<T>& lhs, const T& rhs);   
131  template <typename T> bool operator==(const T& lhs, const CType<T>& rhs);   
132  template <typename T> bool operator==(const CType_ref<T>& lhs, const T& rhs);   
133  template <typename T> bool operator==(const T& lhs, const CType_ref<T>& rhs); 
134  template <typename T> bool operator==(const CType<T>& lhs, const CType<T>& rhs); 
135  template <typename T> bool operator==(const CType_ref<T>& lhs, const CType_ref<T>& rhs); 
136
137  template <typename T>
138  bool operator==(const CType_ref<T>& lhs, const CType<T>& rhs)
139  {
140    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
141    if (lhs.isEmpty() && rhs.isEmpty()) return true;
142    return (*lhs.ptrValue == *rhs.ptrValue);
143  } 
144
145  template <typename T>
146  bool operator==(const CType<T>& lhs, const CType_ref<T>& rhs)
147  {
148    return (rhs == lhs);
149  }
150
151
152  class CMessage ;
153
154  template <typename T>
155  CBufferOut& operator<<(CBufferOut& buffer, const CType<T>& type) ;
156
157  template <typename T>
158  CBufferOut& operator<<(CBufferOut& buffer, const CType_ref<T>& type) ;
159
160  template <typename T>
161  CBufferOut& operator<<(CBufferOut& buffer, const T& type) ;
162
163  template <typename T>
164  CBufferOut& operator<<(CBufferOut& buffer, T& type) ;
165
166
167  template <typename T>
168  CBufferIn& operator>>(CBufferIn& buffer, CType<T>& type) ;
169
170  template <typename T>
171  CBufferIn& operator>>(CBufferIn& buffer, const CType_ref<T>& type) ;
172
173  template <typename T>
174  CBufferIn& operator>>(CBufferIn& buffer, T& type) ;
175
176/*
177  template <typename T>
178  CMessage& operator<<(CMessage& msg, const CType<T>& type) ;
179
180  template <typename T>
181  CMessage& operator<<(CMessage& msg, const CType_ref<T>& type) ;
182*/
183
184  template <typename T>
185  CMessage& operator<<(CMessage& msg, const T& type) ;
186
187  template <typename T>
188  CMessage& operator<<(CMessage& msg, T& type) ;
189
190}
191
192
193//#include "test_type_impl.hpp"
194//#include "test_type_specialisation.hpp"
195
196#endif
197
Note: See TracBrowser for help on using the repository browser.