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(0), 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 VectorTpl : public ExplicitSerializer {
00536 private:
00537 std::vector<T>& v;
00538 size_t l;
00539
00540 public:
00541 finline VectorTpl( std::vector<T>& vec, size_t length ) :
00542 v(vec), l(length) {}
00543
00544 sznMethodBegin(X)
00545 if (X.isDeserializer()) v.resize(l);
00546 for (size_t i=0; i<l; i++) X && v[i];
00547 sznMethodEnd()
00548 };
00549
00550 template<typename X, typename T>
00551 finline X V( T& x ) {
00552 throw "ERROR: No vector serializer for this type";
00553 }
00554
00555 template<typename T>
00556 finline ArrayTpl<T> A( T*& array, size_t length ) {
00557 return ArrayTpl<T>(array,length);
00558 }
00559
00560 template<typename T>
00561 finline VectorTpl<T> A( std::vector<T>& array, size_t length ) {
00562 return VectorTpl<T>(array,length);
00563 }
00564
00565
00566 template<typename T>
00567 class VOTpl : ExplicitSerializer {
00568 private:
00569 int variant;
00570 T*& obj;
00571 public:
00572 finline VOTpl( T*& mobj, int variant ) : obj(mobj) {
00573 }
00574 sznMethodBegin(X)
00575 if (X.isSerializer()) {
00576 if (obj!=NULL) X && obj;
00577 } else {
00578 obj = new T();
00579 X && obj;
00580 }
00581 sznMethodEnd()
00582 };
00583
00584 template<typename T>
00585 finline VOTpl<T> VO( T*& obj, int variant = DEFAULT_V ) {
00586 return VOTpl<T>(obj,variant);
00587 }
00588
00589
00590 template<typename T>
00591 class OTpl : ExplicitSerializer {
00592 private:
00593 int variant;
00594 T*& obj;
00595 public:
00596 finline OTpl( T*& mobj, int variant ) : obj(mobj) {
00597 }
00598 sznMethodBegin(X)
00599 if (X.isSerializer()) {
00600 if (obj!=NULL) X && *obj;
00601 } else {
00602 obj = new T();
00603 X && *obj;
00604 }
00605 sznMethodEnd()
00606 };
00607
00608 template<typename T>
00609 finline OTpl<T> O( T*& obj, int variant = DEFAULT_V ) {
00610 return OTpl<T>(obj,variant);
00611 }
00612
00613 }
00614
00615
00616
00617
00618
00619
00620 template<int __variant, typename X> finline
00621 size_t data_length_v( const X& obj ) {
00622 DataStreamTpl<MEASURE, __variant> stream;
00623 return (stream && (X&)obj).getCurrentLength();
00624 }
00625
00626 template<typename X> finline
00627 size_t data_length( const X& obj ) {
00628 return data_length_v<DEFAULT_V>(obj);
00629 }
00630
00631 template<Mode __mode, int __variant, typename X> finline
00632 size_t data_serialization_v( X& obj, Data& data,
00633 if_is_base_of(Serializeable, X) ) {
00634 if (__mode == SERIALIZE) {
00635 DataStreamTpl<SERIALIZE, __variant> stream;
00636 size_t len = data_length_v<__variant>(obj);
00637 stream.ensureLength( len );
00638 return (data = (stream && obj).getData()).getLength();
00639 } else {
00640 DataStreamTpl<DESERIALIZE, __variant> stream( data );
00641 return (stream && obj).getCurrentLength();
00642 }
00643 }
00644
00645 template<Mode __mode, int __variant, typename X>
00646 size_t slow_data_serialization_v( X& obj, Data& data,
00647 if_is_base_of(Serializeable, X) ) {
00648 return slow_data_serialization_v<__mode,__variant>(obj,data);
00649 }
00650
00651 template<Mode __mode, typename X>
00652 size_t data_serialization( X& obj, Data& data,
00653 if_is_base_of( Serializeable, X ) ) {
00654 return slow_data_serialization_v<__mode, DEFAULT_V>( obj, data );
00655 }
00656
00657 template<int __variant, typename X>
00658 Data data_serialize_v( const X& obj, if_is_base_of(Serializeable, X) ) {
00659 Data data; data_serialization_v<SERIALIZE, __variant>( (X&)obj, data );
00660 return data;
00661 }
00662
00663 template<typename X>
00664 Data data_serialize( const X& obj, if_is_base_of(Serializeable, X) ) {
00665 return data_serialize_v<DEFAULT_V>(obj);
00666 }
00667
00668 template<int __variant, typename X>
00669 size_t data_deserialize_v( X& obj, Data data, if_is_base_of(Serializeable, X) ) {
00670 return data_serialization_v<DESERIALIZE,__variant>( obj, data );
00671 }
00672
00673 template<typename X>
00674 size_t data_deserialize( X& obj, Data data,
00675 if_is_base_of(Serializeable, X) ) {
00676 return data_deserialize_v<DEFAULT_V>(obj, data);
00677 }
00678
00679
00680
00681 finline bool data_serialization( VSerializeable* obj, Data& data,
00682 Mode mode, int variant ) {
00683 size_t length = obj->SERIALIZATION_METHOD_NAME( mode, data, variant );
00684 return length != 0;
00685 }
00686
00687 finline Data data_serialize( const VSerializeable* obj,
00688 int variant ) {
00689 Data data;
00690 data_serialization( (VSerializeable*)obj, data, SERIALIZE, variant );
00691 return data;
00692 }
00693
00694 finline bool data_deserialize( VSerializeable* obj, Data& data,
00695 int variant ) {
00696 return data_serialization( obj, data, DESERIALIZE, variant );
00697 }
00698
00699 finline size_t data_length( const VSerializeable* obj, int variant ) {
00700 return ((VSerializeable*)obj)->SERIALIZATION_METHOD_NAME( MEASURE,
00701 (Data&)Data::UNSPECIFIED, variant );
00702 }
00703
00704
00705
00706 SERIALIZATION_NS_END()
00707
00708 #endif