{

public:

using self_type = BitstreamReader<BufferType>;

// for the moment we simply use pointers, but with some traits this can be extended to

// containers

using value_type = BufferType;

using iterator = const value_type*;

static constexpr size_t value_size = sizeof(value_type) * 8;

BitstreamReader() = delete;

BitstreamReader(iterator start, iterator end)

: mStart(start), mEnd(end), mCurrent(mStart), mBitPosition(value_size)

{

}

~BitstreamReader() = default;

/// Check reader's state

/// @return true if not in error state

bool good() const

{

return mBitPosition > 0;

}

/// Indicates end of data

/// @return true if end of resource is reached

bool eof() const

{

return mCurrent == mEnd && mBitPosition > 0;

}

/// Reset the reader, start over at beginning

void reset()

{

mCurrent = mStart;

mBitPosition = value_size;

}

/// Get the next N bits without moving the read position

/// if bitlength is smaller than the size of data type, result is aligned to LSB

/// TODO: this also works nicely for bitsets, but then the bitlength has to be specified

/// as template parameter, want to do a specific overload, but needs more work to catch

/// all cases.

/// @param v target variable passed by reference

/// @return number of poked bits

template <typename T, size_t N = sizeof(T) * 8>

size_t peek(T& v)

{

static_assert(N <= sizeof(T) * 8);

return peek<T, false>(v, N);

}

/// Get the next n bits without moving the read position

/// if bitlength is smaller than the size of data type, result is aligned to LSB

/// @param v target variable passed by reference

/// @param bitlength number of bits to read

/// @return number of poked bits

template <typename T>

size_t peek(T& v, size_t bitlength)

{

return peek<T, true>(v, bitlength);

}

/// Move read position

/// @param bitlength move count in number of bits

void seek(size_t bitlength)

{

while (good() && bitlength > 0 && mCurrent != mEnd) {

if (bitlength >= mBitPosition) {

bitlength -= mBitPosition;

mBitPosition = 0;

} else {

mBitPosition -= bitlength;

bitlength = 0;

}

if (mBitPosition == 0) {

mCurrent++;

mBitPosition = value_size;

}

}

if (bitlength > 0) {

mBitPosition = 0;

}

}

/// Get the next n bits and move the read position

template <typename T, size_t N = sizeof(T) * 8>

T get()

{

T result;

peek<T, N>(result);

seek(N);

return result;

}

/// Get the next n and move the read position

template <typename T>

T get(size_t bitlength = sizeof(T) * 8)

{

T result;

peek<T>(result, bitlength);

seek(bitlength);

return result;

}

/// @class Bits

/// @brief Helper class to get value of specified type which holds the number used bits

///

/// The class holds both the extracted value access via peek method and the number of used

/// bits. The reader will be incremented when the object is destroyed.

/// The number of bits can be adjusted by using markUsed method

template <typename FieldType, size_t N = sizeof(FieldType) * 8, typename ParentType = self_type>

class Bits

{

public:

using field_type = FieldType;

static_assert(N <= sizeof(FieldType) * 8);

Bits()

: mParent(nullptr), mData(0), mLength(0)

{

}

Bits(ParentType* parent, FieldType&& data)

: mParent(parent), mData(std::move(data)), mLength(N)

{

}

Bits(Bits&& other)

: mParent(other.mParent), mData(std::move(other.mData)), mLength(other.mLength)

{

other.mParent = nullptr;

other.mLength = 0;

}

~Bits()

{

if (mParent) {

mParent->seek(mLength);

}

}

auto& operator=(Bits<FieldType, N, ParentType>&& other)

{

mParent = other.mParent;

mData = std::move(other.mData);

mLength = other.mLength;

other.mParent = nullptr;

other.mLength = 0;

return *this;

}

FieldType& operator*()

{

return mData;

}

void markUsed(size_t length)

{

mLength = length;

}

private:

ParentType* mParent;

FieldType mData;

size_t mLength;

};

/// Read an integral value from the stream

template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>

self_type& operator>>(T& target)

{

target = get<T>();

return *this;

}

/// Read a bitstream value from the stream

template <size_t N>

self_type& operator>>(std::bitset<N>& target)

{

target = get<std::bitset<N>, N>();

return *this;

}

/// Read a Bits object from the stream

template <typename T>

self_type& operator>>(Bits<T>& target)

{

T bitfield;

peek<T>(bitfield);

target = std::move(Bits<T>(this, std::move(bitfield)));

return *this;

}

private:

/// The internal peek method

template <typename T, bool RuntimeCheck>

size_t peek(T& result, size_t bitlength)

{

if constexpr (RuntimeCheck) {

// the runtime check is disabled if bitlength is derived at compile time

if (bitlength > sizeof(T) * 8) {

throw std::length_error(std::string("requested bit length ") + std::to_string(bitlength) + " does not fit size of result data type " + std::to_string(sizeof(T) * 8));

}

}

result = 0;

size_t bitsToWrite = bitlength;

auto current = mCurrent;

auto bitsAvailable = mBitPosition;

while (bitsToWrite > 0 && current != mEnd) {

// extract available bits

value_type mask = ~value_type(0) >> (value_size - bitsAvailable);

if (bitsToWrite >= bitsAvailable) {

T value = (*current & mask) << (bitsToWrite - bitsAvailable);

result |= value;

bitsToWrite -= bitsAvailable;

bitsAvailable = 0;

} else {

value_type value = (*current & mask) >> (bitsAvailable - bitsToWrite);

result |= value;

bitsAvailable -= bitsToWrite;

bitsToWrite = 0;

}

if (bitsAvailable == 0) {

current++;

bitsAvailable = value_size;

}

}

return bitlength - bitsToWrite;

}

/// start of resource

iterator mStart;

/// end of resource

iterator mEnd;

/// current position in resource

iterator mCurrent;

/// bit position in current element

size_t mBitPosition;