a

1 files changed, 36 insertions, 27 deletions

diff --git a/serialize/packbits.cpp b/serialize/packbits.cpp
index 634191fc..ffca868f 100644
--- a/serialize/packbits.cpp
+++ b/serialize/packbits.cpp
@@ -7,10 +7,11 @@ using namespace floormat::detail_Pack;
 
 namespace {
 
+#if 0
 template<std::unsigned_integral T, size_t Sum, typename... Xs> struct check_size_overflow;
 
 template<std::unsigned_integral T, std::unsigned_integral U, size_t Sum, size_t N, typename... Xs>
-struct check_size_overflow<T, Sum, Bits_<U, N>, Xs...>
+struct check_size_overflow<T, Sum, Bits<U, N>, Xs...>
 {
     static_assert(std::is_same_v<T, U>);
     static constexpr auto acc = Sum + size_t{N};
@@ -25,10 +26,10 @@ struct check_size_overflow<T, Sum>
     static constexpr size_t size = Sum;
     static constexpr bool result = Sum <= sizeof(T)*8;
 };
+#endif
 
 template<std::unsigned_integral T, size_t N> constexpr inline T lowbits = (T{1} << N)-T{1};
-
-template<size_t Val> using us_bits = Bits_<uint16_t, Val>;
+template<size_t Val> using us_bits = Bits<uint16_t, Val>;
 
 static_assert(!Storage<uint32_t, 3>{65535}.check_zero());
 static_assert(Storage<uint32_t, 30>{65535}.advance<16>() == 0);
@@ -72,6 +73,7 @@ constexpr bool test1()
 }
 static_assert(test1());
 
+#if 0
 constexpr bool test2()
 {
     using foo1 = us_bits<2>;
@@ -107,6 +109,7 @@ constexpr bool test2()
     return true;
 }
 static_assert(test2());
+#endif
 
 constexpr bool test3()
 {
@@ -131,30 +134,36 @@ static_assert(std::is_same_v< make_tuple_type<uint8_t, 3>,  std::tuple<uint8_t,
 
 constexpr bool test4()
 {
-    using Tuple = std::tuple<uint32_t, uint32_t, uint32_t>;
-    Tuple tuple{};
-    assign_tuple2(tuple, Storage<uint32_t, 32>{(uint32_t)-1}, std::make_index_sequence<3>{},
-                  Bits_<uint32_t, 17>{}, Bits_<uint32_t, 14>{}, Bits_<uint32_t, 1>{});
-    auto [a, b, c] = tuple;
-
-    static_assert(lowbits<uint32_t, 17> != 0);
-    fm_assert(a == lowbits<uint32_t, 17>);
-    fm_assert(b == lowbits<uint32_t, 14>);
-    fm_assert(c & 1);
-
-    //Assign::do_tuple(tuple, Storage<uint32_t, 32>{(uint32_t)-1});
-
-    return true;
-}
-static_assert(test4());
-
-constexpr bool test5()
-{
-    auto st = Storage<uint32_t, 32>{0xB16B00B5};
-    uint32_t a, b, c;
-    using Tuple = std::tuple<uint32_t&, uint32_t&, uint32_t&>;
-    auto t = Tuple{a, b, c};
-    //assign_tuple<uint32_t, std::make_index_sequence<3>, Tuple,
+    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);
+        assign_tuple(tuple, Storage<uint32_t, 32>{(uint32_t)-1}, std::make_index_sequence<3>{}, Bits<uint32_t, 17>{}, Bits<uint32_t, 14>{}, Bits<uint32_t, 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{};
+        assign_tuple(tuple, Storage<uint8_t, 8>{0b101011}, std::make_index_sequence<3>{}, Bits<uint8_t, 1>{}, Bits<uint8_t, 3>{}, Bits<uint8_t, 2>{});
+        auto [a, b, c] = tuple;
+        fm_assert(a == 0b1);
+        fm_assert(b == 0b101);
+        fm_assert(c == 0b10);
+    }
+    {
+        std::tuple<> empty_tuple;
+        assign_tuple(empty_tuple, Storage<uint8_t, 8>{0}, std::index_sequence<>{});
+        Tuple_u8 tuple{}; (void)tuple;
+        // assign_tuple(empty_tuple, Storage<uint8_t, 8>{1}, std::index_sequence<>{});
+        // assign_tuple(tuple, Storage<uint8_t, 5>{0b11111}, std::make_index_sequence<3>{}, Bits<uint8_t, 2>{}, Bits<uint8_t, 2>{}, Bits<uint8_t, 2>{});
+        // (void)Storage<uint8_t, 9>{};
+        //assign_tuple(empty_tuple, Storage<uint8_t, 8>{}, std::index_sequence<0>{}, Bits<uint8_t, 1>{});
+        // assign_tuple(empty_tuple, Storage<uint8_t, 8>{1}, std::index_sequence<>{}, Bits<uint8_t, 1>{});
+    }
 
     return true;
 }