wa

2 files changed, 22 insertions, 13 deletions

diff --git a/serialize/packbits-write.cpp b/serialize/packbits-write.cpp
index b549994e..84126ea4 100644
--- a/serialize/packbits-write.cpp
+++ b/serialize/packbits-write.cpp
@@ -5,22 +5,24 @@ namespace floormat::detail_Pack_output {
 using u32 = uint32_t;
 using u8 = uint8_t;
 template<size_t N> using f32 = output_field<u32, N>;
-template<size_t N> using f8 = output_field<u8, N>,
+template<size_t N> using f8 = output_field<u8, N>;
 
 static_assert(count_bits<u32, std::tuple< f32<2>, f32<3>, f32<5>> >::length == 10);
 static_assert(count_bits<u8, std::tuple<>>::length == 0);
 //static_assert(count_bits<u8, std::tuple<f8<9>>>::length == 0);
 
-template u32 write_(output<u32, 32>, output_field<u32, 1>);
+template u32 write_(output<u32, 32>, std::index_sequence<0>, const std::tuple<f32<1>>&);
 
 static_assert(output<u32, 32>::next<1>::Capacity == 31);
 static_assert(output<u32, 32>::next<1>::next<2>::Capacity == 29);
 
 template<size_t N> using f32 = output_field<u32, N>;
 
+#if 0
 static_assert(write_(output<u32, 32>{0},
                      f32<2>{0b10},
                      f32<3>{0b011},
                      f32<3>{0b001}) == 0b000101110);
+#endif
 
 } // namespace floormat::detail_Pack_output
diff --git a/serialize/packbits-write.hpp b/serialize/packbits-write.hpp
index 060c444f..34a16ece 100644
--- a/serialize/packbits-write.hpp
+++ b/serialize/packbits-write.hpp
@@ -62,7 +62,7 @@ template<std::unsigned_integral Type, typename Tuple> struct count_bits;
 template<std::unsigned_integral Int, size_t N, typename... Ts> struct count_bits<Int, std::tuple<output_field<Int, N>, Ts...>>
 {
     static constexpr size_t length = N + count_bits<Int, std::tuple<Ts...>>::length;
-    static_assert(length <= sizeof(T)*8);
+    static_assert(length <= sizeof(Int)*8);
 };
 
 template<std::unsigned_integral Int> struct count_bits<Int, std::tuple<>>
@@ -70,21 +70,28 @@ template<std::unsigned_integral Int> struct count_bits<Int, std::tuple<>>
     static constexpr size_t length = 0;
 };
 
-#if 0
-template<typename T, size_t Left, typename Fields, size_t... Is>
-constexpr T write_(output<T, Left> st, std::tuple<Fields..., output_field<T, F>> fields)
+template <std::size_t ... Is>
+constexpr std::index_sequence<sizeof...(Is)-1uz-Is...> reverse_index_sequence(std::index_sequence<Is...> const&);
+
+template <std::size_t N>
+using make_reverse_index_sequence = decltype(reverse_index_sequence(std::make_index_sequence<N>{}));
+
+template<typename T, size_t Left, size_t I, size_t... Is, typename Tuple>
+constexpr T write_(output<T, Left> st, std::index_sequence<I, Is...>, const Tuple& tuple)
 {
-    T value0 = fields.get< std::tuple_size_v<std::tuple<Fields..., output_field<T, F>>>-1 >(fields).value;
-    T value = st.set(value0, output_bits<F>{});
-    using next = typename output<T, Left>::template next<F>;
-    return write_(next{value}, );
+    constexpr size_t N = std::tuple_element_t<I, Tuple>::Length;
+    if constexpr(Left != sizeof(T)*8)
+        st.value <<= N;
+    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_(next{value}, std::index_sequence<Is...>{}, tuple);
 }
 
-template<typename T, size_t Left>
-constexpr T write_(output<T, Left> st)
+template<typename T, size_t Left, typename Tuple>
+constexpr T write_(output<T, Left> st, std::index_sequence<>, const Tuple&)
 {
     return st.value;
 }
-#endif
 
 } // namespace floormat::detail_Pack_output