713 lines
28 KiB
C++
713 lines
28 KiB
C++
/*! \file pibytearray.h
|
||
* \ingroup Core
|
||
* \~\brief
|
||
* \~english Byte array
|
||
* \~russian Байтовый массив
|
||
*/
|
||
/*
|
||
PIP - Platform Independent Primitives
|
||
Byte array
|
||
Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
|
||
|
||
This program is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU Lesser General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU Lesser General Public License for more details.
|
||
|
||
You should have received a copy of the GNU Lesser General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#ifndef PIBYTEARRAY_H
|
||
#define PIBYTEARRAY_H
|
||
|
||
#include "pichar.h"
|
||
#include "pibitarray.h"
|
||
#include "pimap.h"
|
||
#include "pivector2d.h"
|
||
#include <stdio.h>
|
||
|
||
class PIString;
|
||
class PIByteArray;
|
||
|
||
|
||
//! \ingroup Core
|
||
//! \~\brief
|
||
//! \~english The %PIByteArray class provides an array of bytes.
|
||
//! \~russian Класс %PIByteArray представляет собой массив байтов.
|
||
class PIP_EXPORT PIByteArray: public PIDeque<uchar>
|
||
{
|
||
public:
|
||
|
||
//! \~english Constructs an empty byte array
|
||
//! \~russian Создает пустой байтовый массив
|
||
PIByteArray() {;}
|
||
|
||
//! \~english Constructs copy of byte array "o"
|
||
//! \~russian Создает копию байтового массива "o"
|
||
PIByteArray(const PIByteArray & o): PIDeque<uchar>(o) {}
|
||
|
||
//! \~english Constructs copy of byte array "o"
|
||
//! \~russian Создает копию байтового массива "o"
|
||
PIByteArray(const PIDeque<uchar> & o): PIDeque<uchar>(o) {}
|
||
|
||
PIByteArray(PIByteArray && o): PIDeque<uchar>(std::move(o)) {}
|
||
|
||
//! \~english Constructs 0-filled byte array with size "size"
|
||
//! \~russian Создает заполненный "0" байтовый массив размером "size"
|
||
PIByteArray(const uint size) {resize(size);}
|
||
|
||
//! \~english Constructs byte array from data "data" and size "size"
|
||
//! \~russian Создает байтовый массив из данных по указателю "data" размером "size"
|
||
PIByteArray(const void * data, const uint size): PIDeque<uchar>((const uchar*)data, size_t(size)) {}
|
||
|
||
//! \~english Constructs byte array with size "size" filled by "t"
|
||
//! \~russian Создает заполненный "t" байтовый массив размером "size"
|
||
PIByteArray(const uint size, uchar t): PIDeque<uchar>(size, t) {}
|
||
|
||
|
||
//! \~english Help struct to store/restore custom blocks of data to/from PIByteArray
|
||
//! \~russian Вспомогательная структура для сохранения/извлечения произвольного блока данных в/из байтового массива
|
||
struct RawData {
|
||
friend PIByteArray & operator <<(PIByteArray & s, const PIByteArray::RawData & v);
|
||
friend PIByteArray & operator >>(PIByteArray & s, PIByteArray::RawData v);
|
||
public:
|
||
//! \~english Constructs data block
|
||
//! \~russian Создает блок данных
|
||
RawData(void * data = 0, int size = 0) {d = data; s = size;}
|
||
RawData(const RawData & o) {d = o.d; s = o.s;}
|
||
//! \~english Constructs data block
|
||
//! \~russian Создает блок данных
|
||
RawData(const void * data, const int size) {d = const_cast<void * >(data); s = size;}
|
||
RawData & operator =(const RawData & o) {d = o.d; s = o.s; return *this;}
|
||
private:
|
||
void * d;
|
||
int s;
|
||
};
|
||
|
||
//! \~english Return resized byte array
|
||
//! \~russian Возвращает копию байтового массива с измененным размером
|
||
PIByteArray resized(uint new_size) const {PIByteArray ret(new_size); memcpy(ret.data(), data(), new_size); return ret;}
|
||
|
||
//! \~english Return sub-array starts from "index" and has "count" or less bytes
|
||
//! \~russian Возвращает подмассив с данными от индекса "index" и размером не более "count"
|
||
PIByteArray getRange(size_t index, size_t count) const {
|
||
return PIDeque<uchar>::getRange(index, count);
|
||
}
|
||
|
||
|
||
//! \~english Convert data to Base 64 and return this byte array
|
||
//! \~russian Преобразует данные в Base 64 и возвращает текущий массив
|
||
PIByteArray & convertToBase64();
|
||
|
||
//! \~english Convert data from Base 64 and return this byte array
|
||
//! \~russian Преобразует данные из Base 64 и возвращает текущий массив
|
||
PIByteArray & convertFromBase64();
|
||
|
||
//! \~english Return converted to Base 64 data
|
||
//! \~russian Возвращает копию байтового массива, преобразованного в Base 64
|
||
PIByteArray toBase64() const;
|
||
|
||
PIByteArray & compressRLE(uchar threshold = 192);
|
||
PIByteArray & decompressRLE(uchar threshold = 192);
|
||
PIByteArray compressedRLE(uchar threshold = 192) {PIByteArray ba(*this); ba.compressRLE(threshold); return ba;}
|
||
PIByteArray decompressedRLE(uchar threshold = 192) {PIByteArray ba(*this); ba.decompressRLE(threshold); return ba;}
|
||
|
||
//! \~english Return string representation of data, each byte in "base" base, separated by spaces
|
||
//! \~russian Возвращает текстовое представление байтового массива, каждый байт в "base" системе, с пробелами
|
||
PIString toString(int base = 16) const;
|
||
|
||
//! \~english
|
||
//! Returns a hex encoded copy of the byte array, without spaces.
|
||
//! The hex encoding uses the numbers 0-9 and the letters a-f.
|
||
//! \~russian
|
||
//! Возвращает шестнадцатеричное представление массива, без пробелов.
|
||
//! Оно использует цифры 0-9 и буквы a-f.
|
||
PIString toHex() const;
|
||
|
||
//! \~english Add to the end data "data" with size "size"
|
||
//! \~russian Добавляет в конец массива данные по указателю "data" размером "size"
|
||
PIByteArray & append(const void * data_, int size_) {uint ps = size(); enlarge(size_); memcpy(data(ps), data_, size_); return *this;}
|
||
|
||
//! \~english Add to the end byte array "data"
|
||
//! \~russian Добавляет в конец массива содержимое массива "data"
|
||
PIByteArray & append(const PIByteArray & data_) {uint ps = size(); enlarge(data_.size_s()); memcpy(data(ps), data_.data(), data_.size()); return *this;}
|
||
|
||
//! \~english Add to the end "t"
|
||
//! \~russian Добавляет в конец массива байт "t"
|
||
PIByteArray & append(uchar t) {push_back(t); return *this;}
|
||
|
||
//! \~english Returns 8-bit checksum
|
||
//! \~russian Возвращает 8-битную контрольную сумму
|
||
uchar checksumPlain8(bool inverse = true) const;
|
||
|
||
//! \~english Returns 32-bit checksum
|
||
//! \~russian Возвращает 32-битную контрольную сумму
|
||
uint checksumPlain32(bool inverse = true) const;
|
||
|
||
//! \~english Returns hash of content
|
||
//! \~russian Возвращает хэш содержимого
|
||
uint hash() const;
|
||
|
||
void operator =(const PIDeque<uchar> & d) {resize(d.size()); memcpy(data(), d.data(), d.size());}
|
||
|
||
PIByteArray & operator =(const PIByteArray & o) {if (this == &o) return *this; clear(); append(o); return *this;}
|
||
|
||
PIByteArray & operator =(PIByteArray && o) {swap(o); return *this;}
|
||
|
||
static PIByteArray fromUserInput(PIString str);
|
||
|
||
static PIByteArray fromHex(PIString str);
|
||
|
||
//! \~english Return converted from Base 64 data
|
||
//! \~russian Возвращает массив из Base 64 представления
|
||
static PIByteArray fromBase64(const PIByteArray & base64);
|
||
static PIByteArray fromBase64(const PIString & base64);
|
||
|
||
|
||
class StreamRef {
|
||
public:
|
||
StreamRef(PIByteArray & s): ba(s) {}
|
||
operator PIByteArray&() {return ba;}
|
||
private:
|
||
PIByteArray & ba;
|
||
};
|
||
|
||
};
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Byte arrays compare operator
|
||
//! \~russian Оператор сравнения
|
||
inline bool operator <(const PIByteArray & v0, const PIByteArray & v1) {
|
||
if (v0.size() == v1.size()) {
|
||
if (v0.isEmpty()) return false;
|
||
return memcmp(v0.data(), v1.data(), v0.size()) < 0;
|
||
}
|
||
return v0.size() < v1.size();
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Byte arrays compare operator
|
||
//! \~russian Оператор сравнения
|
||
inline bool operator >(const PIByteArray & v0, const PIByteArray & v1) {
|
||
if (v0.size() == v1.size()) {
|
||
if (v0.isEmpty()) return false;
|
||
return memcmp(v0.data(), v1.data(), v0.size()) > 0;
|
||
}
|
||
return v0.size() > v1.size();
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Byte arrays compare operator
|
||
//! \~russian Оператор сравнения
|
||
inline bool operator ==(const PIByteArray & v0, const PIByteArray & v1) {
|
||
if (v0.size() == v1.size()) {
|
||
if (v0.isEmpty()) return true;
|
||
return memcmp(v0.data(), v1.data(), v0.size()) == 0;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Byte arrays compare operator
|
||
//! \~russian Оператор сравнения
|
||
inline bool operator !=(const PIByteArray & v0, const PIByteArray & v1) {
|
||
if (v0.size() == v1.size()) {
|
||
if (v0.isEmpty()) return false;
|
||
return memcmp(v0.data(), v1.data(), v0.size()) != 0;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#ifdef PIP_STD_IOSTREAM
|
||
//! \relatesalso PIByteArray \brief Output to std::ostream operator
|
||
inline std::ostream & operator <<(std::ostream & s, const PIByteArray & ba);
|
||
#endif
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Output operator to \a PICout
|
||
//! \~russian Оператор вывода в \a PICout
|
||
PIP_EXPORT PICout operator <<(PICout s, const PIByteArray & ba);
|
||
|
||
|
||
|
||
|
||
// store operators for basic types
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
inline PIByteArray & operator <<(PIByteArray & s, const bool v) {s.push_back(v); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
inline PIByteArray & operator <<(PIByteArray & s, const char v) {s.push_back(v); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
inline PIByteArray & operator <<(PIByteArray & s, const uchar v) {s.push_back(v); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for any trivial copyable type
|
||
//! \~russian Оператор сохранения для тривиальных типов
|
||
template<typename T, typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray::StreamRef operator <<(PIByteArray & s, const T & v) {
|
||
int os = s.size_s();
|
||
s.enlarge(sizeof(v));
|
||
memcpy(s.data(os), &v, sizeof(v));
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator, see \ref PIByteArray_sec1 for details
|
||
//! \~russian Оператор сохранения, подробнее в \ref PIByteArray_sec1
|
||
PIP_EXPORT PIByteArray & operator <<(PIByteArray & s, const PIByteArray & v);
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIByteArray::RawData & v) {
|
||
int os = s.size_s();
|
||
if (v.s > 0) {
|
||
s.enlarge(v.s);
|
||
memcpy(s.data(os), v.d, v.s);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIVector of any trivial copyable type
|
||
//! \~russian Оператор сохранения для PIVector тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector<T> & v) {
|
||
s << int(v.size_s());
|
||
int os = s.size_s();
|
||
if (v.size_s() > 0) {
|
||
s.enlarge(v.size_s()*sizeof(T));
|
||
memcpy(s.data(os), v.data(), v.size_s()*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector<T> & v) {
|
||
s << int(v.size_s());
|
||
for (uint i = 0; i < v.size(); ++i) s << v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIDeque of any trivial copyable type
|
||
//! \~russian Оператор сохранения для PIDeque тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIDeque<T> & v) {
|
||
s << int(v.size_s());
|
||
int os = s.size_s();
|
||
if (v.size_s() > 0) {
|
||
s.enlarge(v.size_s()*sizeof(T));
|
||
memcpy(s.data(os), v.data(), v.size_s()*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIDeque<T> & v) {
|
||
s << int(v.size_s());
|
||
for (uint i = 0; i < v.size(); ++i) s << v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIVector2D of any trivial copyable type
|
||
//! \~russian Оператор сохранения для PIVector2D тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector2D<T> & v) {
|
||
s << int(v.rows()) << int(v.cols());
|
||
int os = s.size_s();
|
||
if (v.size_s() > 0) {
|
||
s.enlarge(v.size_s()*sizeof(T));
|
||
memcpy(s.data(os), v.data(), v.size_s()*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector2D<T> & v) {
|
||
s << int(v.rows()) << int(v.cols()) << v.toPlainVector();
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIBitArray & v) {s << v.size_ << v.data_; return s;}
|
||
|
||
//! \relatesalso PIPair
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
template<typename Type0, typename Type1>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIPair<Type0, Type1> & v) {s << v.first << v.second; return s;}
|
||
|
||
|
||
|
||
|
||
// restore operators for basic types
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
inline PIByteArray & operator >>(PIByteArray & s, bool & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
inline PIByteArray & operator >>(PIByteArray & s, char & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
inline PIByteArray & operator >>(PIByteArray & s, uchar & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for any trivial copyable type
|
||
//! \~russian Оператор извлечения для тривиальных типов
|
||
template<typename T, typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray::StreamRef operator >>(PIByteArray & s, T & v) {
|
||
if (s.size() < sizeof(v)) {
|
||
printf("error with %s\n", __PIP_TYPENAME__(T));
|
||
assert(s.size() >= sizeof(v));
|
||
}
|
||
memcpy((void*)(&v), s.data(), sizeof(v));
|
||
s.remove(0, sizeof(v));
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator, see \ref PIByteArray_sec1 for details
|
||
//! \~russian Оператор извлечения, подробнее в \ref PIByteArray_sec1
|
||
PIP_EXPORT PIByteArray & operator >>(PIByteArray & s, PIByteArray & v);
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIByteArray::RawData v) {
|
||
if (s.size_s() < v.s) {
|
||
printf("error with RawData %d < %d\n", (int)s.size_s(), v.s);
|
||
assert(s.size_s() >= v.s);
|
||
}
|
||
if (v.s > 0) {
|
||
memcpy((void*)(v.d), s.data(), v.s);
|
||
s.remove(0, v.s);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIVector of any trivial copyable type
|
||
//! \~russian Оператор извлечения для PIVector тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIVector<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v._resizeRaw(sz);
|
||
if (sz > 0) {
|
||
memcpy(v.data(), s.data(), sz*sizeof(T));
|
||
s.remove(0, sz*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIVector<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v.resize(sz);
|
||
for (int i = 0; i < sz; ++i) s >> v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIDeque of any trivial copyable type
|
||
//! \~russian Оператор извлечения для PIDeque тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIDeque<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIDeque<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v._resizeRaw(sz);
|
||
if (sz > 0) {
|
||
memcpy(v.data(), s.data(), sz*sizeof(T));
|
||
s.remove(0, sz*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIDeque<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIDeque<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v.resize(sz);
|
||
for (int i = 0; i < sz; ++i) s >> v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIVector2D of any trivial copyable type
|
||
//! \~russian Оператор извлечения для PIVector2D тривиальных типов
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if< std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector2D<T> & v) {
|
||
if (s.size_s() < 8) {
|
||
printf("error with PIVecto2Dr<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 8);
|
||
}
|
||
int r, c; s >> r >> c;
|
||
v._resizeRaw(r, c);
|
||
int sz = r*c;
|
||
if (sz > 0) {
|
||
memcpy(v.data(), s.data(), sz*sizeof(T));
|
||
s.remove(0, sz*sizeof(T));
|
||
}
|
||
return s;
|
||
}
|
||
template<typename T,
|
||
typename std::enable_if< std::is_trivially_copyable<T>::value, int>::type = 0,
|
||
typename std::enable_if<!std::is_same<decltype(std::declval<PIByteArray&>() << std::declval<const T &>()), PIByteArray::StreamRef>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector2D<T> & v) {
|
||
if (s.size_s() < 8) {
|
||
printf("error with PIVecto2Dr<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 8);
|
||
}
|
||
int r,c;
|
||
PIVector<T> tmp;
|
||
s >> r >> c >> tmp;
|
||
v = PIVector2D<T>(r, c, tmp);
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIBitArray & v) {assert(s.size_s() >= 8); s >> v.size_ >> v.data_; return s;}
|
||
|
||
//! \relatesalso PIPair
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
template<typename Type0, typename Type1>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIPair<Type0, Type1> & v) {s >> v.first >> v.second; return s;}
|
||
|
||
|
||
|
||
|
||
// store operators for complex types
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIVector of any compound type
|
||
//! \~russian Оператор сохранения для PIVector сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector<T> & v) {
|
||
s << int(v.size_s());
|
||
for (uint i = 0; i < v.size(); ++i) s << v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIDeque of any compound type
|
||
//! \~russian Оператор сохранения для PIDeque сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIDeque<T> & v) {
|
||
s << int(v.size_s());
|
||
for (uint i = 0; i < v.size(); ++i) s << v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator for PIVector2D of any compound type
|
||
//! \~russian Оператор сохранения для PIVector2D сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIVector2D<T> & v) {
|
||
s << int(v.rows()) << int(v.cols()) << v.toPlainVector();
|
||
return s;
|
||
}
|
||
|
||
|
||
|
||
|
||
// restore operators for complex types
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIVector of any compound type
|
||
//! \~russian Оператор извлечения для PIVector сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIVector<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v.resize(sz);
|
||
for (int i = 0; i < sz; ++i) s >> v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIDeque of any compound type
|
||
//! \~russian Оператор извлечения для PIDeque сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIDeque<T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIDeque<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
int sz; s >> sz;
|
||
v.resize(sz);
|
||
for (int i = 0; i < sz; ++i) s >> v[i];
|
||
return s;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator for PIVector2D of any compound type
|
||
//! \~russian Оператор извлечения для PIVector2D сложных типов
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIVector2D<T> & v) {
|
||
if (s.size_s() < 8) {
|
||
printf("error with PIVecto2Dr<%s>\n", __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 8);
|
||
}
|
||
int r,c;
|
||
PIVector<T> tmp;
|
||
s >> r >> c >> tmp;
|
||
v = PIVector2D<T>(r, c, tmp);
|
||
return s;
|
||
}
|
||
|
||
|
||
|
||
|
||
// other types
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store operator
|
||
//! \~russian Оператор сохранения
|
||
template <typename Key, typename T>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const PIMap<Key, T> & v) {
|
||
// s << int(v.pim_index.size_s());
|
||
// for (uint i = 0; i < v.size(); ++i)
|
||
// s << int(v.pim_index[i].index) << v.pim_index[i].key;
|
||
s << v.pim_content;
|
||
return s;
|
||
}
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore operator
|
||
//! \~russian Оператор извлечения
|
||
template <typename Key, typename T>
|
||
inline PIByteArray & operator >>(PIByteArray & s, PIMap<Key, T> & v) {
|
||
if (s.size_s() < 4) {
|
||
printf("error with PIMap<%s, %s>\n", __PIP_TYPENAME__(Key), __PIP_TYPENAME__(T));
|
||
assert(s.size_s() >= 4);
|
||
}
|
||
// int sz; s >> sz; v.pim_index.resize(sz);
|
||
// int ind = 0;
|
||
// for (int i = 0; i < sz; ++i) {
|
||
// s >> ind >> v.pim_index[i].key;
|
||
// v.pim_index[i].index = ind;
|
||
// }
|
||
s >> v.pim_content;
|
||
// if (v.pim_content.size_s() != v.pim_index.size_s()) {
|
||
// piCout << "Warning: loaded invalid PIMap, clear";
|
||
// v.clear();
|
||
// }
|
||
return s;
|
||
}
|
||
|
||
|
||
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator <<(PIByteArray & s, const T & ) {
|
||
static_assert(std::is_trivially_copyable<T>::value, "[PIByteArray] Error: using undeclared operator << for complex type!");
|
||
return s;
|
||
}
|
||
|
||
template<typename T, typename std::enable_if<!std::is_trivially_copyable<T>::value, int>::type = 0>
|
||
inline PIByteArray & operator >>(PIByteArray & s, T & ) {
|
||
static_assert(std::is_trivially_copyable<T>::value, "[PIByteArray] Error: using undeclared operator >> for complex type!");
|
||
return s;
|
||
}
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Returns PIByteArray::hash() of "ba"
|
||
//! \~russian Возвращает PIByteArray::hash() от "ba"
|
||
template<> inline uint piHash(const PIByteArray & ba) {return ba.hash();}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Swap contents betwee "f" and "s"
|
||
//! \~russian Меняет содержимое массивов "f" и "s"
|
||
template<> inline void piSwap(PIByteArray & f, PIByteArray & s) {f.swap(s);}
|
||
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Store "value" to bytearray and returns it
|
||
//! \~russian Сохраняет "value" в байтовый массив и возвращает его
|
||
template <typename T> PIByteArray piSerialize(const T & value) {
|
||
PIByteArray ret;
|
||
ret << value;
|
||
return ret;
|
||
}
|
||
|
||
//! \relatesalso PIByteArray
|
||
//! \~english Restore type "T" from bytearray "data" and returns it
|
||
//! \~russian Извлекает тип "T" из байтового массива "data" и возвращает его
|
||
template <typename T> T piDeserialize(const PIByteArray & data) {
|
||
T ret;
|
||
if (!data.isEmpty()) {
|
||
PIByteArray ba(data);
|
||
ba >> ret;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
|
||
#endif // PIBYTEARRAY_H
|