bit_measure.h

Go to the documentation of this file.

#pragma once
#include "../utility/assert.h"
#include "../utility/crc.h"
#include "../utility/endian.h"
#include "../utility/meta.h"
 
#include "byte_buffer.h"
#include "serialize_traits.h"
 
#include <cstdint>
#include <cstring>
#include <limits>
#include <memory>
#include <type_traits>
 
namespace bitstream
{
    class bit_measure
    {
    public:
        static constexpr bool writing = true;
        static constexpr bool reading = false;
 
        bit_measure() noexcept :
            m_NumBitsWritten(0),
            m_TotalBits((std::numeric_limits<uint32_t>::max)()) {}
 
        bit_measure(uint32_t num_bytes) noexcept :
            m_NumBitsWritten(0),
            m_TotalBits(num_bytes * 8) {}
 
        bit_measure(const bit_measure&) = delete;
 
        bit_measure(bit_measure&& other) noexcept :
            m_NumBitsWritten(other.m_NumBitsWritten),
            m_TotalBits(other.m_TotalBits)
        {
            other.m_NumBitsWritten = 0;
            other.m_TotalBits = 0;
        }
 
        bit_measure& operator=(const bit_measure&) = delete;
 
        bit_measure& operator=(bit_measure&& rhs) noexcept
        {
            m_NumBitsWritten = rhs.m_NumBitsWritten;
            m_TotalBits = rhs.m_TotalBits;
 
            rhs.m_NumBitsWritten = 0;
            rhs.m_TotalBits = 0;
 
            return *this;
        }
 
        [[nodiscard]] uint8_t* get_buffer() const noexcept { return nullptr; }
 
        [[nodiscard]] uint32_t get_num_bits_serialized() const noexcept { return m_NumBitsWritten; }
 
        [[nodiscard]] uint32_t get_num_bytes_serialized() const noexcept { return m_NumBitsWritten > 0U ? ((m_NumBitsWritten - 1U) / 8U + 1U) : 0U; }
 
        [[nodiscard]] bool can_serialize_bits(uint32_t num_bits) const noexcept { return m_NumBitsWritten + num_bits <= m_TotalBits; }
 
        [[nodiscard]] uint32_t get_remaining_bits() const noexcept { return m_TotalBits - m_NumBitsWritten; }
 
        [[nodiscard]] uint32_t get_total_bits() const noexcept { return m_TotalBits; }
 
        [[nodiscard]] bool prepend_checksum() noexcept
        {
            BS_ASSERT(m_NumBitsWritten == 0);
 
            BS_ASSERT(can_serialize_bits(32U));
 
            m_NumBitsWritten += 32U;
 
            return true;
        }
 
        uint32_t serialize_checksum(uint32_t protocol_version) noexcept
        {
            return m_NumBitsWritten;
        }
 
        [[nodiscard]] bool pad_to_size(uint32_t num_bytes) noexcept
        {
            BS_ASSERT(num_bytes * 8U <= m_TotalBits);
 
            BS_ASSERT(num_bytes * 8U >= m_NumBitsWritten);
 
            m_NumBitsWritten = num_bytes * 8U;
 
            return true;
        }
 
        [[nodiscard]] bool pad(uint32_t num_bytes) noexcept
        {
            return pad_to_size(get_num_bytes_serialized() + num_bytes);
        }
 
        [[nodiscard]] bool align() noexcept
        {
            uint32_t remainder = m_NumBitsWritten % 8U;
            if (remainder != 0U)
                m_NumBitsWritten += 8U - remainder;
            return true;
        }
 
        [[nodiscard]] bool serialize_bits(uint32_t value, uint32_t num_bits) noexcept
        {
            BS_ASSERT(num_bits > 0U && num_bits <= 32U);
 
            BS_ASSERT(can_serialize_bits(num_bits));
 
            m_NumBitsWritten += num_bits;
 
            return true;
        }
 
        [[nodiscard]] bool serialize_bytes(const uint8_t* bytes, uint32_t num_bits) noexcept
        {
            BS_ASSERT(num_bits > 0U);
 
            BS_ASSERT(can_serialize_bits(num_bits));
 
            m_NumBitsWritten += num_bits;
 
            return true;
        }
 
        template<typename Trait, typename... Args, typename = utility::has_serialize_t<Trait, bit_measure, Args...>>
        [[nodiscard]] bool serialize(Args&&... args) noexcept(utility::is_serialize_noexcept_v<Trait, bit_measure, Args...>)
        {
            return serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...);
        }
 
        template<typename... Args, typename Trait, typename = utility::has_deduce_serialize_t<Trait, bit_measure, Args...>>
        [[nodiscard]] bool serialize(Trait&& arg, Args&&... args) noexcept(utility::is_deduce_serialize_noexcept_v<Trait, bit_measure, Args...>)
        {
            return serialize_traits<utility::deduce_trait_t<Trait, bit_measure, Args...>>::serialize(*this, std::forward<Trait>(arg), std::forward<Args>(args)...);
        }
 
    private:
        uint32_t m_NumBitsWritten;
        uint32_t m_TotalBits;
    };
}