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