Serde WIP

Signed-off-by: Alexis Jeandet <[email protected]>

Author: jeandet

include/cpp_utils/endianness/endianness.hpp

@@ -87,10 +87,22 @@ namespace details
     using uint_t = typename uint<s>::type;
 
 
-    inline uint8_t bswap(uint8_t v) { return v; }
-    inline uint16_t bswap(uint16_t v) { return bswap16(v); }
-    inline uint32_t bswap(uint32_t v) { return bswap32(v); }
-    inline uint64_t bswap(uint64_t v) { return bswap64(v); }
+    inline uint8_t bswap(uint8_t v)
+    {
+        return v;
+    }
+    inline uint16_t bswap(uint16_t v)
+    {
+        return bswap16(v);
+    }
+    inline uint32_t bswap(uint32_t v)
+    {
+        return bswap32(v);
+    }
+    inline uint64_t bswap(uint64_t v)
+    {
+        return bswap64(v);
+    }
 
     template <typename T, std::size_t s = sizeof(T)>
     T byte_swap(T value)
@@ -117,6 +129,7 @@ enum class Endianness
 struct big_endian_t
 {
 };
+
 struct little_endian_t
 {
 };
@@ -132,16 +145,15 @@ inline constexpr bool is_big_endian_v = std::is_same_v<big_endian_t, endianness_
 inline Endianness host_endianness_v()
 {
     if constexpr (is_little_endian_v<host_endianness_t>)
-            return Endianness::little;
+        return Endianness::little;
     if constexpr (is_big_endian_v<host_endianness_t>)
-            return Endianness::big;
+        return Endianness::big;
     return Endianness::unknown;
 }
 
 
 template <typename src_endianess_t, typename T, typename U>
-[[nodiscard]] HEDLEY_NON_NULL(1)
-T decode(const U* input)
+[[nodiscard]] HEDLEY_NON_NULL(1) T decode(const U* input)
 {
     if constexpr (sizeof(T) > 1)
     {
@@ -173,14 +185,22 @@ inline void _impl_decode_v(const value_t* data, std::size_t size, value_t* outpu
             }
         }
     }
+    else
+    {
+        if (size > 0 && data != output)
+        {
+            std::memcpy(output, data, size * sizeof(value_t));
+        }
+    }
 }
 
 
 template <typename src_endianess_t, typename value_t>
 HEDLEY_NON_NULL(1)
 inline void decode_v(value_t* data, std::size_t size)
 {
-    _impl_decode_v<src_endianess_t>(reinterpret_cast<details::uint_t<sizeof(value_t)>*>(data), size, reinterpret_cast<details::uint_t<sizeof(value_t)>*>(data));
+    _impl_decode_v<src_endianess_t>(reinterpret_cast<details::uint_t<sizeof(value_t)>*>(data), size,
+        reinterpret_cast<details::uint_t<sizeof(value_t)>*>(data));
 }
 
 template <typename src_endianess_t, typename value_t>
@@ -189,7 +209,8 @@ inline void decode_v(const auto* data, std::size_t size, value_t* output)
 {
     using _value_t = details::uint_t<sizeof(value_t)>;
     auto count = size * sizeof(decltype(*data)) / sizeof(value_t);
-    _impl_decode_v<src_endianess_t>(reinterpret_cast<const _value_t*>(data), count , reinterpret_cast<_value_t*>(output));
+    _impl_decode_v<src_endianess_t>(
+        reinterpret_cast<const _value_t*>(data), count, reinterpret_cast<_value_t*>(output));
 }
 
 }

include/cpp_utils/io/memory_mapped_file.hpp

