BitStreamReader.h

Go to the documentation of this file.

#ifndef ZSERIO_BIT_STREAM_READER_H_INC
#define ZSERIO_BIT_STREAM_READER_H_INC
 
#include <algorithm>
#include <cstddef>
#include <type_traits>
 
#include "zserio/BitBuffer.h"
#include "zserio/Bytes.h"
#include "zserio/RebindAlloc.h"
#include "zserio/String.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
class ArrayPreallocation
{
public:
    static constexpr size_t MAX_INITIAL_ARRAY_ALLOCATION = 128 * 1024;
 
    ArrayPreallocation() :
            allocation(MAX_INITIAL_ARRAY_ALLOCATION)
    {}
    explicit ArrayPreallocation(size_t alloc) :
            allocation(alloc)
    {}
    operator size_t() const
    {
        return allocation;
    }
 
private:
    size_t allocation;
};
 
class BitStreamReader
{
public:
    using BitPosType = size_t;
 
    struct ReaderContext
    {
        explicit ReaderContext(
                Span<const uint8_t> readBuffer, size_t readBufferBitSize, size_t maxArrayPrealloc);
 
        ~ReaderContext() = default;
 
        ReaderContext(const ReaderContext&) = delete;
        ReaderContext& operator=(const ReaderContext&) = delete;
 
        ReaderContext(const ReaderContext&&) = delete;
        ReaderContext& operator=(const ReaderContext&&) = delete;
        Span<const uint8_t> buffer; 
        const BitPosType bufferBitSize; 
        uintptr_t cache; 
        uint8_t cacheNumBits; 
        const size_t maxArrayPreallocation; 
        BitPosType bitIndex; 
    };
 
    explicit BitStreamReader(
            const uint8_t* buffer, size_t bufferByteSize, ArrayPreallocation maxArrayPrealloc = {});
 
    explicit BitStreamReader(Span<const uint8_t> buffer, ArrayPreallocation maxArrayPrealloc = {});
 
    explicit BitStreamReader(
            Span<const uint8_t> buffer, size_t bufferBitSize, ArrayPreallocation maxArrayPrealloc = {});
 
    explicit BitStreamReader(
            const uint8_t* buffer, size_t bufferBitSize, BitsTag, ArrayPreallocation maxArrayPrealloc = {});
 
    template <typename ALLOC>
    explicit BitStreamReader(const BasicBitBuffer<ALLOC>& bitBuffer, ArrayPreallocation maxArrayPrealloc = {}) :
            BitStreamReader(bitBuffer.getData(), bitBuffer.getBitSize(), maxArrayPrealloc)
    {}
 
    ~BitStreamReader() = default;
 
    uint32_t readUnsignedBits32(uint8_t numBits = 32);
 
    uint64_t readUnsignedBits64(uint8_t numBits = 64);
 
    int32_t readSignedBits32(uint8_t numBits = 32);
 
    int64_t readSignedBits64(uint8_t numBits = 64);
 
    Bool readBool();
 
    VarInt16 readVarInt16();
 
    VarInt32 readVarInt32();
 
    VarInt64 readVarInt64();
 
    VarInt readVarInt();
 
    VarUInt16 readVarUInt16();
 
    VarUInt32 readVarUInt32();
 
    VarUInt64 readVarUInt64();
 
    VarUInt readVarUInt();
 
    VarSize readVarSize();
 
    Float16 readFloat16();
 
    Float32 readFloat32();
 
    Float64 readFloat64();
 
