w

2 files changed, 12 insertions, 32 deletions

diff --git a/serialize/packbits-write.cpp b/serialize/packbits-write.cpp
index 85130c12..416ee718 100644
--- a/serialize/packbits-write.cpp
+++ b/serialize/packbits-write.cpp
@@ -16,8 +16,12 @@ static_assert(count_bits<u8, std::tuple<>> == 0);
 template u32 write_(const std::tuple<f32<1>>&, output<u32, 32>, output_bits<32>, std::index_sequence<0>);
 static_assert(write_(std::tuple<output_field<u32, 13>>{4242}, output<u32, 32>{0}, output_bits<32>{}, std::index_sequence<0>{}) == 4242);
 
-static_assert(output<u32, 32>::next<1>::Capacity == 31);
-static_assert(output<u32, 32>::next<1>::next<2>::Capacity == 29);
+static_assert(write_(
+    std::tuple{f8<3>{7}, f8<2>{3}, f8<1>{1}},
+    output<u8, 6>{0},
+    output_bits<8>{},
+    std::make_index_sequence<3>{}
+) == (1 << 6) - 1);
 
 #if 0
 static_assert(write_(output<u32, 32>{0},
diff --git a/serialize/packbits-write.hpp b/serialize/packbits-write.hpp
index a0ebe2ff..a98833ad 100644
--- a/serialize/packbits-write.hpp
+++ b/serialize/packbits-write.hpp
@@ -23,30 +23,6 @@ struct output
     static constexpr size_t Capacity = CAPACITY;
 
     T value{0};
-
-    template<size_t N>
-    struct next_
-    {
-        static_assert(N <= sizeof(T)*8);
-        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<size_t N>
-    constexpr T set(T x, output_bits<N>) const
-    {
-        static_assert(N <= CAPACITY, "data type too small");
-        static_assert(N > 0);
-        T value_{value};
-        if constexpr(CAPACITY != sizeof(T)*8)
-            value_ <<= N;
-        auto x_ = T(x & (T{1}<<N)-T{1});
-        fm_assert(x_ == x);
-        value_ |= x_;
-        return value_;
-    }
 };
 
 template<typename T, size_t LENGTH>
@@ -81,17 +57,17 @@ using make_reverse_index_sequence = decltype(reverse_index_sequence(std::make_in
 template<typename T, size_t Capacity, size_t Left, size_t I, size_t... Is, typename Tuple>
 constexpr T write_(const Tuple& tuple, output<T, Left> st, output_bits<Capacity>, std::index_sequence<I, Is...>)
 {
-    constexpr size_t N = std::tuple_element_t<I, Tuple>::Length;
     static_assert(Capacity <= sizeof(T)*8);
     static_assert(Left <= Capacity);
+    constexpr size_t N = std::tuple_element_t<I, Tuple>::Length;
+    static_assert(N <= Left);
     T x = std::get<I>(tuple).value;
-    T value = st.set(x, output_bits<N>{});
-    using next = typename output<T, Left>::template next<N>;
-    return write_(tuple, next{value}, std::index_sequence<Is...>{});
+    T value = T(T(st.value << N) | x);
+    return write_(tuple, output<T, Left - N>{value}, output_bits<Capacity>{}, std::index_sequence<Is...>{});
 }
 
-template<typename T, size_t Left, typename Tuple>
-constexpr T write_(const Tuple&, output<T, Left> st, std::index_sequence<>)
+template<typename T, size_t Capacity, size_t Left, typename Tuple>
+constexpr T write_(const Tuple&, output<T, Left> st, output_bits<Capacity>, std::index_sequence<>)
 {
     return st.value;
 }