Add bit_stream_measurer

Author: copyrat90

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.25)
-project(nalchi VERSION 0.1.2)
+project(nalchi VERSION 0.1.3)
 
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 

include/nalchi/bit_stream.hpp

@@ -546,6 +546,159 @@ class bit_stream_writer final
     NALCHI_API void do_flush_word_unchecked();
 };
 
+/// @brief Measures the bytes `bit_stream_writer` will use.
+///
+/// This never actually writes any data. \n
+/// Instead, it only measures how many bytes `bit_stream_writer` would use. \n
+/// You can use this to measure the required space for the `bit_stream_writer`.
+class bit_stream_measurer final
+{
+public:
+    using size_type = bit_stream_writer::size_type; ///< Size type representing number of bits and bytes.
+
+private:
+    size_type _logical_used_bits = 0;
+
+public:
+    /// @brief Deleted copy constructor.
+    bit_stream_measurer(const bit_stream_measurer&) = delete;
+
+    /// @brief Deleted copy assignment operator.
+    auto operator=(const bit_stream_measurer&) -> bit_stream_measurer& = delete;
+
+    /// @brief Constructs a `bit_stream_measurer` instance.
+    NALCHI_API bit_stream_measurer() = default;
+
+public:
+    /// @brief Gets the number of used (measured) bytes.
+    /// @return Number of used (measured) bytes.
+    NALCHI_API auto used_bytes() const -> size_type;
+
+    /// @brief Gets the number of used (measured) bits.
+    /// @return Number of used (measured) bits.
+    NALCHI_API auto used_bits() const -> size_type
+    {
+        return _logical_used_bits;
+    }
+
+public:
+    /// @brief Restarts the measure from zero.
+    NALCHI_API void restart()
+    {
+        _logical_used_bits = 0;
+    }
+
+public:
+    /// @brief Fake-writes some arbitrary data to the bit stream.
+    /// @param data Pointer to the arbitrary data.
+    /// @param size Size in bytes of the data.
+    /// @return The stream itself.
+    NALCHI_API auto write([[maybe_unused]] const void* data, size_type size) -> bit_stream_measurer&
+    {
+        _logical_used_bits += 8 * size;
+        return *this;
+    }
+
+    /// @brief Fake-writes an integral value to the bit stream.
+    /// @tparam Int Integer type.
+    /// @param data Data to fake-write.
+    /// @param min Minimum value allowed for @p data.
+    /// @param max Maximum value allowed for @p data.
+    /// @return The stream itself.
+    template <std::integral Int>
+    auto write([[maybe_unused]] Int data, Int min = std::numeric_limits<Int>::min(),
+               Int max = std::numeric_limits<Int>::max()) -> bit_stream_measurer&
+    {
+        using UInt = make_unsigned_allow_bool_t<Int>;
+
+        // Convert `data` to `value`.
+        const int bits = std::bit_width(static_cast<UInt>(((UInt)max) - ((UInt)min)));
+
+        // Adjust used bits
+        _logical_used_bits += static_cast<size_type>(bits);
+
+        return *this;
+    }
+
+    /// @brief Fake-writes a float value to the bit stream.
+    /// @param data Data to fake-write.
+    /// @return The stream itself.
+    NALCHI_API auto write(float data) -> bit_stream_measurer&
+    {
+        _logical_used_bits += static_cast<size_type>(8 * sizeof(data));
+        return *this;
+    }
+
+    /// @brief Fake-writes a double value to the bit stream.
+    /// @param data Data to fake-write.
+    /// @return The stream itself.
+    NALCHI_API auto write(double data) -> bit_stream_measurer&
+    {
+        _logical_used_bits += static_cast<size_type>(8 * sizeof(data));
+        return *this;
+    }
+
+    /// @brief Fake-writes a string view to the bit stream.
+    /// @tparam CharT Underlying character type of `std::basic_string_view`.
+    /// @tparam CharTraits Char traits for `CharT`.
+    /// @param str String to fake-write.
+    /// @return The stream itself.
+    template <character CharT, typename CharTraits>
+    auto write(std::basic_string_view<CharT, CharTraits> str) -> bit_stream_measurer&
+    {
+        // Fake-write a prefix of length prefix.
+        _logical_used_bits += bit_stream_writer::STR_LEN_PREFIX_PREFIX_BITS;
+
+        // Get the length of the string.
+        const auto len = str.length();
+
+        // Fake-write a length prefix.
+        if (len <= std::numeric_limits<std::uint8_t>::max())
+        {
+            _logical_used_bits += (8 * sizeof(std::uint8_t));
+        }
+        else if (len <= std::numeric_limits<std::uint16_t>::max())
+        {
+            _logical_used_bits += (8 * sizeof(std::uint16_t));
+        }
+        else if (len <= std::numeric_limits<std::uint32_t>::max())
+        {
+            _logical_used_bits += (8 * sizeof(std::uint32_t));
+        }
+        else // len <= std::numeric_limits<std::uint64_t>::max()
+        {
+            _logical_used_bits += (8 * sizeof(std::uint64_t));
+        }
+
+        // Fake-write the string payload.
+        _logical_used_bits += static_cast<size_type>(8 * len * sizeof(CharT));
+
+        return *this;
+    }
+
+    /// @brief Fake-writes a string to the bit stream.
+    /// @tparam CharT Underlying character type of `std::basic_string`.
+    /// @tparam CharTraits Char traits for `CharT`.
+    /// @tparam Allocator Underlying allocator for `std::basic_string`.
+    /// @param str String to fake-write.
+    /// @return The stream itself.
+    template <character CharT, typename CharTraits, typename Allocator>
+    auto write(const std::basic_string<CharT, CharTraits, Allocator>& str) -> bit_stream_measurer&
+    {
+        return write(std::basic_string_view<CharT, CharTraits>(str));
+    }
+
+    /// @brief Fake-writes a null-terminated string to the bit stream.
+    /// @tparam CharT Character type of the null-terminated string.
+    /// @param str String to fake-write.
+    /// @return The stream itself.
+    template <character CharT>
+    auto write(const CharT* str) -> bit_stream_measurer&
+    {
+        return write(std::basic_string_view<CharT>(str));
+    }
+};
+
 /// @brief Helper stream to read bits from your buffer.
 ///
 /// Its design is based on the articles by Glenn Fiedler, see:

