BitStreamWriter.h

Go to the documentation of this file.

#ifndef ZSERIO_BIT_STREAM_WRITER_H_INC
#define ZSERIO_BIT_STREAM_WRITER_H_INC
 
#include <algorithm>
#include <cstring>
 
#include "zserio/BitBuffer.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/SizeConvertUtil.h"
#include "zserio/Span.h"
#include "zserio/StringView.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
class BitStreamWriter
{
public:
    class InsufficientCapacityException : public CppRuntimeException
    {
    public:
        using CppRuntimeException::CppRuntimeException;
    };
 
    using BitPosType = size_t;
 
    explicit BitStreamWriter(uint8_t* buffer, size_t bufferBitSize, BitsTag);
 
    explicit BitStreamWriter(uint8_t* buffer, size_t bufferByteSize);
 
    explicit BitStreamWriter(Span<uint8_t> buffer);
 
    explicit BitStreamWriter(Span<uint8_t> buffer, size_t bufferBitSize);
 
    template <typename ALLOC>
    explicit BitStreamWriter(BasicBitBuffer<ALLOC>& bitBuffer) :
            BitStreamWriter(bitBuffer.getData(), bitBuffer.getBitSize())
    {}
 
    ~BitStreamWriter() = default;
 
    BitStreamWriter(const BitStreamWriter&) = delete;
    BitStreamWriter& operator=(const BitStreamWriter&) = delete;
 
    BitStreamWriter(const BitStreamWriter&&) = delete;
    BitStreamWriter& operator=(BitStreamWriter&&) = delete;
    void writeBits(uint32_t data, uint8_t numBits = 32);
 
    void writeBits64(uint64_t data, uint8_t numBits = 64);
 
    void writeSignedBits(int32_t data, uint8_t numBits = 32);
 
    void writeSignedBits64(int64_t data, uint8_t numBits = 64);
 
    void writeVarInt64(int64_t data);
 
    void writeVarInt32(int32_t data);
 
    void writeVarInt16(int16_t data);
 
    void writeVarUInt64(uint64_t data);
 
    void writeVarUInt32(uint32_t data);
 
    void writeVarUInt16(uint16_t data);
 
    void writeVarInt(int64_t data);
 
    void writeVarUInt(uint64_t data);
 
    void writeVarSize(uint32_t data);
 
    void writeFloat16(float data);
 
    void writeFloat32(float data);
 
    void writeFloat64(double data);
 
    void writeBytes(Span<const uint8_t> data);
 
    void writeString(StringView data);
 
    void writeBool(bool data);
 
    template <typename ALLOC>
    void writeBitBuffer(const BasicBitBuffer<ALLOC>& bitBuffer)
    {
        const size_t bitSize = bitBuffer.getBitSize();
        writeVarSize(convertSizeToUInt32(bitSize));
 
        Span<const uint8_t> buffer = bitBuffer.getData();
        size_t numBytesToWrite = bitSize / 8;
        const uint8_t numRestBits = static_cast<uint8_t>(bitSize - numBytesToWrite * 8);
        const BitPosType beginBitPosition = getBitPosition();
        const Span<const uint8_t>::iterator itEnd = buffer.begin() + numBytesToWrite;
        if ((beginBitPosition & 0x07U) != 0)
        {
            // we are not aligned to byte
            for (Span<const uint8_t>::iterator it = buffer.begin(); it != itEnd; ++it)
            {
                writeUnsignedBits(*it, 8);
            }
        }
        else
        {
            // we are aligned to byte
            setBitPosition(beginBitPosition + numBytesToWrite * 8);
            if (hasWriteBuffer())
            {
                (void)std::copy(buffer.begin(), buffer.begin() + numBytesToWrite,
                        m_buffer.data() + beginBitPosition / 8);
            }
        }
 
        if (numRestBits > 0)
        {
            writeUnsignedBits(static_cast<uint32_t>(*itEnd) >> (8U - numRestBits), numRestBits);
        }
    }
 
    BitPosType getBitPosition() const
    {
        return m_bitIndex;
    }
 
    void setBitPosition(BitPosType position);
 
    void alignTo(size_t alignment);
 
    bool hasWriteBuffer() const
    {
        return m_buffer.data() != nullptr;
    }
 
    const uint8_t* getWriteBuffer() const;
 
    Span<const uint8_t> getBuffer() const;
 
    size_t getBufferBitSize() const
    {
        return m_bufferBitSize;
    }
 
private:
    void writeUnsignedBits(uint32_t data, uint8_t numBits);
    void writeUnsignedBits64(uint64_t data, uint8_t numBits);
    void writeSignedVarNum(int64_t value, size_t maxVarBytes, size_t numVarBytes);
    void writeUnsignedVarNum(uint64_t value, size_t maxVarBytes, size_t numVarBytes);
    void writeVarNum(uint64_t value, bool hasSign, bool isNegative, size_t maxVarBytes, size_t numVarBytes);
 
    void checkCapacity(size_t bitSize) const;
    void throwInsufficientCapacityException() const;
 
    Span<uint8_t> m_buffer;
    size_t m_bitIndex;
    size_t m_bufferBitSize;
};
 
} // namespace zserio
 
#endif // ifndef ZSERIO_BIT_STREAM_WRITER_H_INC