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 DATA_HPP_
00040 #define DATA_HPP_
00041
00042
00043 #include <stdlib.h>
00044 #include <iostream>
00045 #include <boost/cstdint.hpp>
00046
00047
00048 template<typename T> class DefaultDataModel;
00049 template<typename T = uint8_t, typename DataModel = DefaultDataModel<uint8_t> > class DataTpl;
00050 typedef DataTpl<> Data;
00051 template<typename T, typename DataModel> std::ostream& operator<<(std::ostream& stream, DataTpl<T, DataModel>& data);
00052
00053
00054 #include "../internal/Utilities.hpp"
00055
00056
00057 #include "DataUtilities.hpp"
00058 #include "Serialization.hpp"
00059
00074 template<typename T, typename DataModel>
00075 class DataTpl: public Serializeable { SERIALIZEABLE
00076 protected:
00077 typedef DataTpl<T,DataModel> _Data;
00078 DataModel model;
00079
00080 public:
00081 static const size_t word_width = sizeof(T) * 8;
00082
00083 class DataManipulator {
00084 private:
00085 DataModel bits;
00086 size_t index;
00087
00088 public:
00089 finline DataManipulator( DataModel& _bits, size_t _index) :
00090 bits(_bits), index(_index) {
00091 }
00092
00093 template<typename X>
00094 finline operator X() const {
00095 return bitget<X>(bits.buffer(), index);
00096 }
00097
00098 template<typename X>
00099 finline DataManipulator& operator=(X value) {
00100 bitset(value, bits.buffer(), index );
00101 return *this;
00102 }
00103
00104 template<typename X>
00105 finline void set(X value, size_t length = sizeof(X) * 8, if_uint(X)) {
00106 bitcpy(value, 0, bits.buffer(), index, length);
00107 }
00108
00109 template<typename X>
00110 finline void set(X value, size_t length = sizeof(X) * 8, if_int(X)) {
00111 set(_unsigned(value),length);
00112 }
00113
00114 template<typename X>
00115 finline void get(X& value, size_t length = sizeof(X) * 8, if_uint(X)) const {
00116 value = bitget<X> (bits.buffer(), index, length);
00117 }
00118
00119 template<typename X>
00120 finline void get(X& value, size_t length = sizeof(X) * 8, if_int(X)) const {
00121 _unsigned(value) = bitget<X> (bits.buffer(), index, length);
00122 }
00123
00124 finline void get(bool& value) const {
00125 value = bitget( bits.buffer(), index );
00126 }
00127 };
00128
00129 public:
00130 static const Data UNSPECIFIED;
00131
00135 finline DataTpl() : model() {
00136 }
00137
00141 finline DataTpl(const DataTpl<T, DataModel>& copy) {
00142 this->model = copy.model;
00143 }
00144
00145 finline DataTpl( const DataModel& _model ) : model( _model ) {
00146 }
00147
00151 finline DataTpl(const T* buffer, size_t length) {
00152 model.buffer() = buffer;
00153 model.length() = length;
00154 }
00155
00159 finline DataTpl( T* buffer, size_t length ) {
00160 model.buffer() = buffer;
00161 model.length() = length;
00162 }
00163
00168 finline DataTpl(size_t length) : model() {
00169 model.resize(length);
00170 }
00171
00172
00176 finline T* getBuffer() const {
00177 return model.buffer();
00178 }
00179
00183 finline size_t getLength() const {
00184 return model.length();
00185 }
00189 void setLength(size_t new_length) {
00190 model.resize(new_length);
00191 }
00192
00199 finline void ensureLength( size_t neededLength ) {
00200 if ((int) neededLength > model.length() ) model.resize(neededLength);
00201 }
00202
00209 finline DataManipulator operator[](size_t index) {
00210 return DataManipulator(model, index);
00211 }
00212
00219 finline const DataManipulator operator[](size_t index) const {
00220 return DataManipulator(model, index);
00221 }
00222
00223 _Data sub( size_t index, size_t length = ~0 ) {
00224 if (length == ~0) length = model.length()-index;
00225 return _Data(model.sub(index,length));
00226 }
00227
00235 _Data clone( size_t index, size_t length ) const {
00236 DataModel new_model = model.clone(index,length);
00237 return _Data(new_model);
00238 }
00239
00245 _Data clone() const {
00246 DataModel new_model = model.clone( 0, model.length() );
00247 return _Data(new_model);
00248 }
00249
00255 finline bool isEmpty() const {
00256 return (model.length() == 0);
00257 }
00258
00265 finline bool isUnspecified() const {
00266 return model.isUnspecified();
00267 }
00268
00274 finline void release() {
00275 model.release();
00276 }
00277
00278
00279
00283 template<typename X>
00284 _Data& operator= (const DataTpl<X>& source) {
00285 this->model = source.model;
00286 return *this;
00287 }
00288
00293 template<typename X>
00294 finline bool operator==( DataTpl<X>& data) {
00295 return (data.model.buffer() == model.buffer() &&
00296 data.model.length() == model.length() );
00297 }
00298
00299 finline _Data& operator&=(_Data& data) {
00300 return *this;
00301 }
00302
00303 finline _Data& operator|=(_Data& data) {
00304 return *this;
00305 }
00306
00307 finline _Data& operator^=(_Data& data) {
00308 return *this;
00309 }
00310
00311
00312
00313 finline _Data operator&(_Data& data) {
00314 return (this->clone() &= data);
00315 }
00316
00317 finline _Data operator|(_Data& data) {
00318 return (this->clone() |= data);
00319 }
00320
00321 finline _Data operator^(_Data& data) {
00322 return (this->clone() ^= data);
00323 }
00324 };
00325
00326
00327 template<typename T, typename DataModel>
00328 std::ostream& operator<<(std::ostream& stream, DataTpl<T, DataModel>& data) {
00329 stream << "[" << bitstr(data.getBuffer(), data.getLength(), 4)
00330 << "|'";
00331 char* buffer = (char*) data.getBuffer();
00332 for (size_t i = 0; i < data.getLength() / 8; i++) {
00333 char c = buffer[i] < 32 ? '.' : buffer[i];
00334 stream << c;
00335 }
00336 stream << "']";
00337 return stream;
00338 }
00339
00340
00341 template<typename T, typename DataModel>
00342 const Data DataTpl<T, DataModel>::UNSPECIFIED;
00343
00349 template<typename _T>
00350 class DefaultDataModel {
00351 public:
00352 typedef _T T;
00353 typedef DefaultDataModel<T> _Model;
00354
00355 private:
00356
00357 int32_t bufferLen;
00358 T* bufferPtr;
00359
00360 static finline int calcLength(int length) {
00361 if (length<0) return 0;
00362 return ((length/8)/sizeof(T)+1);
00363 }
00364 public:
00365 finline DefaultDataModel() {
00366 bufferPtr = NULL;
00367 bufferLen = -1;
00368 }
00369
00370 finline DefaultDataModel( void* buffer, size_t length ) {
00371 bufferPtr = (T*)buffer;
00372 bufferLen = length;
00373 }
00374
00375 finline DefaultDataModel( const _Model& source ) {
00376 this->bufferPtr = source.bufferPtr;
00377 this->bufferLen = source.bufferLen;
00378 }
00379
00380 finline _Model& operator=( const _Model& source ) {
00381 this->bufferPtr = source.bufferPtr;
00382 this->bufferLen = source.bufferLen;
00383 return *this;
00384 }
00385
00386 finline T*& buffer() {
00387 return bufferPtr;
00388 }
00389
00390 finline T* buffer() const {
00391 return bufferPtr;
00392 }
00393
00394 finline int32_t& length() {
00395 return bufferLen;
00396 }
00397
00398 finline int32_t length() const {
00399 return bufferLen;
00400 }
00401
00402 finline bool isUnspecified() const {
00403 return bufferLen < 0;
00404 }
00405
00406 finline void resize( size_t new_length ) {
00407 size_t old_length = calcLength(bufferLen);
00408 size_t res_length = calcLength(new_length);
00409 if (old_length != res_length) {
00410 T* new_buffer = new T[res_length];
00411 if (bufferPtr != NULL) {
00412 size_t clength = res_length < old_length ? res_length : old_length;
00413 memcpy( new_buffer, bufferPtr, clength*sizeof(T) );
00414 delete [] bufferPtr;
00415 }
00416 bufferPtr = new_buffer;
00417 bufferLen = new_length;
00418 }
00419 }
00420
00421 finline void release() {
00422 delete [] bufferPtr;
00423 bufferPtr = NULL;
00424 bufferLen = -1;
00425 }
00426
00427 finline _Model sub( size_t index, size_t length ) {
00428 return _Model( bufferPtr + index/sizeof(T), length );
00429 }
00430
00431 finline _Model clone( size_t index, size_t length ) const {
00432 _Model new_model;
00433 new_model.resize( length );
00434 bitcpy( this->buffer(), index, new_model.buffer(), 0, length );
00435 return new_model;
00436 }
00437 };
00438
00439
00440 sznBeginDefault( Data, X ){
00441 for (size_t i = 0; i< getLength() / word_width; i++) X && getBuffer()[i];
00442 }sznEnd();
00443
00444 #endif