include/nalchi/bit_stream_flat.hpp

@@ -247,6 +247,113 @@ NALCHI_FLAT_API bool nalchi_bit_stream_writer_write_utf16_string(nalchi::bit_str
 /// @return `true` if writing has been successful, otherwise `false`.
 NALCHI_FLAT_API bool nalchi_bit_stream_writer_write_utf32_string(nalchi::bit_stream_writer* self, const char32_t* str);
 
+/// @brief Constructs a `bit_stream_measurer` instance.
+NALCHI_FLAT_API nalchi::bit_stream_measurer* nalchi_bit_stream_measurer_construct();
+
+/// @brief Destroys a `bit_stream_measurer` instance.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_destroy(nalchi::bit_stream_measurer* self);
+
+/// @brief Gets the number of used (measured) bytes.
+/// @return Number of used (measured) bytes.
+NALCHI_FLAT_API auto nalchi_bit_stream_measurer_used_bytes(const nalchi::bit_stream_measurer* self)
+    -> nalchi::bit_stream_measurer::size_type;
+
+/// @brief Gets the number of used (measured) bits.
+/// @return Number of used (measured) bits.
+NALCHI_FLAT_API auto nalchi_bit_stream_measurer_used_bits(const nalchi::bit_stream_measurer* self)
+    -> nalchi::bit_stream_measurer::size_type;
+
+/// @brief Restarts the measure from zero.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_restart(nalchi::bit_stream_measurer* self);
+
+/// @brief Fake-writes some arbitrary data to the bit stream.
+/// @param data Pointer to the arbitrary data.
+/// @param size Size in bytes of the data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_bytes(nalchi::bit_stream_measurer* self, const void* data,
+                                                      nalchi::bit_stream_measurer::size_type size);
+
+/// @brief Fake-writes an bool value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_bool(nalchi::bit_stream_measurer* self, bool data);
+
+/// @brief Fake-writes a `std::int8_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_s8(nalchi::bit_stream_measurer* self, std::int8_t data, std::int8_t min, std::int8_t max);
+
+/// @brief Fake-writes a `std::uint8_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_u8(nalchi::bit_stream_measurer* self, std::uint8_t data, std::uint8_t min, std::uint8_t max);
+
+/// @brief Fake-writes a `std::int16_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_s16(nalchi::bit_stream_measurer* self, std::int16_t data, std::int16_t min, std::int16_t max);
+
+/// @brief Fake-writes a `std::uint16_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_u16(nalchi::bit_stream_measurer* self, std::uint16_t data, std::uint16_t min, std::uint16_t max);
+
+/// @brief Fake-writes a `std::int32_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_s32(nalchi::bit_stream_measurer* self, std::int32_t data, std::int32_t min, std::int32_t max);
+
+/// @brief Fake-writes a `std::uint32_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_u32(nalchi::bit_stream_measurer* self, std::uint32_t data, std::uint32_t min, std::uint32_t max);
+
+/// @brief Fake-writes a `std::int64_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_s64(nalchi::bit_stream_measurer* self, std::int64_t data, std::int64_t min, std::int64_t max);
+
+/// @brief Fake-writes a `std::uint64_t` value to the bit stream.
+/// @param data Data to fake-write.
+/// @param min Minimum value allowed for @p data.
+/// @param max Maximum value allowed for @p data.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_u64(nalchi::bit_stream_measurer* self, std::uint64_t data, std::uint64_t min, std::uint64_t max);
+
+/// @brief Fake-writes a float value to the bit stream.
+/// @param data Data to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_float(nalchi::bit_stream_measurer* self, float data);
+
+/// @brief Fake-writes a double value to the bit stream.
+/// @param data Data to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_double(nalchi::bit_stream_measurer* self, double data);
+
+/// @brief Fake-writes a null-terminated ordinary string to the bit stream.
+/// @param str String to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_ordinary_string(nalchi::bit_stream_measurer* self, const char* str);
+
+/// @brief Fake-writes a null-terminated wide string to the bit stream.
+/// @param str String to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_wide_string(nalchi::bit_stream_measurer* self, const wchar_t* str);
+
+/// @brief Fake-writes a null-terminated UTF-8 string to the bit stream.
+/// @param str String to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_utf8_string(nalchi::bit_stream_measurer* self, const char8_t* str);
+
+/// @brief Fake-writes a null-terminated UTF-16 string to the bit stream.
+/// @param str String to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_utf16_string(nalchi::bit_stream_measurer* self, const char16_t* str);
+
+/// @brief Fake-writes a null-terminated UTF-32 string to the bit stream.
+/// @param str String to fake-write.
+NALCHI_FLAT_API void nalchi_bit_stream_measurer_write_utf32_string(nalchi::bit_stream_measurer* self, const char32_t* str);
+
 /// @brief Constructs a `bit_stream_reader` instance without a buffer.
 ///
 /// This constructor can be useful if you want to set the buffer afterwards. \n

