Merge branch 'master' of https://github.com/5e3/CompoundFs

Author: 5e3

Rfx/Blob.h

@@ -14,6 +14,9 @@
 namespace Rfx
 {
 
+///////////////////////////////////////////////////////////////////////////////
+/// Binary large object with a more agressively allocating grow() function and allocation
+/// that avoids the usual value initialization (see std::make_unique_for_overwrite())
 class Blob
 {
     std::unique_ptr<std::byte[]> m_storage;
@@ -39,8 +42,6 @@ class Blob
     const_reverse_iterator crbegin() const noexcept { return rbegin(); }
     const_reverse_iterator crend() const noexcept { return rend(); }
 
-
-
 public:
     Blob() = default;
     explicit Blob(size_t size);
@@ -67,6 +68,8 @@ class Blob
     void push_back(std::byte val) { *grow(1) = val; }
 };
 
+///////////////////////////////////////////////////////////////////////////////
+
 inline Blob::Blob(size_t size)
     : Blob()
 {
@@ -87,7 +90,6 @@ inline Blob::Blob(TString&& str)
     std::string_view sv(std::forward<TString>(str));
     for (auto ch: sv)
         push_back((std::byte) ch );
-
 }
 
 inline Blob::Blob(const Blob& other)

Rfx/CMakeLists.txt

@@ -25,6 +25,7 @@ set (Headers
 	StreamRule.h
 	PushBits.h
 	Rfx.natvis
+	TypeUtils.h
 	)
 
 if(WIN32)

Rfx/CompressedInteger.h

@@ -3,71 +3,83 @@
 #pragma once
 
 #include <concepts>
-#include <iterator>
+#include <cstddef>
 #include <bit>
 #include <limits>
+#include <stdexcept>
 
 namespace Rfx
 {
 
 template <typename T>
 struct StreamRule;
 
+///////////////////////////////////////////////////////////////////////////////
+
 constexpr int compressedSize(size_t value)
 {
     value |= 0x1; // fix the 0 case
     return (std::bit_width(value) + 6) / 7;
 }
 
+///////////////////////////////////////////////////////////////////////////////
 
 template <std::integral Integer>
 struct CompressedInteger;
 
-template <>
-struct CompressedInteger<size_t>
+///////////////////////////////////////////////////////////////////////////////
+
+ template <>
+ struct CompressedInteger<size_t>
 {
-    size_t m_value;
-    operator size_t() const { return m_value; }
-};
+     size_t m_value;
+     operator size_t() const { return m_value; }
+ };
 
-template<>
+ ///////////////////////////////////////////////////////////////////////////////
+
+ template <>
 struct StreamRule<CompressedInteger<size_t>>
 {
+    static constexpr std::byte MASK { 0b01111111 }; // Mask for extracting 7 bits    
+    static constexpr std::byte MORE { 0b10000000 }; // Indicator that more bytes are to follow
 
     template <typename TStream>
-    static void write(CompressedInteger<size_t> value, TStream& stream)
+    static void write(CompressedInteger<size_t> value, TStream&& stream)
     {
-        const std::byte mask { 0b01111111 };
-        const std::byte more = ~mask;
-        const int size = compressedSize(value.m_value);
-        for (int i = 0; i < size - 1; i++)
+        size_t temp = value.m_value;
+
+        // Write all the bytes except the last one
+        while (temp >= 0b10000000) // While more than 7 bits remain
         {
-            stream.write((std::byte(value.m_value) & mask ) | more);
-            value.m_value >>= 7;
+            stream.write(std::byte(temp) & MASK | MORE); // Write 7 bits with the continuation bit set
+            temp >>= 7;                                  // Shift to get the next 7 bits
         }
-
-        stream.write(std::byte(value.m_value) & mask);
+        
+        // Write the last byte without the continuation bit
+        stream.write(std::byte(temp) & MASK);
     }
 
     template <typename TStream>
-    static void read(CompressedInteger<size_t>& value, TStream& stream)
+    static void read(CompressedInteger<size_t>& value, TStream&& stream)
     {
-        const std::byte mask { 0b01111111 };
-        const std::byte more = ~mask;
+        size_t result = 0;
+        int shift = 0;
         std::byte b;
-        stream.read(b);
-        value.m_value = size_t(b & mask);
-        int count = 1;
-        while ((b & more) != std::byte{0})
+
+        // Read bytes while the continuation bit is set
+        do
         {
-            if (count == compressedSize(std::numeric_limits<size_t>::max()))
+            if (shift >= compressedSize(std::numeric_limits<size_t>::max()) * 7)
                 throw std::runtime_error("read CompressedInteger out of bounds");
+
             stream.read(b);
-            value.m_value |= size_t(b & mask) << (7 * count);
-            count++;
-        }
+            result |= (size_t(b & MASK) << shift);      // Extract 7 bits and shift them into position
+            shift += 7;                                 // Move to the next 7-bit group
+        } while (std::to_integer<uint8_t>(b & MORE));   // Continue if the continuation bit is set
+
+        value.m_value = result; // Set the result in the compressed integer
     }
 };
 
