From 6c30d003dfe391e186cc6e08bb00ec99532e5545 Mon Sep 17 00:00:00 2001
From: Stanislaw Halik <sthalik@misaki.pl>
Date: Mon, 15 Jan 2024 09:33:30 +0100
Subject: a

---
 serialize/packbits-read.cpp  | 112 ++++++++++++++++++++++++++++++++++++++++++
 serialize/packbits-read.hpp  |   8 +--
 serialize/packbits-write.cpp |  11 +++++
 serialize/packbits-write.hpp |  63 ++++++++++++++++++++----
 serialize/packbits.cpp       | 114 -------------------------------------------
 5 files changed, 180 insertions(+), 128 deletions(-)
 create mode 100644 serialize/packbits-read.cpp
 create mode 100644 serialize/packbits-write.cpp
 delete mode 100644 serialize/packbits.cpp

diff --git a/serialize/packbits-read.cpp b/serialize/packbits-read.cpp
new file mode 100644
index 00000000..f21a0de9
--- /dev/null
+++ b/serialize/packbits-read.cpp
@@ -0,0 +1,112 @@
+#include "packbits-read.hpp"
+#include "compat/assert.hpp"
+
+namespace floormat {
+
+using namespace floormat::detail_Pack_input;
+
+namespace {
+
+template<std::unsigned_integral T, size_t N> constexpr inline T lowbits = (T{1} << N)-T{1};
+
+static_assert(!input<uint32_t, 3>{65535}.check_zero());
+static_assert(input<uint32_t, 30>{65535}.advance<16>() == 0);
+
+static_assert(input<uint32_t, 30>::next<16>{ input<uint32_t, 30>{65535}.advance<16>() }.check_zero());
+static_assert(input<uint32_t, 30>::next<16>{}.Capacity == 14);
+
+constexpr bool test1()
+{
+    constexpr size_t bits[] = { 5, 2, 1 };
+    constexpr size_t vals[] = { 8, 3, 1, 0 };
+
+    constexpr auto S0 = input<uint8_t, vals[0]>{0b10111011};
+    constexpr auto S1 = input<uint8_t, vals[1]>{0b00000101};
+    constexpr auto S2 = input<uint8_t, vals[2]>{0b00000001};
+    constexpr auto S3 = input<uint8_t, vals[3]>{0b00000000};
+
+    using P0 = std::decay_t<decltype(S0)>;
+    using P1 = P0::next<bits[0]>;
+    using P2 = P1::next<bits[1]>;
+    using P3 = P2::next<bits[2]>;
+
+    static_assert(std::is_same_v<P0, input<uint8_t, vals[0]>>);
+    static_assert(std::is_same_v<P1, input<uint8_t, vals[1]>>);
+    static_assert(std::is_same_v<P2, input<uint8_t, vals[2]>>);
+    static_assert(std::is_same_v<P3, input<uint8_t, vals[3]>>);
+
+    static_assert(S0.advance<      0>() == S0.value);
+    static_assert(S0.advance<bits[0]>() == S1.value);
+    static_assert(S1.advance<bits[1]>() == S2.value);
+    static_assert(S2.advance<bits[2]>() == S3.value);
+
+    static_assert(S0.get<bits[0]>() == (S0.value & (1<<bits[0])-1));
+    static_assert(S1.get<bits[1]>() == (S1.value & (1<<bits[1])-1));
+    static_assert(S2.get<bits[2]>() == (S2.value & (1<<bits[2])-1));
+    static_assert(S3.check_zero());
+
+    return true;
+}
+static_assert(test1());
+
+constexpr bool test3()
+{
+    constexpr auto S0 = input<uint16_t, 16>{0b1110100110001011};
+    constexpr auto S1 = input<uint16_t,  4>{0b1110};
+    constexpr auto S2 = input<uint16_t,  1>{0b1};
+
+    static_assert(S0.get<12>() == 0b100110001011);
+    static_assert(S0.advance<12>() == S1.value);
+
+    static_assert(S1.get<3>() == 0b110);
+    static_assert(S1.advance<3>() == S2.value);
+
+    static_assert(S2.get<1>() == 0b1);
+    static_assert(S2.advance<1>() == 0);
+
+    return true;
+}
+static_assert(test3());
+
+static_assert(std::is_same_v< make_tuple_type<uint8_t, 3>,  std::tuple<uint8_t, uint8_t, uint8_t> >);
+
+constexpr bool test4()
+{
+    using Tuple_u32 = make_tuple_type<uint32_t, 3>;
+    static_assert(std::is_same_v<Tuple_u32, std::tuple<uint32_t, uint32_t, uint32_t>>);
+    using Tuple_u8  = make_tuple_type<uint8_t, 3>;
+    {
+        Tuple_u32 tuple{};
+        static_assert(lowbits<uint32_t, 17> == 0x1ffffU);
+        read_(tuple, input<uint32_t, 32>{(uint32_t)-1}, std::make_index_sequence<3>{}, make_pack<uint32_t, 17, 14, 1>{});
+        auto [a, b, c] = tuple;
+        fm_assert(a == lowbits<uint32_t, 17>);
+        fm_assert(b == lowbits<uint32_t, 14>);
+        fm_assert(c & 1);
+    }
+    {
+        Tuple_u8 tuple{};
+        read_(tuple, input<uint8_t, 8>{0b101011}, std::make_index_sequence<3>{}, make_pack<uint8_t, 1, 3, 2>{});
+        auto [a, b, c] = tuple;
+        fm_assert(a == 0b1);
+        fm_assert(b == 0b101);
+        fm_assert(c == 0b10);
+    }
+    {
+        std::tuple<> empty_tuple;
+        read_(empty_tuple, input<uint8_t, 8>{0}, std::index_sequence<>{}, make_pack<uint8_t>{});
+        Tuple_u8 tuple{}; (void)tuple;
+        //read_(empty_tuple, input<uint8_t, 8>{1}, std::index_sequence<>{}, make_tuple<uint8_t>{});
+        //read_(tuple, input<uint8_t, 5>{0b11111}, std::make_index_sequence<3>{}, make_tuple<uint8_t, 2, 2, 2>{});
+        //(void)input<uint8_t, 9>{};
+        //read_(empty_tuple, input<uint8_t, 8>{}, std::index_sequence<0>{}, make_tuple<uint8_t, 1>{});
+        //read_(empty_tuple, input<uint8_t, 8>{1}, std::index_sequence<>{}, make_tuple<uint8_t, 1>{});
+    }
+
+    return true;
+}
+static_assert(test4());
+
+} // namespace
+
+} // namespace floormat
diff --git a/serialize/packbits-read.hpp b/serialize/packbits-read.hpp
index 67b2efcb..ff132913 100644
--- a/serialize/packbits-read.hpp
+++ b/serialize/packbits-read.hpp
@@ -89,7 +89,7 @@ struct input<T, 0>
 };
 
 template<std::unsigned_integral T, typename Place, size_t Left, size_t I, size_t... Is, size_t Size, typename... Sizes>