@@ -46,7 +46,7 @@
 namespace cpp_utils::io
 {
 
-struct mmap_adapter
+struct memory_mapped_file
 {
 #ifdef USE_MMAP
     int fd = -1;
@@ -59,7 +59,7 @@ struct mmap_adapter
     HANDLE hFile = NULL;
 #endif
 
-    mmap_adapter(const std::string& path)
+    memory_mapped_file(const std::string& path)
     {
 
         if (std::filesystem::exists(path))
@@ -92,7 +92,7 @@ struct mmap_adapter
             }
         }
     }
-    ~mmap_adapter()
+    ~memory_mapped_file()
     {
         if (mapped_file)
         {

include/cpp_utils/reflexion/reflection.hpp

@@ -36,70 +36,36 @@ namespace details
 {
 struct anything
 {
-    template <class T>
+    template <class T> requires (!std::is_bounded_array_v<std::decay_t<T>>)
     operator T() const;
 };
 
-
-template <class T, class Is, class = void>
-struct _can_construct_with_N : std::false_type
-{
-};
-
-template <class T, std::size_t... Is>
-struct _can_construct_with_N<T, std::index_sequence<Is...>,
-    std::void_t<decltype(T { (void(Is), anything {})... })>> : std::true_type
-{
-};
-
-template <class T, std::size_t N>
-using can_construct_with_N = _can_construct_with_N<T, std::make_index_sequence<N>>;
-
-
-template <std::size_t Min, std::size_t Range, template <std::size_t N> class target>
-struct maximize
-        : std::conditional_t<maximize<Min, Range / 2, target> {} == (Min + Range / 2) - 1,
-              maximize<Min + Range / 2, (Range + 1) / 2, target>, maximize<Min, Range / 2, target>>
-{
-};
-template <std::size_t Min, template <std::size_t N> class target>
-struct maximize<Min, 1, target>
-        : std::conditional_t<target<Min> {}, std::integral_constant<std::size_t, Min>,
-              std::integral_constant<std::size_t, Min - 1>>
-{
-};
-template <std::size_t Min, template <std::size_t N> class target>
-struct maximize<Min, 0, target> : std::integral_constant<std::size_t, Min - 1>
-{
-};
-
-template <class T>
-struct construct_searcher
-{
-    template <std::size_t N>
-    using result = can_construct_with_N<T, N>;
-};
-
-template <class T, std::size_t Cap = 32>
-using construct_airity = details::maximize<0, Cap, details::construct_searcher<T>::template result>;
+template<typename T, typename... A0>
+consteval auto MemberCounter(auto ...c0) {
+    if constexpr (requires { T{ {A0{}}..., {anything{}}, c0... }; } == false
+               && requires { T{ {A0{}}..., c0..., anything{}}; } == false )
+        return sizeof...(A0) + sizeof...(c0);
+    else
+    if constexpr (requires { T{ {A0{}}..., {anything{}}, c0... }; })
+        return MemberCounter<T,A0...,anything>(c0...);
+    else
+        return MemberCounter<T,A0...>(c0...,anything{});
+}
 
 }
 
-template <typename T>
-inline constexpr std::size_t count_members
-    = details::construct_airity<std::remove_cv_t<std::remove_reference_t<T>>>::value;
 
 #define SPLIT_FIELDS_FW_DECL(return_type, name, const_struct)                                      \
     template <typename T, typename... Args>                                                        \
-    constexpr return_type name(const_struct T& structure, Args&&... args);
+    return_type name(const_struct T& structure, Args&&... args);
 
 
 #define SPLIT_FIELDS(return_type, name, function, const_struct)                                    \
     /* this looks quite ugly bit it is worth it!*/                                                 \
     template <typename T, typename... Args>                                                        \
-    constexpr return_type name(const_struct T& structure, Args&&... args)                                    \
+    return_type name(const_struct T& structure, Args&&... args)                                    \
     {                                                                                              \
-        constexpr std::size_t count = count_members<T>;                                            \
+        constexpr std::size_t count = cpp_utils::reflexion::count_members<T>;                                            \
         static_assert(count <= 31);                                                                \
                                                                                                    \
         if constexpr (count == 1)                                                                  \
@@ -343,61 +309,42 @@ inline constexpr std::size_t count_members
 
 namespace cpp_utils::reflexion
 {
+template <typename T>
+inline constexpr std::size_t count_members = details::MemberCounter<T>();
 
-SPLIT_FIELDS_FW_DECL(std::size_t, load_record, );
-
+SPLIT_FIELDS_FW_DECL([[nodiscard]] constexpr std::size_t, composite_size, const);
+template <typename composite_t>
+consteval std::size_t composite_size();
 
 template <typename field_t>
-struct is_field : std::false_type
-{
-};
-
-template <typename field_t>
-inline constexpr bool is_field_v = is_field<field_t>::value;
-
-
-constexpr inline std::size_t _load_field(const auto& , auto& parsing_context, std::size_t offset, types::concepts::fundamental_type auto&& field)
-{
-        using value_t = std::decay_t<decltype(field)>;
-        load_value(parsing_context, offset, std::addressof(field), sizeof(value_t));
-        return offset + sizeof(value_t);
-}
-
-
-template <typename record_t, typename parsing_context_t, typename T>
-constexpr inline std::size_t _load_field(const record_t& r, parsing_context_t& parsing_context, std::size_t offset, T&& field)
+[[nodiscard]] consteval std::size_t field_size()
 {
-    return load_field(r, parsing_context, offset, field);
+    if constexpr (std::is_bounded_array_v<field_t>)
+        return sizeof(field_t)*std::extent_v<field_t>;
+    return sizeof(field_t);
 }
 
-template <typename record_t, typename parsing_context_t, typename T>
-constexpr inline std::size_t load_fields(const record_t& r, parsing_context_t& parsing_context,
-    [[maybe_unused]] std::size_t offset, T&& field)
+[[nodiscard]] constexpr inline std::size_t fields_size(const auto& , auto& field)
 {
-    using Field_t = std::remove_cv_t<std::remove_reference_t<T>>;
-    constexpr std::size_t count = count_members<Field_t>;
-    if constexpr (std::is_compound_v<Field_t> && (count > 1) && (not is_field_v<Field_t>))
-        return load_record(field, parsing_context, offset);
+    using Field_t = std::decay_t<decltype(field)>;
+    if constexpr (std::is_compound_v<Field_t> && ! std::is_bounded_array_v<Field_t>)
+        return composite_size<Field_t>();
     else
-        return _load_field(r, parsing_context, offset, std::forward<T>(field));
+        return field_size<Field_t>();
 }
 
-template <typename record_t, typename parsing_context_t, typename T, typename... Ts>
-constexpr inline std::size_t load_fields(const record_t& r, parsing_context_t& parsing_context,
-    [[maybe_unused]] std::size_t offset, T&& field, Ts&&... fields)
+template <typename record_t, typename T, typename... Ts>
+[[nodiscard]] constexpr inline std::size_t fields_size(const record_t& s, T&& field, Ts&&... fields)
 {
-    offset = load_fields(r, parsing_context, offset, std::forward<T>(field));
-    return load_fields(r, parsing_context, offset, std::forward<Ts>(fields)...);
+    return fields_size(s, std::forward<T>(field)) + fields_size(s, std::forward<Ts>(fields)...);
 }
 
-SPLIT_FIELDS(std::size_t, load_record, load_fields, );
+SPLIT_FIELDS([[nodiscard]] constexpr std::size_t, composite_size, fields_size, const);
 
-template <typename record_t>
-constexpr record_t load_record(auto&& parsing_context, [[maybe_unused]] std::size_t offset)
+template <typename composite_t>
+consteval std::size_t composite_size()
 {
-    record_t r;
-    load_record(r, std::forward<decltype(parsing_context)>(parsing_context), offset);
-    return r;
+    return composite_size(composite_t{});
 }
 
 } // namespace cpp_utils::reflexion