src/bit_stream.cpp

@@ -42,7 +42,8 @@ NALCHI_API bit_stream_writer::bit_stream_writer(word_type* begin, word_type* end
     reset_with(begin, end, logical_bytes_length);
 }
 
-NALCHI_API bit_stream_writer::bit_stream_writer(word_type* begin, size_type words_length, size_type logical_bytes_length)
+NALCHI_API bit_stream_writer::bit_stream_writer(word_type* begin, size_type words_length,
+                                                size_type logical_bytes_length)
 {
     reset_with(begin, words_length, logical_bytes_length);
 }
@@ -179,6 +180,11 @@ NALCHI_API void bit_stream_writer::do_flush_word_unchecked()
     _scratch_index = std::max(0, _scratch_index - static_cast<int>(8 * sizeof(word_type)));
 }
 
+NALCHI_API auto bit_stream_measurer::used_bytes() const -> size_type
+{
+    return ceil_to_multiple_of<8>(used_bits()) / 8;
+}
+
 NALCHI_API bit_stream_reader::bit_stream_reader()
 {
     reset();
@@ -189,12 +195,14 @@ NALCHI_API bit_stream_reader::bit_stream_reader(std::span<const word_type> buffe
     reset_with(buffer, logical_bytes_length);
 }
 
-NALCHI_API bit_stream_reader::bit_stream_reader(const word_type* begin, const word_type* end, size_type logical_bytes_length)
+NALCHI_API bit_stream_reader::bit_stream_reader(const word_type* begin, const word_type* end,
+                                                size_type logical_bytes_length)
 {
     reset_with(begin, end, logical_bytes_length);
 }
 
-NALCHI_API bit_stream_reader::bit_stream_reader(const word_type* begin, size_type words_length, size_type logical_bytes_length)
+NALCHI_API bit_stream_reader::bit_stream_reader(const word_type* begin, size_type words_length,
+                                                size_type logical_bytes_length)
 {
     reset_with(begin, words_length, logical_bytes_length);
 }
@@ -233,12 +241,14 @@ NALCHI_API void bit_stream_reader::reset_with(std::span<const word_type> buffer,
     restart();
 }
 
-NALCHI_API void bit_stream_reader::reset_with(const word_type* begin, const word_type* end, size_type logical_bytes_length)
+NALCHI_API void bit_stream_reader::reset_with(const word_type* begin, const word_type* end,
+                                              size_type logical_bytes_length)
 {
     reset_with(std::span<const word_type>(begin, end), logical_bytes_length);
 }
 
-NALCHI_API void bit_stream_reader::reset_with(const word_type* begin, size_type words_length, size_type logical_bytes_length)
+NALCHI_API void bit_stream_reader::reset_with(const word_type* begin, size_type words_length,
+                                              size_type logical_bytes_length)
 {
     reset_with(std::span<const word_type>(begin, words_length), logical_bytes_length);
 }