-constexpr void read(Place& p, input<T, Left> st, std::index_sequence<I, Is...>, empty_pack_tuple<input_bits<T, Size>, Sizes...>)
+constexpr void read_(Place& p, input<T, Left> st, std::index_sequence<I, Is...>, empty_pack_tuple<input_bits<T, Size>, Sizes...>)
 {
     static_assert(sizeof...(Is) == sizeof...(Sizes));
     static_assert(Size <= Left, "data type too small");
@@ -98,18 +98,18 @@ constexpr void read(Place& p, input<T, Left> st, std::index_sequence<I, Is...>,
     using next_type = typename S::template next<Size>;
     get<I>(p) = st.template get<Size>();
     T next_value = st.template advance<Size>();
-    read(p, next_type{ next_value }, std::index_sequence<Is...>{}, empty_pack_tuple<Sizes...>{});
+    read_(p, next_type{ next_value }, std::index_sequence<Is...>{}, empty_pack_tuple<Sizes...>{});
 }
 
 template<std::unsigned_integral T, typename Place, size_t Left>
-constexpr void read(Place&, input<T, Left> st, std::index_sequence<>, empty_pack_tuple<>)
+constexpr void read_(Place&, input<T, Left> st, std::index_sequence<>, empty_pack_tuple<>)
 {
     fm_assert(st.check_zero());
 }
 
 template<std::unsigned_integral T, typename Place, size_t Left, size_t... Is, typename... Sizes>
 requires(sizeof...(Is) != sizeof...(Sizes))
-constexpr void read(Place&, input<T, Left>, std::index_sequence<Is...>, empty_pack_tuple<Sizes...>) = delete;
+constexpr void read_(Place&, input<T, Left>, std::index_sequence<Is...>, empty_pack_tuple<Sizes...>) = delete;
 
 template<std::unsigned_integral T, size_t... Ns> using make_pack = empty_pack_tuple<input_bits<T, Ns>...>;
 
diff --git a/serialize/packbits-write.cpp b/serialize/packbits-write.cpp
new file mode 100644
index 00000000..0b4fb4f1
--- /dev/null
+++ b/serialize/packbits-write.cpp
@@ -0,0 +1,11 @@
+#include "packbits-write.hpp"
+
+namespace floormat::detail_Pack_output {
+
+using u32 = uint32_t;
+using u8 = uint8_t;
+
+template u32 write_(output<u32, 32>, output_field<u32, 1>);
+static_assert(output<u32, 32>::next<1>::Capacity == 31);
+
+} // namespace floormat::detail_Pack_output
diff --git a/serialize/packbits-write.hpp b/serialize/packbits-write.hpp
index 34fc140f..faa3ff00 100644
--- a/serialize/packbits-write.hpp
+++ b/serialize/packbits-write.hpp
@@ -1,28 +1,71 @@
 #pragma once
+#include "compat/assert.hpp"
+#include <type_traits>
+#include <utility>
 #include <concepts>
 
 namespace floormat::detail_Pack_output {
 
-template<std::unsigned_integral T>
+template<size_t N>
+struct output_bits final
+{
+    static_assert(N > 0);
+    static_assert(N < sizeof(size_t)*8);
+
+    static constexpr size_t length = N;
+};
+
+template<std::unsigned_integral T, size_t CAPACITY>
 struct output
 {
-    T value = 0;
-    uint8_t capacity = sizeof(T)*8;
+    static_assert(std::is_fundamental_v<T>);
+    static_assert(CAPACITY <= sizeof(T)*8);
+    static constexpr size_t Capacity = CAPACITY;
+
+    T value{0};
 
-    constexpr inline output next(T x, uint8_t bits) const
+    template<size_t N>
+    constexpr T set(T x, output_bits<N>) const
     {
-        fm_assert(bits > 0 && bits <= capacity);
-        auto val = value;
-        val <<= bits;
-        T x_ = T(x & (T{1} << bits)- T{1});
+        static_assert(N <= CAPACITY, "data type too small");
+        static_assert(N > 0);
+        T value_{value};
+        if constexpr(CAPACITY != sizeof(T)*8)
+            value_ <<= CAPACITY;
+        auto x_ = T(x & (T{1}<<N)-T{1});
         fm_assert(x_ == x);
-        val |= x_;
-        return { val | x_, capacity - bits };
+        value_ |= x_;
+        return value_;
     }
+
+    template<size_t N>
+    struct next_
+    {
+        static_assert(N > 0);
+        static_assert(N <= CAPACITY);
+        using type = output<T, CAPACITY - N>;
+    };
+
+    template<size_t N> using next = typename next_<N>::type;
 };
 
+template<typename T, size_t N>
+using output_field = std::pair<T, output_bits<N>>;
 
+template<typename... Ts> struct empty_pack_tuple {}; // todo copypasta
 
+template<typename T, size_t Left, size_t F, typename... Fields>
+constexpr T write_(output<T, Left> st, output_field<T, F> field, Fields... fields)
+{
+    T value = st.set(field.first, field.second);
+    using next = typename output<T, Left>::template next<F>;
+    return write_(next{value}, fields...);
+}
 
+template<typename T, size_t Left>
+constexpr T write_(output<T, Left> st)
+{
+    return st.value;
+}
 
 } // namespace floormat::detail_Pack_output
diff --git a/serialize/packbits.cpp b/serialize/packbits.cpp
deleted file mode 100644
index e9ce54bc..00000000
--- a/serialize/packbits.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "packbits-read.hpp"
-#include "packbits-write.hpp"
-#include "compat/assert.hpp"
-
-namespace floormat {
-
-using namespace floormat::detail_Pack_input;
-
-namespace {
-
-template<std::unsigned_integral T, size_t N> constexpr inline T lowbits = (T{1} << N)-T{1};
-
-static_assert(!input<uint32_t, 3>{65535}.check_zero());
-static_assert(input<uint32_t, 30>{65535}.advance<16>() == 0);
-
-static_assert(input<uint32_t, 30>::next<16>{ input<uint32_t, 30>{65535}.advance<16>()
-}.check_zero());
-static_assert(input<uint32_t, 30>::next<16>{}.Capacity == 14);
-
-constexpr bool test1()
-{
-    constexpr size_t bits[] = { 5, 2, 1 };
-    constexpr size_t vals[] = { 8, 3, 1, 0 };
-
-    constexpr auto S0 = input<uint8_t, vals[0]>{0b10111011};
-    constexpr auto S1 = input<uint8_t, vals[1]>{0b00000101};
-    constexpr auto S2 = input<uint8_t, vals[2]>{0b00000001};
-    constexpr auto S3 = input<uint8_t, vals[3]>{0b00000000};
-
-    using P0 = std::decay_t<decltype(S0)>;
-    using P1 = P0::next<bits[0]>;
-    using P2 = P1::next<bits[1]>;
-    using P3 = P2::next<bits[2]>;
-
-    static_assert(std::is_same_v<P0, input<uint8_t, vals[0]>>);
-    static_assert(std::is_same_v<P1, input<uint8_t, vals[1]>>);
-    static_assert(std::is_same_v<P2, input<uint8_t, vals[2]>>);
-    static_assert(std::is_same_v<P3, input<uint8_t, vals[3]>>);
-
-    static_assert(S0.advance<      0>() == S0.value);
-    static_assert(S0.advance<bits[0]>() == S1.value);
-    static_assert(S1.advance<bits[1]>() == S2.value);
-    static_assert(S2.advance<bits[2]>() == S3.value);
-
-    static_assert(S0.get<bits[0]>() == (S0.value & (1<<bits[0])-1));
-    static_assert(S1.get<bits[1]>() == (S1.value & (1<<bits[1])-1));
-    static_assert(S2.get<bits[2]>() == (S2.value & (1<<bits[2])-1));
-    static_assert(S3.check_zero());
-
-    return true;
-}
-static_assert(test1());
-
-constexpr bool test3()
-{
-    constexpr auto S0 = input<uint16_t, 16>{0b1110100110001011};
-    constexpr auto S1 = input<uint16_t,  4>{0b1110};
-    constexpr auto S2 = input<uint16_t,  1>{0b1};
-
-    static_assert(S0.get<12>() == 0b100110001011);
-    static_assert(S0.advance<12>() == S1.value);
-
-    static_assert(S1.get<3>() == 0b110);
-    static_assert(S1.advance<3>() == S2.value);
-
-    static_assert(S2.get<1>() == 0b1);
-    static_assert(S2.advance<1>() == 0);
-
-    return true;
-}
-static_assert(test3());
-
-static_assert(std::is_same_v< make_tuple_type<uint8_t, 3>,  std::tuple<uint8_t, uint8_t, uint8_t> >);
-
-constexpr bool test4()
-{
-    using Tuple_u32 = make_tuple_type<uint32_t, 3>;
-    static_assert(std::is_same_v<Tuple_u32, std::tuple<uint32_t, uint32_t, uint32_t>>);
-    using Tuple_u8  = make_tuple_type<uint8_t, 3>;
-    {
-        Tuple_u32 tuple{};
-        static_assert(lowbits<uint32_t, 17> == 0x1ffffU);
-        read(tuple, input<uint32_t, 32>{(uint32_t)-1}, std::make_index_sequence<3>{}, make_pack<uint32_t, 17, 14, 1>{});
-        auto [a, b, c] = tuple;
-        fm_assert(a == lowbits<uint32_t, 17>);
-        fm_assert(b == lowbits<uint32_t, 14>);
-        fm_assert(c & 1);
-    }
-    {
-        Tuple_u8 tuple{};
-        read(tuple, input<uint8_t, 8>{0b101011}, std::make_index_sequence<3>{}, make_pack<uint8_t, 1, 3, 2>{});
-        auto [a, b, c] = tuple;
-        fm_assert(a == 0b1);
-        fm_assert(b == 0b101);
-        fm_assert(c == 0b10);
-    }
-    {
-        std::tuple<> empty_tuple;
-        read(empty_tuple, input<uint8_t, 8>{0}, std::index_sequence<>{}, make_pack<uint8_t>{});
-        Tuple_u8 tuple{}; (void)tuple;
-        //read(empty_tuple, input<uint8_t, 8>{1}, std::index_sequence<>{}, make_tuple<uint8_t>{});
-        //read(tuple, input<uint8_t, 5>{0b11111}, std::make_index_sequence<3>{}, make_tuple<uint8_t, 2, 2, 2>{});
-        //(void)input<uint8_t, 9>{};
-        //read(empty_tuple, input<uint8_t, 8>{}, std::index_sequence<0>{}, make_tuple<uint8_t, 1>{});
-        //read(empty_tuple, input<uint8_t, 8>{1}, std::index_sequence<>{}, make_tuple<uint8_t, 1>{});
-    }
-
-    return true;
-}
-static_assert(test4());
-
-} // namespace
-
-} // namespace floormat
-- 
cgit v1.2.3