    template <typename ALLOC = std::allocator<uint8_t>>
    BasicBytes<ALLOC> readBytes(const ALLOC& alloc = ALLOC())
    {
        const size_t len = static_cast<size_t>(readVarSize());
        const BitPosType beginBitPosition = getBitPosition();
        if (beginBitPosition + 8ULL * len > getBufferBitSize())
        {
            throw CppRuntimeException("BitStreamReader: Byte array size exceeds available buffer!");
        }
        if ((beginBitPosition & 0x07U) != 0)
        {
            // we are not aligned to byte
            Vector<uint8_t, ALLOC> value{alloc};
            value.reserve(len);
            for (size_t i = 0; i < len; ++i)
            {
                value.push_back(readByte());
            }
            return value;
        }
        else
        {
            // we are aligned to byte
            setBitPosition(beginBitPosition + len * 8);
            Span<const uint8_t>::iterator beginIt = m_context.buffer.begin() + beginBitPosition / 8;
            return BasicBytes<ALLOC>(beginIt, beginIt + len, alloc);
        }
    }
 
    template <typename ALLOC = std::allocator<char>>
    BasicString<ALLOC> readString(const ALLOC& alloc = ALLOC())
    {
        const size_t len = static_cast<size_t>(readVarSize());
        const BitPosType beginBitPosition = getBitPosition();
        if (beginBitPosition + 8ULL * len > getBufferBitSize())
        {
            throw CppRuntimeException("BitStreamReader: Byte array size exceeds available buffer!");
        }
        if ((beginBitPosition & 0x07U) != 0)
        {
            // we are not aligned to byte
            BasicString<ALLOC> value{alloc};
            value.reserve(len);
            for (size_t i = 0; i < len; ++i)
            {
                const char readCharacter = std::char_traits<char>::to_char_type(
                        static_cast<std::char_traits<char>::int_type>(readByte()));
                value.push_back(readCharacter);
            }
            return value;
        }
        else
        {
            // we are aligned to byte
            setBitPosition(beginBitPosition + len * 8);
            Span<const uint8_t>::iterator beginIt = m_context.buffer.begin() + beginBitPosition / 8;
            return BasicString<ALLOC>(beginIt, beginIt + len, alloc);
        }
    }
 
    template <typename ALLOC = std::allocator<uint8_t>>
    BasicBitBuffer<RebindAlloc<ALLOC, uint8_t>> readBitBuffer(const ALLOC& allocator = ALLOC())
    {
        const size_t bitSize = static_cast<size_t>(readVarSize());
        const BitPosType beginBitPosition = getBitPosition();
        if (beginBitPosition + static_cast<uint64_t>(bitSize) > getBufferBitSize())
        {
            throw CppRuntimeException("BitStreamReader: Byte array size exceeds available buffer!");
        }
        const size_t numBytesToRead = bitSize / 8;
        const uint8_t numRestBits = static_cast<uint8_t>(bitSize - numBytesToRead * 8);
        BasicBitBuffer<RebindAlloc<ALLOC, uint8_t>> bitBuffer(bitSize, allocator);
        Span<uint8_t> buffer = bitBuffer.getData();
        const Span<uint8_t>::iterator itEnd = buffer.begin() + numBytesToRead;
        if ((beginBitPosition & 0x07U) != 0)
        {
            // we are not aligned to byte
            for (Span<uint8_t>::iterator it = buffer.begin(); it != itEnd; ++it)
            {
                *it = static_cast<uint8_t>(readUnsignedBits32(8));
            }
        }
        else
        {
            // we are aligned to byte
            setBitPosition(beginBitPosition + numBytesToRead * 8);
            Span<const uint8_t>::const_iterator sourceIt = m_context.buffer.begin() + beginBitPosition / 8;
            (void)std::copy(sourceIt, sourceIt + numBytesToRead, buffer.begin());
        }
 
        if (numRestBits > 0)
        {
            *itEnd = static_cast<uint8_t>(readUnsignedBits32(numRestBits) << (8U - numRestBits));
        }
 
        return bitBuffer;
    }
 
    BitPosType getBitPosition() const
    {
        return m_context.bitIndex;
    }
 
    void setBitPosition(BitPosType position);
 
    void alignTo(size_t alignment);
 
    size_t getBufferBitSize() const
    {
        return m_context.bufferBitSize;
    }
 
    size_t getMaxArrayPreallocation() const
    {
        return m_context.maxArrayPreallocation;
    }
 
private:
    uint8_t readByte();
 
