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 DATASTREAM_HPP_
00040 #define DATASTREAM_HPP_
00041
00042
00043 #include <boost/cstdint.hpp>
00044 #include <boost/type_traits/make_unsigned.hpp>
00045
00046 #include <iostream>
00047 #include <vector>
00048 #include <string.h>
00049
00050 #ifndef SERIALIZATION_NS
00051 #define SERIALIZATION_NS ariba::utility::serialization
00052 #define SERIALIZATION_NS_INT SERIALIZATION_NS::internal
00053
00054
00055 #define SERIALIZATION_NS_BEGIN() \
00056 namespace ariba { \
00057 namespace utility { \
00058 namespace serialization {
00059
00060 #define SERIALIZATION_NS_END() \
00061 } } }
00062 #endif
00063
00064
00065 SERIALIZATION_NS_BEGIN()
00066
00067
00068 template<Mode __mode, int __variant = DEFAULT_V, typename T = uint8_t>
00069 class DataStreamTpl;
00070
00071
00072 namespace internal {
00073 template<typename T> class ITpl;
00074 template<typename T> ITpl<T> I( T& value, size_t length = sizeof(T)*8 );
00075 class cI;
00076 class T;
00077 class cT;
00078 }
00079
00080
00081 bool data_serialization( Mode mode, VSerializeable* obj, Data& data, int variant = DEFAULT_V );
00082 Data data_serialize( const VSerializeable* obj, int variant = DEFAULT_V );
00083 bool data_deserialize( VSerializeable* obj, Data& data, int variant = DEFAULT_V );
00084 size_t data_length( const VSerializeable* obj, int variant = DEFAULT_V );
00085
00086 SERIALIZATION_NS_END()
00087
00088
00089 #include "../internal/Utilities.hpp"
00090
00091
00092 #include "Serialization.hpp"
00093 #include "DataUtilities.hpp"
00094 #include "Data.hpp"
00095
00096 SERIALIZATION_NS_BEGIN()
00097
00098
00101 template<Mode __mode, int __variant, typename T>
00102 class DataStreamTpl {
00103
00104 template<typename X>
00105 friend class SERIALIZATION_NS_INT::ITpl;
00106 friend class SERIALIZATION_NS_INT::cI;
00107 friend class SERIALIZATION_NS_INT::T;
00108 friend class SERIALIZATION_NS_INT::cT;
00109
00110 template<Mode _a, int _b, typename _c>
00111 friend std::ostream& operator<<( std::ostream&, DataStreamTpl<_a, _b, _c>& );
00112
00113 private:
00114
00115 size_t index;
00116
00117
00118 DataTpl<T> bits;
00119
00120
00121 template<class X>
00122 finline void add(const X& ser, if_is_base_of( ExplicitSerializer, X )) {
00123 ser.SERIALIZATION_METHOD_NAME(*this);
00124 }
00125
00126 template<class X>
00127 finline void remove(const X& ser, if_is_base_of( ExplicitSerializer, X )) {
00128 ser.SERIALIZATION_METHOD_NAME(*this);
00129 }
00130
00131
00132 template<class X>
00133 finline void add( X& obj, if_is_base_of( Serializeable, X ) ) {
00134 get_serializer<__variant>(obj).SERIALIZATION_METHOD_NAME(*this);
00135 }
00136
00137 template<class X>
00138 finline void add( const X& obj, if_is_base_of( Serializeable, X ) ) {
00139 get_serializer<__variant>((X&)obj).SERIALIZATION_METHOD_NAME(*this);
00140 }
00141
00142 template<class X>
00143 finline void remove( X& obj, if_is_base_of( Serializeable, X ) ) {
00144 get_serializer<__variant>(obj).SERIALIZATION_METHOD_NAME(*this);
00145 }
00146
00147
00148 template<typename X>
00149 finline void add(X& obj, if_uint(X)) {
00150 if (!isMeasure())
00151 bitcpy( obj, 0, bits.getBuffer(), index);
00152 index += sizeof(X) * 8;
00153 }
00154
00155 template<typename X>
00156 finline void remove(X& obj, if_uint(X)) {
00157 if (!isMeasure()) bits[index].get(obj);
00158 index += sizeof(X) * 8;
00159 }
00160
00161
00162 template<typename X>
00163 finline void add(X& sobj, if_int(X)) {
00164 typedef typename boost::make_unsigned<X>::type UX;
00165 UX& obj = *((UX*)&sobj);
00166 if (!isMeasure())
00167 bitcpy( sobj, 0, bits.getBuffer(), index);
00168 index += sizeof(X) * 8;
00169 }
00170
00171 template<typename X>
00172 finline void remove(X& sobj, if_int(X)) {
00173 typedef typename boost::make_unsigned<X>::type UX;
00174 UX& obj = *((UX*)&sobj);
00175 if (!isMeasure()) bits[index].get(obj);
00176 index += sizeof(X) * 8;
00177 }
00178
00179
00180 finline void add( bool& obj ) {
00181 if (!isMeasure()) bits[index] = obj;
00182 index += 1;
00183 }
00184
00185 finline void remove( bool& obj ) {
00186 if (!isMeasure()) bits[index].get(obj);
00187 index += 1;
00188 }
00189
00190
00191 finline void add( const VSerializeable* obj ) {
00192 if (!isMeasure()) {
00193 Data data = data_serialize( (VSerializeable*)obj, __variant );
00194 add(data); data.release();
00195 } else {
00196 index += data_length( obj, __variant );
00197 }
00198 }
00199
00200 finline void remove( VSerializeable* obj ) {
00201 Data data( bits.getBuffer() + index / 8, getRemainingLength() );
00202 size_t length = obj->SERIALIZATION_METHOD_NAME( __mode, data, __variant );
00203 index += length;
00204 }
00205
00206 finline void remove( const VSerializeable* obj ) {
00207 throw "NOT SUPPORTED!";
00208 }
00209
00210
00211 typedef DataStreamTpl<__mode, __variant, T> _DataStream;
00212
00213 public:
00214
00215 finline DataStreamTpl() : bits() {
00216 index = 0;
00217 }
00218
00219 finline DataStreamTpl( Data& binary ) : bits(binary) {
00220 index = 0;
00221 }
00222
00223 finline DataStreamTpl( _DataStream& stream ) {
00224 throw "Error: DataStreams can not be copied.";
00225 }
00226
00232 finline Mode getMode() const {
00233 return __mode;
00234 }
00235
00241 finline bool isMeasure() {
00242 return __mode == MEASURE;
00243 }
00244
00245 finline bool isSerializer() {
00246 return (__mode == SERIALIZE) || isMeasure();
00247 }
00248
00249 finline bool isDeserializer() {
00250 return __mode == DESERIALIZE;
00251 }
00252
00258 finline int getVariant() const {
00259 return __variant;
00260 }
00261
00268 finline size_t getRemainingLength() const {
00269 return bits.getLength() - index;
00270 }
00271
00278 finline Data getRemainingData( size_t length ) {
00279 Data subData = Data(bits.getBuffer() + index / bits.word_width, length);
00280 index += length;
00281 return subData;
00282 }
00283
00290 finline size_t getCurrentLength() const {
00291 return index;
00292 }
00293
00297 finline void reset(Mode mode = UNDEFINED) {
00298 this->index = 0;
00299 this->mode = mode;
00300 }
00301
00305 finline size_t mark() const {
00306 return index;
00307 }
00308
00312 finline void seek( size_t idx ) {
00313 index = idx;
00314 }
00315
00320 finline void ensureLength( size_t size ) {
00321 if (!isMeasure()) bits.ensureLength( size + index );
00322 }
00323
00327 finline Data getData() {
00328 bits.setLength(index);
00329 return bits;
00330 }
00331
00335 template<typename X>
00336 finline _DataStream& operator&&( X& obj ) {
00337 if (isSerializer()) add(obj); else if (isDeserializer()) remove(obj);
00338 return *this;
00339 }
00340
00341 template<typename X>
00342 finline _DataStream& operator&&( const X& obj ) {
00343 if (isSerializer()) add(obj); else if (isDeserializer()) remove(obj);
00344 return *this;
00345 }
00346
00347 template<typename X>
00348 finline _DataStream& operator&&( X* obj ) {
00349 if (isSerializer()) add(obj); else if (isDeserializer()) remove(obj);
00350 return *this;
00351 }
00352
00353 template<typename X>
00354 finline _DataStream& operator&&( const X* obj ) {
00355 if (isSerializer()) add(obj); else if (isDeserializer()) remove(obj);
00356 return *this;
00357 }
00358 };
00359
00360
00361
00362 template<Mode _a, int _b, typename _c>
00363 std::ostream& operator<<( std::ostream& stream,
00364 DataStreamTpl<_a, _b, _c>& binaryStream ) {
00365 stream << binaryStream.bits << "";
00366 return stream;
00367 }
00368
00369
00370
00371 namespace internal {
00372 using_serialization;
00373
00374
00375 template<typename T>
00376 class ITpl : public ExplicitSerializer {
00377 private:
00378 T& value;
00379 size_t length;
00380 public:
00381 finline ITpl( T& _value, size_t _length = sizeof(T)*8 )
00382 : value(_value), length(_length) {}
00383
00384 sznMethodBegin(X)
00385 if (X.isSerializer()) {
00386 if (!X.isMeasure())
00387 X.bits[X.index].set( value, length );
00388 X.index += length;
00389 } else {
00390 X.bits[X.index].get(value,length);
00391 X.index += length;
00392 }
00393 sznMethodEnd()
00394 };
00395
00396 template<typename T>
00397 finline ITpl<T> I( T& value, size_t length ) {
00398 return ITpl<T>(value, length);
00399 }
00400
00401
00402 class cI : public ExplicitSerializer {
00403 private:
00404 const uintmax_t value;
00405 size_t length;
00406 public:
00407 finline cI( const uintmax_t _value, size_t _length )
00408 : value(_value), length(_length) {}
00409
00410 sznMethodBegin(X)
00411 if (X.isSerializer()) {
00412 if (!X.isMeasure())
00413 X.bits[X.index].set(value,length);
00414 X.index += length;
00415 } else {
00416 uintmax_t _value = 0;
00417 X.bits[X.index].get(_value,length);
00418 if (_value != value) break;
00419 X.index += length;
00420 }
00421 sznMethodEnd()
00422 };
00423
00424
00425 class cT : public ExplicitSerializer {
00426 private:
00427 const char* text;
00428
00429 public:
00430 finline cT( const char* _text )
00431 : text(_text) {}
00432
00433 sznMethodBegin(X)
00434 if (X.isSerializer()) {
00435 size_t length = strlen(text);
00436 if (!X.isMeasure()) {
00437 for (size_t i=0; i<length; i++)
00438 X.bits[X.index+i*8] = (uint8_t)text[i];
00439 }
00440 X.index += length * 8;
00441 } else {
00442 size_t length = strlen(text);
00443 for (size_t i=0; i<length; i++) {
00444 char c = 0;
00445 X.bits[X.index+i*8].get(c);
00446 if (c!=text[i]) break;
00447 }
00448 }
00449 sznMethodEnd()
00450 };
00451
00452
00453 class T : public ExplicitSerializer {
00454 private:
00455 bool isCharP;
00456 char** text;
00457 std::string* string;
00458 int length;
00459
00460 public:
00461 finline T( char*& _text, int length = -1 ) :
00462 text(&_text), string(NULL) {
00463 this->isCharP = true;
00464 this->length = length;
00465 }
00466
00467 finline T( std::string& _string, int length = -1 ) :
00468 text(NULL), string(&_string) {
00469 this->isCharP = false;
00470 this->length = length;
00471 }
00472
00473 sznMethodBegin(X)
00474 if (X.isSerializer()) {
00475 char* textp = isCharP ? *text : (char*)string->c_str();
00476 size_t plength = length!= -1 ? length : strlen(textp);
00477 if (!X.isMeasure()) {
00478 size_t i;
00479 for (i=0; i<plength && textp[i]!=0; i++)
00480 X.bits[X.index+i*8] = (uint8_t)textp[i];
00481 if (length==-1) X.bits[X.index+i*8] = (uint8_t)0;
00482 }
00483 X.index += plength * 8 + ((length == -1) ? 8 : 0);
00484 } else {
00485 std::string s;
00486 size_t i = 0;
00487 while (length == -1 || i < (size_t)length) {
00488 uint8_t c = 0;
00489 X.bits[X.index].get(c); X.index += 8;
00490 if (c == 0 && length == -1) break;
00491 s += (char)c;
00492 i++;
00493 }
00494 if (isCharP) *text = strdup(s.c_str()); else *string = s;
00495 }
00496 sznMethodEnd()
00497 };
00498
00499
00500 template<typename T>
00501 class ArrayTpl : public ExplicitSerializer {
00502 private:
00503 T*& v;
00504 size_t l;
00505
00506 public:
00507 finline ArrayTpl( T*& array, size_t length ) :
00508 v(0), l(length) {}
00509
00510 sznMethodBegin(X)
00511 if (X.isDeserializer()) v = new T[l];
00512 for (size_t i=0; i<l; i++) X && v[i];
00513 sznMethodEnd()
00514 };
00515
00516 template<typename T>
00517 class VectorTpl : public ExplicitSerializer {
00518 private:
00519 std::vector<T>& v;
00520 size_t l;
00521
00522 public:
00523 finline VectorTpl( std::vector<T>& vec, size_t length ) :
00524 v(vec), l(length) {}
00525
00526 sznMethodBegin(X)
00527 if (X.isDeserializer()) v.resize(l);
00528 for (size_t i=0; i<l; i++) X && v[i];
00529 sznMethodEnd()
00530 };
00531
00532 template<typename X, typename T>
00533 finline X V( T& x ) {
00534 throw "ERROR: No vector serializer for this type";
00535 }
00536
00537 template<typename T>
00538 finline ArrayTpl<T> A( T*& array, size_t length ) {
00539 return ArrayTpl<T>(array,length);
00540 }
00541
00542 template<typename T>
00543 finline VectorTpl<T> A( std::vector<T>& array, size_t length ) {
00544 return VectorTpl<T>(array,length);
00545 }
00546
00547
00548 template<typename T>
00549 class VOTpl : ExplicitSerializer {
00550 private:
00551 int variant;
00552 T*& obj;
00553 public:
00554 finline VOTpl( T*& mobj, int variant ) : obj(mobj) {
00555 }
00556 sznMethodBegin(X)
00557 if (X.isSerializer()) {
00558 if (obj!=NULL) X && obj;
00559 } else {
00560 obj = new T();
00561 X && obj;
00562 }
00563 sznMethodEnd()
00564 };
00565
00566 template<typename T>
00567 finline VOTpl<T> VO( T*& obj, int variant = DEFAULT_V ) {
00568 return VOTpl<T>(obj,variant);
00569 }
00570
00571
00572 template<typename T>
00573 class OTpl : ExplicitSerializer {
00574 private:
00575 int variant;
00576 T*& obj;
00577 public:
00578 finline OTpl( T*& mobj, int variant ) : obj(mobj) {
00579 }
00580 sznMethodBegin(X)
00581 if (X.isSerializer()) {
00582 if (obj!=NULL) X && *obj;
00583 } else {
00584 obj = new T();
00585 X && *obj;
00586 }
00587 sznMethodEnd()
00588 };
00589
00590 template<typename T>
00591 finline OTpl<T> O( T*& obj, int variant = DEFAULT_V ) {
00592 return OTpl<T>(obj,variant);
00593 }
00594
00595 }
00596
00597
00598
00599
00600
00601
00602 template<int __variant, typename X> finline
00603 size_t data_length_v( const X& obj ) {
00604 DataStreamTpl<MEASURE, __variant> stream;
00605 return (stream && (X&)obj).getCurrentLength();
00606 }
00607
00608 template<typename X> finline
00609 size_t data_length( const X& obj ) {
00610 return data_length_v<DEFAULT_V>(obj);
00611 }
00612
00613 template<Mode __mode, int __variant, typename X> finline
00614 size_t data_serialization_v( X& obj, Data& data,
00615 if_is_base_of(Serializeable, X) ) {
00616 if (__mode == SERIALIZE) {
00617 DataStreamTpl<SERIALIZE, __variant> stream;
00618 size_t len = data_length_v<__variant>(obj);
00619 stream.ensureLength( len );
00620 return (data = (stream && obj).getData()).getLength();
00621 } else {
00622 DataStreamTpl<DESERIALIZE, __variant> stream( data );
00623 return (stream && obj).getCurrentLength();
00624 }
00625 }
00626
00627 template<Mode __mode, int __variant, typename X>
00628 size_t slow_data_serialization_v( X& obj, Data& data,
00629 if_is_base_of(Serializeable, X) ) {
00630 return slow_data_serialization_v<__mode,__variant>(obj,data);
00631 }
00632
00633 template<Mode __mode, typename X>
00634 size_t data_serialization( X& obj, Data& data,
00635 if_is_base_of( Serializeable, X ) ) {
00636 return slow_data_serialization_v<__mode, DEFAULT_V>( obj, data );
00637 }
00638
00639 template<int __variant, typename X>
00640 Data data_serialize_v( const X& obj, if_is_base_of(Serializeable, X) ) {
00641 Data data; data_serialization_v<SERIALIZE, __variant>( (X&)obj, data );
00642 return data;
00643 }
00644
00645 template<typename X>
00646 Data data_serialize( const X& obj, if_is_base_of(Serializeable, X) ) {
00647 return data_serialize_v<DEFAULT_V>(obj);
00648 }
00649
00650 template<int __variant, typename X>
00651 size_t data_deserialize_v( X& obj, Data data, if_is_base_of(Serializeable, X) ) {
00652 return data_serialization_v<DESERIALIZE,__variant>( obj, data );
00653 }
00654
00655 template<typename X>
00656 size_t data_deserialize( X& obj, Data data,
00657 if_is_base_of(Serializeable, X) ) {
00658 return data_deserialize_v<DEFAULT_V>(obj, data);
00659 }
00660
00661
00662
00663 finline bool data_serialization( VSerializeable* obj, Data& data,
00664 Mode mode, int variant ) {
00665 size_t length = obj->SERIALIZATION_METHOD_NAME( mode, data, variant );
00666 return length != 0;
00667 }
00668
00669 finline Data data_serialize( const VSerializeable* obj,
00670 int variant ) {
00671 Data data;
00672 data_serialization( (VSerializeable*)obj, data, SERIALIZE, variant );
00673 return data;
00674 }
00675
00676 finline bool data_deserialize( VSerializeable* obj, Data& data,
00677 int variant ) {
00678 return data_serialization( obj, data, DESERIALIZE, variant );
00679 }
00680
00681 finline size_t data_length( const VSerializeable* obj, int variant ) {
00682 return ((VSerializeable*)obj)->SERIALIZATION_METHOD_NAME( MEASURE,
00683 (Data&)Data::UNSPECIFIED, variant );
00684 }
00685
00686
00687
00688 SERIALIZATION_NS_END()
00689
00690 #endif