-
 }

Rfx/PushBits.h

@@ -12,6 +12,13 @@
 
 namespace Rfx
 {
+
+#ifdef _DEBUG
+constexpr bool debug_mode = true;
+#else
+constexpr bool debug_mode = false;
+#endif
+
 template<typename T>
 concept BitStreamable = (std::is_arithmetic_v<T> || std::is_enum_v<T>);
 
@@ -37,6 +44,9 @@ TIter copyBits(TRange first, TRange last, TIter pos)
     requires(BitStreamable<std::iter_value_t<TRange>> && std::same_as<std::iter_value_t<TIter>, std::byte>)
 {
     size_t size = last - first;
+    if (debug_mode && size == 0)
+        return pos;
+
     const std::byte* ptr = reinterpret_cast<const std::byte*>(&(*first));
     return std::copy(ptr, ptr + (sizeof(std::iter_value_t<TRange>) * size), pos);
 }
@@ -67,6 +77,9 @@ TIter copyBits(TIter pos, TRange first, TRange last)
     requires(BitStreamable<std::iter_value_t<TRange>> && std::same_as<std::iter_value_t<TIter>, std::byte>)
 {
     size_t size = last - first;
+    if (debug_mode && size == 0)
+        return pos;
+
     std::byte* ptr = reinterpret_cast<std::byte*>(&(*first));
     auto endPos = pos + (sizeof(std::iter_value_t<TRange>) * size);
     std::copy(pos, endPos, ptr);
@@ -91,16 +104,6 @@ void pushBits(const TRange& range, Blob& blob)
     copyBits(range.begin(), range.end(), it);
 }
 
-template <std::ranges::range TRange>
-void pushBits(const TRange& range, Blob& blob)
-    requires(BitStreamable<std::ranges::range_value_t<TRange>> && !std::ranges::sized_range<TRange>)
-{
-    for (auto it = range.begin(); it != range.end(); ++it)
-    {
-        auto pos = blob.grow(sizeof(std::ranges::range_value_t<TRange>));
-        copyBits(*it, pos);
-    }
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -124,8 +127,6 @@ T popBits(BlobRange& blobRange)
     return value;
 }
 
-
-
 /// for containers of BitStreamable (like std::list<double>)
 template <std::ranges::sized_range TRange>
 auto popBits(TRange& valueRange, BlobRange blobRange)
@@ -136,16 +137,6 @@ auto popBits(TRange& valueRange, BlobRange blobRange)
     return copyBits(blobRange.begin(), valueRange.begin(), valueRange.end());
 }
 
-/// for ranges of BitStreamables of unkown size (like std::ranges::subrange<std::list<double>::iterator>)
-template <std::ranges::range TRange>
-auto popBits(TRange& valueRange, BlobRange blobRange)
-    requires(BitStreamable<std::ranges::range_value_t<TRange>> && !std::ranges::sized_range<TRange>)
-{
-    Blob::const_iterator it = blobRange.begin();
-    for (auto& value: valueRange)
-        it = popBits(value, BlobRange(it, blobRange.end()));
-    return it;
-}
 
 
 

Rfx/Stream.h

@@ -12,7 +12,8 @@
 
 namespace Rfx
 {
-
+///////////////////////////////////////////////////////////////////////////////
+/// Stream into Blob with versioning.
 class StreamOut
 {
     Blob m_blob;
@@ -27,7 +28,7 @@ class StreamOut
     {
         if constexpr (BitStreamable<T>)
             pushBits(value, m_blob);
-        else if constexpr (isVersioned<T>)
+        else if constexpr (IsVersioned_v<T>)
         {
             size_t topIndex = m_fixups.size();
             auto fixup = m_fixups.nextFixup(m_blob.size());
@@ -78,8 +79,9 @@ class StreamOut
     }
 };
 
-
-class StreamIn 
+///////////////////////////////////////////////////////////////////////////////
+/// Stream from Blob with versioning.
+class StreamIn
 {
     Blob::const_iterator m_first;
     Blob::const_iterator m_last;
@@ -114,7 +116,7 @@ class StreamIn
         {
             m_first = popBits(value, asRange());
         }
-        else if constexpr (isVersioned<T>)
+        else if constexpr (IsVersioned_v<T>)
         {
             auto last = m_last;
             auto currentFixup = m_currentFixup;
@@ -150,9 +152,11 @@ class StreamIn
     template<typename T>
     void operator()(T& value)
     {
-        if (m_first < m_last)
+        if (!empty())
             read(value);
     }
+
+    bool empty() const { return m_first == m_last; }
 };
 
 }