close Warning: Can't use blame annotator: 
No changeset 2259 in the repository

source: source/ariba/utility/serialization/Serialization.hpp@ 5671

Last change on this file since 5671 was 4890, checked in by Christoph Mayer, 15 years ago

gcc 4 fixes
File size: 7.9 KB
RevLine 
1// [License]
2// The Ariba-Underlay Copyright
3//
4// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)
5//
6// Institute of Telematics
7// UniversitÀt Karlsruhe (TH)
8// Zirkel 2, 76128 Karlsruhe
9// Germany
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND
22// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR
25// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//
33// The views and conclusions contained in the software and documentation
34// are those of the authors and should not be interpreted as representing
35// official policies, either expressed or implied, of the Institute of
36// Telematics.
37// [License]
38
39#ifndef SERIALIZATION_HPP_
40#define SERIALIZATION_HPP_
41
42//---------------------------------------------------------------------------
43//= namespace adaption =
44#ifndef SERIALIZATION_NS
45
46#define SERIALIZATION_NS ariba::utility::serialization
47#define SERIALIZATION_NS_INT SERIALIZATION_NS::internal
48
49//---------------------------------------------------------------------------
50//= some words on the namespaces =
51#define SERIALIZATION_NS_BEGIN() \
52 namespace ariba { namespace utility { namespace serialization {
53
54#define SERIALIZATION_NS_END() }}}
55
56#endif
57
58//---------------------------------------------------------------------------
59//= some definition of method and class names =
60#define SERIALIZATION_METHOD_NAME __mSerialization
61#define SERIALIZATION_CLASS_NAME __cSerialization
62
63//---------------------------------------------------------------------------
64//= namespace specifications =
65#define USING_SERIALIZATION using namespace SERIALIZATION_NS;
66#define using_serialization USING_SERIALIZATION;
67
68//---------------------------------------------------------------------------
69//== prototypes ==
70
71// public serializer prototype
72template<typename __Y, int __V> class SERIALIZATION_CLASS_NAME;
73
74SERIALIZATION_NS_BEGIN()
75
76// the internal namespace
77namespace internal {}
78
79// default variants
80const int DEFAULT_V = 0;
81const int STRING_V = 1;
82
83// serialization mode
84enum Mode {
85 UNDEFINED = 0,
86 SERIALIZE = 1,
87 DESERIALIZE = 2,
88 MEASURE = 3
89};
90
91SERIALIZATION_NS_END()
92
93//---------------------------------------------------------------------------
94//= Serialization Macros =
95
96#define SERIALIZATION_USE_INTERNAL_NS \
97 using namespace SERIALIZATION_NS_INT; \
98 using namespace SERIALIZATION_NS;
99
100//= serialization method =
101#define ISERIALIZATION_METHOD_BEGIN( Buffer, Const ) \
102 public: template<typename __X> \
103 finline bool SERIALIZATION_METHOD_NAME( __X& Buffer ) Const { \
104 SERIALIZATION_USE_INTERNAL_NS \
105 bool __ok = false; do {
106
107#define RSERIALIZATION_METHOD_BEGIN( Buffer ) \
108 ISERIALIZATION_METHOD_BEGIN( Buffer, )
109
110#define SERIALIZATION_METHOD_BEGIN( Buffer ) \
111 ISERIALIZATION_METHOD_BEGIN( Buffer, const )
112
113#define SERIALIZATION_METHOD_END() \
114 __ok = true; } while (false); return __ok; }
115
116// convenience
117#define sznMethodBegin( Buffer ) SERIALIZATION_METHOD_BEGIN( Buffer )
118#define sznMethodEnd() SERIALIZATION_METHOD_END()
119
120//= serialization class stub =
121#define SERIALIZEABLE \
122 public: template<typename __Y,int __V> \
123 friend class ::SERIALIZATION_CLASS_NAME;
124
125#define sznStub SERIALIZEABLE
126
127//= serialization code generation =
128#define SERIALIZATION_BEGIN( Class, Variant, Buffer ) \
129 template<> \
130 class SERIALIZATION_CLASS_NAME \
131 <Class, SERIALIZATION_NS::Variant> : Class { \
132 RSERIALIZATION_METHOD_BEGIN( Buffer )
133
134#define SERIALIZATION_END() \
135 SERIALIZATION_METHOD_END() };
136
137// convenience
138#define sznBegin(Class,Variant,Buffer) \
139 SERIALIZATION_BEGIN( Class, Variant, Buffer )
140#define sznBeginDefault( Class, Buffer ) \
141 SERIALIZATION_BEGIN( Class, DEFAULT_V, Buffer )
142#define sznEnd() SERIALIZATION_END()
143
144//= virtual serialization =
145#define VSERIALIZEABLE \
146 SERIALIZEABLE \
147 virtual size_t SERIALIZATION_METHOD_NAME( \
148 SERIALIZATION_NS::Mode __mode, \
149 Data& __data, \
150 int __variant = SERIALIZATION_NS::DEFAULT_V \
151 );
152
153#define VSERIALIZATION_BEGIN( Class ) \
154 size_t Class::SERIALIZATION_METHOD_NAME( \
155 SERIALIZATION_NS::Mode __mode, \
156 Data& __data, \
157 int __variant \
158 ) { \
159 USING_SERIALIZATION; \
160 SERIALIZATION_USE_INTERNAL_NS; \
161 switch (__variant) {
162
163#define VSERIALIZATION_END() \
164 } return 0; }
165
166#define VSERIALIZATION_REG( __variant ) \
167 case __variant: \
168 switch (__mode) { \
169 case SERIALIZE: \
170 __data = data_serialize_v<__variant>(*this); \
171 return __data.getLength(); \
172 case DESERIALIZE: \
173 return data_deserialize_v<__variant>(*this, __data); \
174 case MEASURE: \
175 return data_length_v<__variant>(*this); \
176 case UNDEFINED: \
177 return 0; \
178 } break;
179
180#define VSERIALIZATION_DEFAULT( Class ) \
181 USING_SERIALIZATION \
182 VSERIALIZATION_BEGIN( Class ) \
183 VSERIALIZATION_REG( DEFAULT_V ) \
184 VSERIALIZATION_END( )
185
186// convenience
187#define vsznStub VSERIALIZEABLE
188#define vsznBegin( Class ) VSERIALIZAION_BEGIN( Class )
189#define vsznEnd() VSERIALIZATION_END()
190#define vsznRegister( Variant ) VSERIALIZATION_REG( Variant )
191#define vsznDefault( Class ) VSERIALIZATION_DEFAULT( Class )
192
193// new: convenience
194#define sznImplBegin(Class) VSERIALIZAION_BEGIN( Class )
195#define sznImplDefault(Class) VSERIALIZATION_DEFAULT( Class )
196
197//---------------------------------------------------------------------------
198//== includes ==
199#include "../internal/Utilities.hpp"
200#include <typeinfo>
201#include <iostream>
202#include <cstdio>
203
204//---------------------------------------------------------------------------
205//= Public Serialization Classes =
206
207/**
208 * TODO: doc
209 */
210template<typename __Y, int __V>
211class SERIALIZATION_CLASS_NAME: __Y {
212public:
213 template<class __X>
214 finline bool SERIALIZATION_METHOD_NAME(__X& buffer) {
215 printf("Serialization not supported for type '%s' "
216 "with variant %d for Stream %s.\n",
217 typeid(__Y).name(), __V, typeid(__X).name());
218 return false;
219 }
220};
221
222class Serializeable {};
223
224#include "Data.hpp"
225
226class VSerializeable : public Serializeable {
227public:
228 /**
229 * Serializes/Deserializes an this object in the specified variant.
230 * The special case is, that virtual serializeable objects are bound
231 * to byte boundaries -- so they cannot be smaller than a byte.
232 *
233 * @param data BitData object that holds or is used to serialize data
234 * @param mode Mode of operation (serialize/deserialize)
235 * @param variant Variant of encoding/decoding
236 * @return size of the binary object in bits or zero if unsuccessful
237 */
238 virtual size_t SERIALIZATION_METHOD_NAME(
239 SERIALIZATION_NS::Mode __mode,
240 Data& __binary,
241 int __variant = SERIALIZATION_NS::DEFAULT_V
242 );
243};
244
245/**
246 * TODO: doc
247 */
248class ExplicitSerializer {
249 SERIALIZATION_METHOD_BEGIN(X)
250 std::cerr << "Serialization unimplemented" << std::endl;
251 SERIALIZATION_METHOD_END()
252};
253
254//---------------------------------------------------------------------------
255//= Serialization Namespace =
256
257SERIALIZATION_NS_BEGIN()
258
259/**
260 * TODO: doc
261 */
262template<int V, typename Y>
263finline static SERIALIZATION_CLASS_NAME<Y, V>& get_serializer(Y& obj) {
264 return *((SERIALIZATION_CLASS_NAME<Y, V>*)(&obj));
265}
266SERIALIZATION_NS_END()
267
268#endif /* SERIALIZATION_HPP_ */
Note: See TracBrowser for help on using the repository browser.