mirror of
https://github.com/fraillt/bitsery.git
synced 2026-08-05 12:59:22 +00:00
130 lines
4.3 KiB
C++
130 lines
4.3 KiB
C++
//
|
|
// Created by Mindaugas Vinkelis on 2016-11-11.
|
|
//
|
|
|
|
#ifndef PROJECT_TEMPLATE_BUFFER_READER_H
|
|
#define PROJECT_TEMPLATE_BUFFER_READER_H
|
|
|
|
#include "Common.h"
|
|
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
|
|
namespace bitsery {
|
|
|
|
struct BufferReader {
|
|
|
|
using value_type = uint8_t;
|
|
|
|
BufferReader(const std::vector<uint8_t> &buf) : _buf{buf}, _pos{std::begin(buf)} {
|
|
|
|
}
|
|
|
|
template<size_t SIZE, typename T>
|
|
bool readBytes(T &v) {
|
|
static_assert(std::is_integral<T>(), "");
|
|
static_assert(sizeof(T) == SIZE, "");
|
|
using UT = typename std::make_unsigned<T>::type;
|
|
return !m_scratch
|
|
? directRead(&v, 1)
|
|
: readBits(reinterpret_cast<UT &>(v), BITS_SIZE<T>);
|
|
}
|
|
|
|
template<size_t SIZE, typename T>
|
|
bool readBuffer(T *buf, size_t count) {
|
|
static_assert(std::is_integral<T>(), "");
|
|
static_assert(sizeof(T) == SIZE, "");
|
|
|
|
if (!m_scratchBits) {
|
|
return directRead(buf, count);
|
|
} else {
|
|
using UT = typename std::make_unsigned<T>::type;
|
|
//todo improve implementation
|
|
const auto end = buf + count;
|
|
for (auto it = buf; it != end; ++it) {
|
|
if (!readBits(reinterpret_cast<UT &>(*it), BITS_SIZE<T>))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
template<typename T>
|
|
bool readBits(T &v, size_t bitsCount) {
|
|
static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
|
|
assert(bitsCount <= BITS_SIZE<T>);
|
|
|
|
const auto bytesRequired = bitsCount > m_scratchBits
|
|
? ((bitsCount - 1 - m_scratchBits) >> 3) + 1u
|
|
: 0u;
|
|
if (static_cast<size_t>(std::distance(_pos, std::end(_buf))) < bytesRequired)
|
|
return false;
|
|
readBitsInternal(v, bitsCount);
|
|
return true;
|
|
}
|
|
|
|
bool align() {
|
|
if (m_scratchBits) {
|
|
SCRATCH_TYPE tmp{};
|
|
readBitsInternal(tmp, BITS_SIZE<value_type> - m_scratchBits);
|
|
return tmp == 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool isCompleted() const {
|
|
return _pos == std::end(_buf);
|
|
}
|
|
|
|
private:
|
|
const std::vector<value_type> &_buf;
|
|
decltype(std::begin(_buf)) _pos;
|
|
|
|
template<typename T>
|
|
bool directRead(T *v, size_t count) {
|
|
static_assert(!std::is_const<T>::value, "");
|
|
const auto bytesCount = sizeof(T) * count;
|
|
if (static_cast<size_t>(std::distance(_pos, std::end(_buf))) < bytesCount)
|
|
return false;
|
|
std::copy_n(_pos, bytesCount, reinterpret_cast<value_type *>(v));
|
|
std::advance(_pos, bytesCount);
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
void readBitsInternal(T &v, size_t size) {
|
|
auto bitsLeft = size;
|
|
T res{};
|
|
while (bitsLeft > 0) {
|
|
auto bits = std::min(bitsLeft, BITS_SIZE<value_type>);
|
|
if (m_scratchBits < bits) {
|
|
value_type tmp;
|
|
|
|
std::copy_n(_pos, 1, reinterpret_cast<value_type *>(&tmp));
|
|
std::advance(_pos, 1);
|
|
|
|
m_scratch |= static_cast<SCRATCH_TYPE>(tmp) << m_scratchBits;
|
|
m_scratchBits += BITS_SIZE<value_type>;
|
|
}
|
|
auto shiftedRes =
|
|
static_cast<T>(m_scratch & ((static_cast<SCRATCH_TYPE>(1) << bits) - 1)) << (size - bitsLeft);
|
|
res |= shiftedRes;
|
|
m_scratch >>= bits;
|
|
m_scratchBits -= bits;
|
|
bitsLeft -= bits;
|
|
}
|
|
v = res;
|
|
}
|
|
|
|
using SCRATCH_TYPE = typename BIGGER_TYPE<value_type>::type;
|
|
|
|
SCRATCH_TYPE m_scratch{};
|
|
size_t m_scratchBits{}; ///< Number of bits currently in the scratch buffer. If the user wants to read more bits than this, we have to go fetch another dword from memory.
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif //PROJECT_TEMPLATE_BUFFER_READER_H
|