131 lines
3.3 KiB
C++
131 lines
3.3 KiB
C++
#include "pichunkstream.h"
|
|
|
|
/*! \class PIChunkStream
|
|
* \brief Class for binary serialization
|
|
*
|
|
* \section PIChunkStream_sec0 Synopsis
|
|
* This class provides very handly mechanism to store and restore values to and from
|
|
* \a PIByteArray. The main advantage of using this class is that your binary data
|
|
* become independent from order and collection of your values.
|
|
*
|
|
* \section PIChunkStream_sec1 Mechanism
|
|
* %PIChunkStream works with items called "chunk". Chunk is an ID and any value that
|
|
* can be stored and restored to \a PIByteArray with stream operators << and >>.
|
|
* You can place chunks to stream and read chunks from stream.
|
|
*
|
|
* To construct %PIChunkStream for writing data use any constructor. Empty constructor
|
|
* creates internal empty buffer that can be accessed by function \a data().
|
|
* Non-empty constructor works with given byte array.
|
|
*
|
|
* To read chunks from byte array use function \a read() that returns ID of
|
|
* next chunk. Then you can get value of this chunk with function \a getData(),
|
|
* but you should definitely know type of this value. You can read from byte array
|
|
* while \a atEnd() if false.
|
|
*
|
|
* \section PIChunkStream_ex0 Example
|
|
* Prepare your structs to work with %PIChunkStream
|
|
* \snippet pichunkstream.cpp struct
|
|
* Writing to %PIChunkStream
|
|
* \snippet pichunkstream.cpp write
|
|
* Reading from %PIChunkStream
|
|
* \snippet pichunkstream.cpp read
|
|
*/
|
|
|
|
|
|
void PIChunkStream::setSource(const PIByteArray & data) {
|
|
data_ = const_cast<PIByteArray*>(&data);
|
|
_init();
|
|
}
|
|
|
|
|
|
void PIChunkStream::setSource(PIByteArray * data) {
|
|
data_ = (data ? data : &tmp_data);
|
|
_init();
|
|
}
|
|
|
|
|
|
int PIChunkStream::read() {
|
|
switch (version_) {
|
|
case Version_1:
|
|
(*data_) >> last_id >> last_data;
|
|
break;
|
|
case Version_2:
|
|
last_id = readVInt(*data_);
|
|
last_data.resize(readVInt(*data_));
|
|
//piCout << last_id << last_data.size();
|
|
(*data_) >> PIByteArray::RawData(last_data.data(), last_data.size_s());
|
|
break;
|
|
default: break;
|
|
}
|
|
return last_id;
|
|
}
|
|
|
|
|
|
void PIChunkStream::readAll() {
|
|
data_map.clear();
|
|
while (!atEnd()) {
|
|
read();
|
|
data_map[last_id] = last_data;
|
|
}
|
|
}
|
|
|
|
|
|
PIChunkStream::~PIChunkStream() {
|
|
|
|
}
|
|
|
|
|
|
void PIChunkStream::_init() {
|
|
last_id = -1;
|
|
last_data.clear();
|
|
if (!data_->isEmpty()) {
|
|
uchar v = data_->at(0);
|
|
if ((v & 0x80) == 0x80) {
|
|
v &= 0x7f;
|
|
switch (v) {
|
|
case 2: version_ = (uchar)Version_2; data_->pop_front(); break;
|
|
default: version_ = Version_1; break;
|
|
}
|
|
} else
|
|
version_ = Version_1;
|
|
}
|
|
}
|
|
|
|
|
|
uint PIChunkStream::readVInt(PIByteArray & s) {
|
|
if (s.isEmpty()) return 0;
|
|
uchar bytes[4]; s >> bytes[0];
|
|
uchar abc = 0;
|
|
for (abc = 0; abc < 3; ++abc) {
|
|
uchar mask = (0x80 >> abc);
|
|
if ((bytes[0] & mask) == mask) {
|
|
//if (s.isEmpty()) return 0;
|
|
bytes[0] &= (mask - 1);
|
|
s >> bytes[abc + 1];
|
|
} else break;
|
|
}
|
|
uint ret = 0;
|
|
for (int i = 0; i <= abc; ++i) {
|
|
ret += (bytes[i] << (8 * ((int)abc - i)));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIChunkStream::writeVInt(PIByteArray & s, uint val) {
|
|
if (val > 0xfffffff) return;
|
|
if (val <= 0x7f) {
|
|
s << uchar(val);
|
|
return;
|
|
}
|
|
if (val <= 0x3fff) {
|
|
s << uchar((val >> 8) | 0x80) << uchar(val & 0xff);
|
|
return;
|
|
}
|
|
if (val <= 0x1fffff) {
|
|
s << uchar((val >> 16) | 0xc0) << uchar((val >> 8) & 0xff) << uchar(val & 0xff);
|
|
return;
|
|
}
|
|
s << uchar((val >> 24) | 0xe0) << uchar((val >> 16) & 0xff) << uchar((val >> 8) & 0xff) << uchar(val & 0xff);
|
|
}
|