1 files changed, 11 insertions, 59 deletions

diff --git a/serialize/packbits.hpp b/serialize/packbits.hpp
index c94f96d7..8a828f94 100644
--- a/serialize/packbits.hpp
+++ b/serialize/packbits.hpp
@@ -5,14 +5,13 @@
 #include "compat/assert.hpp"
 
 namespace floormat::Pack {
-template<std::unsigned_integral T, size_t N> struct Bits_;
+template<std::unsigned_integral T, size_t N> struct Bits;
 } // namespace floormat::Pack
 
 namespace floormat::detail_Pack {
 
 using namespace floormat::Pack;
 
-
 template<std::unsigned_integral T, size_t CAPACITY>
 struct Storage
 {
@@ -79,80 +78,33 @@ struct make_tuple_type_
 template<std::unsigned_integral T, size_t N> using make_tuple_type = typename make_tuple_type_<T, N>::Seq;
 
 template<typename T, typename Place, size_t Left, size_t I, size_t... Is, size_t Size, typename... Sizes>
-constexpr void assign_tuple2(Place& p, Storage<T, Left> st, std::index_sequence<I, Is...>, Bits_<T, Size>, Sizes... sizes)
+constexpr void assign_tuple(Place& p, Storage<T, Left> st, std::index_sequence<I, Is...>, Bits<T, Size>, Sizes... sizes)
 {
+    static_assert(Size <= Left, "too many bits requested");
+    static_assert(I < std::tuple_size_v<Place>, "too few tuple members");
     using S = Storage<T, Left>;
     using next_type = typename S::template next<Size>;
     get<I>(p) = st.template get<Size>();
     T next_value = st.template advance<Size>();
-    assign_tuple2(p, next_type{next_value}, std::index_sequence<Is...>{}, sizes...);
+    assign_tuple(p, next_type{next_value}, std::index_sequence<Is...>{}, sizes...);
 }
 
 template<typename T, typename Place, size_t Left>
-constexpr void assign_tuple2(Place&, Storage<T, Left>, std::index_sequence<>)
+constexpr void assign_tuple(Place&, Storage<T, Left> st, std::index_sequence<>)
 {
+    fm_assert(st.check_zero());
 }
 
-#if 0
-template<typename T, typename Indexes, typename... Sizes> struct assign_tuple;
-
-template<typename T, size_t Index, size_t... Indexes, size_t Size, typename... Sizes>
-struct assign_tuple<T, std::index_sequence<Index, Indexes...>, Bits_<T, Size>, Sizes...>
-{
-    static_assert(Size <= sizeof(T)*8, "bit count can't be larger than sizeof(T)*8");
-    static_assert(Size > 0, "bit count can't be zero");
-
-    template<typename Place, size_t Left>
-    static constexpr inline void do_tuple(Place& p, Storage<T, Left> st)
-    {
-        static_assert(requires (Place& p) { std::get<0>(p) = T{0}; });
-        static_assert(std::tuple_size_v<Place> >= sizeof...(Indexes) + 1);
-        static_assert(Size <= Left, "not enough bits for element");
-
-        get<Index>(p) = st.template get<Size>(st.value);
-        using Next = typename Storage<T, Left>::template next<Size>;
-        assign_tuple<T, std::index_sequence<Indexes...>, Sizes...>::
-            template do_tuple<Place, Next>(p, Next{st.template advance<Size>()});
-    }
-
-    static constexpr bool is_empty = false;
-};
-
-template<typename T, size_t Index, size_t... Indexes>
-struct assign_tuple<T, std::index_sequence<Index, Indexes...>>
-{
-    static_assert(sizeof(T) == (size_t)-1, "too few lhs elements");
-    static_assert(sizeof(T) != (size_t)-1);
-};
-
-template<typename T, size_t Size, typename... Sizes>
-struct assign_tuple<T, std::index_sequence<>, Bits_<T, Size>, Sizes...>
-{
-    static_assert(sizeof(T) == (size_t)-1, "too few rhs elements");
-    static_assert(sizeof(T) != (size_t)-1);
-};
-
-template<typename T>
-struct assign_tuple<T, std::index_sequence<>>
-{
-    template<typename Place, size_t Left>
-    static constexpr inline void do_tuple(Place&, Storage<T, Left> st)
-    {
-        fm_assert(st.check_zero());
-    }
-
-    static constexpr bool is_empty = true;
-    using type = T;
-};
-
-#endif
+template<typename T, typename Place, size_t Left, size_t... Is, typename... Sizes>
+requires(sizeof...(Is) != sizeof...(Sizes))
+constexpr void assign_tuple(Place&, Storage<T, Left>, std::index_sequence<Is...>, Sizes...) = delete;
 
 } // namespace floormat::detail_Pack
 
 namespace floormat::Pack {
 
 template<std::unsigned_integral T, size_t N>
-struct Bits_ final
+struct Bits final
 {
     static_assert(std::is_fundamental_v<T>);
     static_assert(N > 0);