00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #ifndef SERIALIZATION_HPP_
00040 #define SERIALIZATION_HPP_
00041
00042
00043
00044 #ifndef SERIALIZATION_NS
00045
00046 #define SERIALIZATION_NS ariba::utility::serialization
00047 #define SERIALIZATION_NS_INT SERIALIZATION_NS::internal
00048
00049
00050
00051 #define SERIALIZATION_NS_BEGIN() \
00052 namespace ariba { namespace utility { namespace serialization {
00053
00054 #define SERIALIZATION_NS_END() }}}
00055
00056 #endif
00057
00058
00059
00060 #define SERIALIZATION_METHOD_NAME __mSerialization
00061 #define SERIALIZATION_CLASS_NAME __cSerialization
00062
00063
00064
00065 #define USING_SERIALIZATION using namespace SERIALIZATION_NS;
00066 #define using_serialization USING_SERIALIZATION;
00067
00068
00069
00070
00071
00072 template<typename __Y, int __V> class SERIALIZATION_CLASS_NAME;
00073
00074 SERIALIZATION_NS_BEGIN()
00075
00076
00077 namespace internal {}
00078
00079
00080 const int DEFAULT_V = 0;
00081 const int STRING_V = 1;
00082
00083
00084 enum Mode {
00085 UNDEFINED = 0,
00086 SERIALIZE = 1,
00087 DESERIALIZE = 2,
00088 MEASURE = 3
00089 };
00090
00091 SERIALIZATION_NS_END()
00092
00093
00094
00095
00096 #define SERIALIZATION_USE_INTERNAL_NS \
00097 using namespace SERIALIZATION_NS_INT; \
00098 using namespace SERIALIZATION_NS;
00099
00100
00101 #define ISERIALIZATION_METHOD_BEGIN( Buffer, Const ) \
00102 public: template<typename __X> \
00103 finline bool SERIALIZATION_METHOD_NAME( __X& Buffer ) Const { \
00104 SERIALIZATION_USE_INTERNAL_NS \
00105 bool __ok = false; do {
00106
00107 #define RSERIALIZATION_METHOD_BEGIN( Buffer ) \
00108 ISERIALIZATION_METHOD_BEGIN( Buffer, )
00109
00110 #define SERIALIZATION_METHOD_BEGIN( Buffer ) \
00111 ISERIALIZATION_METHOD_BEGIN( Buffer, const )
00112
00113 #define SERIALIZATION_METHOD_END() \
00114 __ok = true; } while (false); return __ok; }
00115
00116
00117 #define sznMethodBegin( Buffer ) SERIALIZATION_METHOD_BEGIN( Buffer )
00118 #define sznMethodEnd() SERIALIZATION_METHOD_END()
00119
00120
00121 #define SERIALIZEABLE \
00122 public: template<typename __Y,int __V> \
00123 friend class ::SERIALIZATION_CLASS_NAME;
00124
00125 #define sznStub SERIALIZEABLE
00126
00127
00128 #define SERIALIZATION_BEGIN( Class, Variant, Buffer ) \
00129 template<> \
00130 class SERIALIZATION_CLASS_NAME \
00131 <Class, SERIALIZATION_NS::Variant> : Class { \
00132 RSERIALIZATION_METHOD_BEGIN( Buffer )
00133
00134 #define SERIALIZATION_END() \
00135 SERIALIZATION_METHOD_END() };
00136
00137
00138 #define sznBegin(Class,Variant,Buffer) \
00139 SERIALIZATION_BEGIN( Class, Variant, Buffer )
00140 #define sznBeginDefault( Class, Buffer ) \
00141 SERIALIZATION_BEGIN( Class, DEFAULT_V, Buffer )
00142 #define sznEnd() SERIALIZATION_END()
00143
00144
00145 #define VSERIALIZEABLE \
00146 SERIALIZEABLE \
00147 virtual size_t SERIALIZATION_METHOD_NAME( \
00148 SERIALIZATION_NS::Mode __mode, \
00149 Data& __data, \
00150 int __variant = SERIALIZATION_NS::DEFAULT_V \
00151 );
00152
00153 #define VSERIALIZATION_BEGIN( Class ) \
00154 size_t Class::SERIALIZATION_METHOD_NAME( \
00155 SERIALIZATION_NS::Mode __mode, \
00156 Data& __data, \
00157 int __variant \
00158 ) { \
00159 USING_SERIALIZATION; \
00160 SERIALIZATION_USE_INTERNAL_NS; \
00161 switch (__variant) {
00162
00163 #define VSERIALIZATION_END() \
00164 } return 0; }
00165
00166 #define VSERIALIZATION_REG( __variant ) \
00167 case __variant: \
00168 switch (__mode) { \
00169 case SERIALIZE: \
00170 __data = data_serialize_v<__variant>(*this); \
00171 return __data.getLength(); \
00172 case DESERIALIZE: \
00173 return data_deserialize_v<__variant>(*this, __data); \
00174 case MEASURE: \
00175 return data_length_v<__variant>(*this); \
00176 case UNDEFINED: \
00177 return 0; \
00178 } break;
00179
00180 #define VSERIALIZATION_DEFAULT( Class ) \
00181 USING_SERIALIZATION \
00182 VSERIALIZATION_BEGIN( Class ) \
00183 VSERIALIZATION_REG( DEFAULT_V ) \
00184 VSERIALIZATION_END( )
00185
00186
00187 #define vsznStub VSERIALIZEABLE
00188 #define vsznBegin( Class ) VSERIALIZAION_BEGIN( Class )
00189 #define vsznEnd() VSERIALIZATION_END()
00190 #define vsznRegister( Variant ) VSERIALIZATION_REG( Variant )
00191 #define vsznDefault( Class ) VSERIALIZATION_DEFAULT( Class )
00192
00193
00194 #define sznImplBegin(Class) VSERIALIZAION_BEGIN( Class )
00195 #define sznImplDefault(Class) VSERIALIZATION_DEFAULT( Class )
00196
00197
00198
00199 #include "../internal/Utilities.hpp"
00200 #include <typeinfo>
00201 #include <iostream>
00202
00203
00204
00205
00209 template<typename __Y, int __V>
00210 class SERIALIZATION_CLASS_NAME: __Y {
00211 public:
00212 template<class __X>
00213 finline bool SERIALIZATION_METHOD_NAME(__X& buffer) {
00214 printf("Serialization not supported for type '%s' "
00215 "with variant %d for Stream %s.\n",
00216 typeid(__Y).name(), __V, typeid(__X).name());
00217 return false;
00218 }
00219 };
00220
00221 class Serializeable {};
00222
00223 #include "Data.hpp"
00224
00225 class VSerializeable : public Serializeable {
00226 public:
00237 virtual size_t SERIALIZATION_METHOD_NAME(
00238 SERIALIZATION_NS::Mode __mode,
00239 Data& __binary,
00240 int __variant = SERIALIZATION_NS::DEFAULT_V
00241 );
00242 };
00243
00247 class ExplicitSerializer {
00248 SERIALIZATION_METHOD_BEGIN(X)
00249 std::cerr << "Serialization unimplemented" << std::endl;
00250 SERIALIZATION_METHOD_END()
00251 };
00252
00253
00254
00255
00256 SERIALIZATION_NS_BEGIN()
00257
00258
00261 template<int V, typename Y>
00262 finline static SERIALIZATION_CLASS_NAME<Y, V>& get_serializer(Y& obj) {
00263 return *((SERIALIZATION_CLASS_NAME<Y, V>*)(&obj));
00264 }
00265 SERIALIZATION_NS_END()
00266
00267 #endif