2 files changed, 53 insertions, 38 deletions
diff --git a/serialize/packbits-write.cpp b/serialize/packbits-write.cpp
index a5c80b49..045d6283 100644
--- a/serialize/packbits-write.cpp
+++ b/serialize/packbits-write.cpp
@@ -3,30 +3,37 @@
 namespace floormat::detail_Pack_output {
 
 using u32 = uint32_t;
+using u16 = uint16_t;
 using u8 = uint8_t;
 template<size_t N> using f32 = output_field<u32, N>;
+template<size_t N> using f16 = output_field<u16, N>;
 template<size_t N> using f8 = output_field<u8, N>;
 
-static_assert(count_bits<u32, std::tuple< f32<2>, f32<3>, f32<5> >> == 10);
-static_assert(count_bits<uint8_t, std::tuple< f8<1>, f8<2>, f8<4> >> == 7);
-static_assert(count_bits<u8, std::tuple<>> == 0);
-//static_assert(count_bits<u8, std::tuple< f8<9> >> == 0);
-//static_assert(count_bits<u8, std::tuple< f8<7>, f8<2> >> == 9);
-
-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(write_(std::tuple<output_field<u32, 13>>{4242}, output<u32, 32, 32>{0}, std::index_sequence<0>{}) == 4242u);
 
 static_assert(write_(
     std::tuple{f8<3>{7}, f8<2>{3}, f8<1>{1}},
-    output<u8, 6>{0},
-    output_bits<8>{},
+    output<u8, 8, 6>{0},
     std::make_index_sequence<3>{}
 ) == (1 << 6) - 1);
 
 static_assert(write_(
     std::tuple{f32<2>{0b10}, f32<3>{0b011}, f32<3>{0b001}},
-    output<u32, 32>{0},
-    output_bits<32>{},
+    output<u32, 32, 32>{0},
     make_reverse_index_sequence<3>{}) == 0b000101110);
 
+static_assert(write(std::tuple{f32<2>{0b10}, f32<3>{0b011}, f32<3>{0b01}}) == 0b00101110);
+//static_assert(write(std::tuple{f32<2>{0b10}, f32<3>{0b1011}, f32<3>{0b001}}) == 0b000101110);
+static_assert(write(std::tuple{f8<2>{0b10}, f8<3>{0b011}, f8<3>{0b01}}) == 0b00101110);
+//static_assert(write(std::tuple{f8<2>{0b10}, f8<3>{0b011}, f8<4>{0b01}}) == 0b00101110);
+//static_assert(write(std::tuple{}) == 0);
+
+#if 0 // check disasembly
+u32 foo1(u32 a, u32 b, u32 c);
+u32 foo1(u32 a, u32 b, u32 c)
+{
+    return write(std::tuple{f32<2>{a}, f32<3>{b}, f32<3>{c}});
+}
+#endif
+
 } // namespace floormat::detail_Pack_output
diff --git a/serialize/packbits-write.hpp b/serialize/packbits-write.hpp
index 1a91cbcf..09ec820e 100644
--- a/serialize/packbits-write.hpp
+++ b/serialize/packbits-write.hpp
@@ -1,61 +1,69 @@
 #pragma once
 #include "compat/assert.hpp"
 #include <type_traits>
-#include <tuple>
+#include <bit>
 #include <concepts>
+#include <tuple>
 
 namespace floormat::detail_Pack_output {
 
-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>
+template<std::unsigned_integral T, size_t CAPACITY, size_t LEFT>
 struct output
 {
     static_assert(std::is_fundamental_v<T>);
+    static_assert(CAPACITY > 0);
     static_assert(CAPACITY <= sizeof(T)*8);
-    static constexpr size_t Capacity = CAPACITY;
-
+    static_assert(LEFT <= CAPACITY);
+    static constexpr size_t Capacity = CAPACITY, Left = LEFT;
     T value{0};
 };
 
-template<typename T, size_t LENGTH>
+template<std::unsigned_integral T, size_t LENGTH>
 struct output_field
 {
-    T value;
+    static_assert(LENGTH > 0);
     static constexpr size_t Length = LENGTH;
+    T value;
 };
 
-template<std::unsigned_integral Type, typename Tuple> struct count_bits_;
-
-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>
+template <size_t... Is>
+constexpr std::index_sequence<sizeof...(Is)-1u-Is...> reverse_index_sequence(std::index_sequence<Is...>);
+template <size_t N>
 using make_reverse_index_sequence = decltype(reverse_index_sequence(std::make_index_sequence<N>{}));
 
-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...>)
+template<typename T> struct is_output_field : std::bool_constant<false> {};
+template<std::unsigned_integral T, size_t N> struct is_output_field<output_field<T, N>> : std::bool_constant<true> { static_assert(N > 0); };
+
+template<std::unsigned_integral T, size_t Capacity, size_t Left, size_t I, size_t... Is, typename Tuple>
+constexpr CORRADE_ALWAYS_INLINE T write_(const Tuple& tuple, output<T, Capacity, Left> st, std::index_sequence<I, Is...>)
 {
+    static_assert(Capacity > 0);
+    static_assert(Left > 0);
     static_assert(Capacity <= sizeof(T)*8);
     static_assert(Left <= Capacity);
+    static_assert(is_output_field<std::decay_t<decltype(std::get<I>(tuple))>>{});
     constexpr size_t N = std::tuple_element_t<I, Tuple>::Length;
     static_assert(N <= Left);
+
     T x = std::get<I>(tuple).value;
+    fm_assert((size_t)std::bit_width(x) <= N);
     T value = T(T(st.value << N) | x);
-    return write_(tuple, output<T, Left - N>{value}, output_bits<Capacity>{}, std::index_sequence<Is...>{});
+    return write_(tuple, output<T, Capacity, Left - N>{value}, std::index_sequence<Is...>{});
 }
 
-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<>)
+template<std::unsigned_integral T, size_t Capacity, size_t Left, typename Tuple>
+constexpr CORRADE_ALWAYS_INLINE T write_(const Tuple&, output<T, Capacity, Left> st, std::index_sequence<>)
 {
     return st.value;
 }
 
+template<std::unsigned_integral T, size_t... Sizes>
+constexpr T write(const std::tuple<output_field<T, Sizes>...>& tuple)
+{
+    constexpr size_t nbits = sizeof(T)*8;
+    return write_(tuple, output<T, nbits, nbits>{T{0}}, make_reverse_index_sequence<sizeof...(Sizes)>{});
+}
+
+constexpr uint8_t write(const std::tuple<>&) = delete;
+
 } // namespace floormat::detail_Pack_output