bit_stream_writer.hpp

#pragma once
 
#include "fly/types/bit_stream/detail/bit_stream.hpp"
#include "fly/types/bit_stream/detail/concepts.hpp"
#include "fly/types/bit_stream/types.hpp"
#include "fly/types/numeric/endian.hpp"
 
#include <bit>
#include <ostream>
 
namespace fly {
 
class BitStreamWriter : public detail::BitStream
{
public:
    explicit BitStreamWriter(std::ostream &stream) noexcept;
 
    void write_word(word_type word);
 
    void write_byte(byte_type byte);
 
    template <detail::BitStreamInteger DataType>
    void write_bits(DataType bits, byte_type size);
 
    bool finish();
 
private:
    void flush_header(byte_type remainder);
 
    void flush_buffer();
 
    template <detail::BitStreamInteger DataType>
    void flush(const DataType &buffer, byte_type bytes);
 
    std::ostream &m_stream;
};
 
//==================================================================================================
template <detail::BitStreamInteger DataType>
void BitStreamWriter::write_bits(DataType bits, byte_type size)
{
    // If there are more bits to write than are available in the byte buffer, break the bits into
    // two chunks.
    if (size > m_position)
    {
        const byte_type rshift = size - m_position;
 
        // Fill the remainder of the byte buffer with as many bits as are available, and flush it
        // onto the stream.
        m_buffer |= static_cast<buffer_type>(bits) >> rshift;
        flush_buffer();
 
        // Then update the input bits to retain only those bits that have not been written yet.
        bits &= bit_mask<DataType>(rshift);
        size = rshift;
    }
 
    const byte_type lshift = m_position - size;
 
    m_buffer |= static_cast<buffer_type>(bits) << lshift;
    m_position = lshift;
}
 
//==================================================================================================
template <detail::BitStreamInteger DataType>
void BitStreamWriter::flush(const DataType &buffer, byte_type bytes)
{
    if (m_stream)
    {
        const DataType data = endian_swap_if_non_native<std::endian::big>(buffer);
 
        m_stream_buffer->sputn(
            reinterpret_cast<const std::ios::char_type *>(&data),
            static_cast<std::streamsize>(bytes));
    }
}
 
} // namespace fly