    ReaderContext m_context;
};
 
namespace detail
{
 
inline void read(BitStreamReader& reader, Bool& value)
{
    value = reader.readBool();
}
 
template <BitSize BIT_SIZE, bool IS_SIGNED>
void read(BitStreamReader& reader, FixedIntWrapper<BIT_SIZE, IS_SIGNED>& value)
{
    using ValueType = typename FixedIntWrapper<BIT_SIZE, IS_SIGNED>::ValueType;
    // TODO[Mi-L@]: implement on the reader to get rid of the numBits check
    if constexpr (sizeof(ValueType) <= 4)
    {
        if constexpr (std::is_signed_v<ValueType>)
        {
            value = static_cast<ValueType>(reader.readSignedBits32(BIT_SIZE));
        }
        else
        {
            value = static_cast<ValueType>(reader.readUnsignedBits32(BIT_SIZE));
        }
    }
    else
    {
        if constexpr (std::is_signed_v<ValueType>)
        {
            value = static_cast<ValueType>(reader.readSignedBits64(BIT_SIZE));
        }
        else
        {
            value = static_cast<ValueType>(reader.readUnsignedBits64(BIT_SIZE));
        }
    }
}
 
template <typename T>
void read(BitStreamReader& reader, DynIntWrapper<T>& value, uint8_t numBits)
{
    if constexpr (sizeof(T) <= 4)
    {
        if constexpr (std::is_signed_v<T>)
        {
            value = static_cast<T>(reader.readSignedBits32(numBits));
        }
        else
        {
            value = static_cast<T>(reader.readUnsignedBits32(numBits));
        }
    }
    else
    {
        if constexpr (std::is_signed_v<T>)
        {
            value = static_cast<T>(reader.readSignedBits64(numBits));
        }
        else
        {
            value = static_cast<T>(reader.readUnsignedBits64(numBits));
        }
    }
}
 
inline void read(BitStreamReader& reader, VarInt16& value)
{
    value = reader.readVarInt16();
}
 
inline void read(BitStreamReader& reader, VarInt32& value)
{
    value = reader.readVarInt32();
}
 
inline void read(BitStreamReader& reader, VarInt64& value)
{
    value = reader.readVarInt64();
}
 
inline void read(BitStreamReader& reader, VarInt& value)
{
    value = reader.readVarInt();
}
 
inline void read(BitStreamReader& reader, VarUInt16& value)
{
    value = reader.readVarUInt16();
}
 
inline void read(BitStreamReader& reader, VarUInt32& value)
{
    value = reader.readVarUInt32();
}
 
inline void read(BitStreamReader& reader, VarUInt64& value)
{
    value = reader.readVarUInt64();
}
 
inline void read(BitStreamReader& reader, VarUInt& value)
{
    value = reader.readVarUInt();
}
 
inline void read(BitStreamReader& reader, VarSize& value)
{
    value = reader.readVarSize();
}
 
inline void read(BitStreamReader& reader, Float16& value)
{
    value = reader.readFloat16();
}
 
inline void read(BitStreamReader& reader, Float32& value)
{
    value = reader.readFloat32();
}
 
inline void read(BitStreamReader& reader, Float64& value)
{
    value = reader.readFloat64();
}
 
template <typename ALLOC>
inline void read(BitStreamReader& reader, BasicBytes<ALLOC>& value)
{
    value = reader.readBytes(value.get_allocator());
}
 
template <typename ALLOC>
inline void read(BitStreamReader& reader, zserio::BasicString<ALLOC>& value)
{
    value = reader.readString(value.get_allocator());
}
 
template <typename ALLOC>
inline void read(BitStreamReader& reader, BasicBitBuffer<ALLOC>& value)
{
    value = reader.readBitBuffer(value.get_allocator());
}
 
} // namespace detail
 
} // namespace zserio
 
#endif // ifndef ZSERIO_BIT_STREAM_READER_H_INC