1 files changed, 34 insertions, 26 deletions

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