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 <cstddef>
#include <string_view>
#include <type_traits>
 
#include "zserio/BitBuffer.h"
#include "zserio/Bytes.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/SizeConvertUtil.h"
#include "zserio/String.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
class BitStreamWriter
{
public:
    class InsufficientCapacityException : public CppRuntimeException
    {
    public:
        using CppRuntimeException::CppRuntimeException;
 
        ~InsufficientCapacityException() override;
    };
 
    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 writeUnsignedBits32(uint32_t data, uint8_t numBits = 32);
 
    void writeUnsignedBits64(uint64_t data, uint8_t numBits = 64);
 
    void writeSignedBits32(int32_t data, uint8_t numBits = 32);
 
    void writeSignedBits64(int64_t data, uint8_t numBits = 64);
 
    void writeBool(Bool data);
 
    void writeVarInt16(VarInt16 data);
 
    void writeVarInt32(VarInt32 data);
 
    void writeVarInt64(VarInt64 data);
 
    void writeVarInt(VarInt data);
 
    void writeVarUInt16(VarUInt16 data);
 
    void writeVarUInt32(VarUInt32 data);
 
    void writeVarUInt64(VarUInt64 data);
 
    void writeVarUInt(VarUInt data);
 
    void writeVarSize(VarSize data);
 
    void writeFloat16(Float16 data);
 
    void writeFloat32(Float32 data);
 
    void writeFloat64(Float64 data);
 
    void writeBytes(BytesView data);
 
    void writeString(std::string_view data);
 
    template <typename ALLOC>
    void writeBitBuffer(const BasicBitBuffer<ALLOC>& bitBuffer)
    {
        const VarSize bitSize = fromCheckedValue<VarSize>(convertSizeToUInt32(bitBuffer.getBitSize()));
        writeVarSize(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)
            {
                writeUnsignedBits32Impl(*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)
        {
            writeUnsignedBits32Impl(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 writeUnsignedBits32Impl(uint32_t data, uint8_t numBits);
    void writeUnsignedBits64Impl(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 detail
{
 
inline void write(BitStreamWriter& writer, Bool value)
{
    writer.writeBool(value);
}
 
template <BitSize BIT_SIZE, bool IS_SIGNED>
void write(BitStreamWriter& writer, FixedIntWrapper<BIT_SIZE, IS_SIGNED> value)
{
    using ValueType = typename FixedIntWrapper<BIT_SIZE, IS_SIGNED>::ValueType;
 
    static_assert(BIT_SIZE != 0, "Variable dynamic bit fields not allowed here!");
    if constexpr (sizeof(ValueType) <= 4)
    {
        if constexpr (std::is_signed_v<ValueType>)
        {
            writer.writeSignedBits32(value, BIT_SIZE);
        }
        else
        {
            writer.writeUnsignedBits32(value, BIT_SIZE);
        }
    }
    else
    {
        if constexpr (std::is_signed_v<ValueType>)
        {
            writer.writeSignedBits64(value, BIT_SIZE);
        }
        else
        {
            writer.writeUnsignedBits64(value, BIT_SIZE);
        }
    }
}
 
template <typename T>
void write(BitStreamWriter& writer, DynIntWrapper<T> value, uint8_t numBits)
{
    if constexpr (sizeof(T) <= 4)
    {
        if constexpr (std::is_signed_v<T>)
        {
            writer.writeSignedBits32(value, numBits);
        }
        else
        {
            writer.writeUnsignedBits32(value, numBits);
        }
    }
    else
    {
        if constexpr (std::is_signed_v<T>)
        {
            writer.writeSignedBits64(value, numBits);
        }
        else
        {
            writer.writeUnsignedBits64(value, numBits);
        }
    }
}
 
inline void write(BitStreamWriter& writer, VarInt16 value)
{
    writer.writeVarInt16(value);
}
 
inline void write(BitStreamWriter& writer, VarInt32 value)
{
    writer.writeVarInt32(value);
}
 
inline void write(BitStreamWriter& writer, VarInt64 value)
{
    writer.writeVarInt64(value);
}
 
inline void write(BitStreamWriter& writer, VarInt value)
{
    writer.writeVarInt(value);
}
 
inline void write(BitStreamWriter& writer, VarUInt16 value)
{
    writer.writeVarUInt16(value);
}
 
inline void write(BitStreamWriter& writer, VarUInt32 value)
{
    writer.writeVarUInt32(value);
}
 
inline void write(BitStreamWriter& writer, VarUInt64 value)
{
    writer.writeVarUInt64(value);
}
 
inline void write(BitStreamWriter& writer, VarUInt value)
{
    writer.writeVarUInt(value);
}
 
inline void write(BitStreamWriter& writer, VarSize value)
{
    writer.writeVarSize(value);
}
 
inline void write(BitStreamWriter& writer, Float16 value)
{
    writer.writeFloat16(value);
}
 
inline void write(BitStreamWriter& writer, Float32 value)
{
    writer.writeFloat32(value);
}
 
inline void write(BitStreamWriter& writer, Float64 value)
{
    writer.writeFloat64(value);
}
 
inline void write(BitStreamWriter& writer, BytesView value)
{
    writer.writeBytes(value);
}
 
inline void write(BitStreamWriter& writer, std::string_view value)
{
    writer.writeString(value);
}
 
template <typename ALLOC>
inline void write(BitStreamWriter& writer, const BasicBitBufferView<ALLOC>& value)
{
    writer.writeBitBuffer(value.get());
}
 
} // namespace detail
 
} // namespace zserio
 
#endif // ifndef ZSERIO_BIT_STREAM_WRITER_H_INC