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 <cstring>
#include <string>
 
#include "zserio/BitBuffer.h"
#include "zserio/RebindAlloc.h"
#include "zserio/Span.h"
#include "zserio/String.h"
#include "zserio/Types.h"
#include "zserio/Vector.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; 
        BitPosType bitIndex; 
        const size_t maxArrayPreallocation; 
    };
 
    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 readBits(uint8_t numBits = 32);
 
    uint64_t readBits64(uint8_t numBits = 64);
 
    int32_t readSignedBits(uint8_t numBits = 32);
 
    int64_t readSignedBits64(uint8_t numBits = 64);
 
    int64_t readVarInt64();
 
    int32_t readVarInt32();
 
    int16_t readVarInt16();
 
    uint64_t readVarUInt64();
 
    uint32_t readVarUInt32();
 
    uint16_t readVarUInt16();
 
    int64_t readVarInt();
 
    uint64_t readVarUInt();
 
    uint32_t readVarSize();
 
    float readFloat16();
 
    float readFloat32();
 
    double readFloat64();
 
    template <typename ALLOC = std::allocator<uint8_t>>
    vector<uint8_t, 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 vector<uint8_t, ALLOC>(beginIt, beginIt + len, alloc);
        }
    }
 
    template <typename ALLOC = std::allocator<char>>
    string<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: String size exceeds available buffer!");
        }
        if ((beginBitPosition & 0x07U) != 0)
        {
            // we are not aligned to byte
            string<ALLOC> value{alloc};
            value.reserve(len);
            for (size_t i = 0; i < len; ++i)
            {
                using char_traits = std::char_traits<char>;
                const char readCharacter =
                        char_traits::to_char_type(static_cast<char_traits::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 string<ALLOC>(beginIt, beginIt + len, alloc);
        }
    }
 
    bool readBool();
 
    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: Bit buffer 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>(readBits(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>(readBits(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 zserio
 
#endif // ifndef ZSERIO_BIT_STREAM_READER_H_INC