diff options
| -rw-r--r-- | serialize/packbits-write.cpp | 31 | ||||
| -rw-r--r-- | serialize/packbits-write.hpp | 60 |
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 |