Serde: slightly more robust scalar vs composite detection

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

Author: jeandet

include/cpp_utils/reflexion/reflection.hpp

@@ -325,7 +325,7 @@ consteval auto is_field()
     }
     else
     {
-        return false;
+        return std::is_fundamental_v<composite_t> || std::is_enum_v<composite_t>;
     }
 }
 
@@ -379,17 +379,20 @@ template <typename field_t>
 }
 
 template <typename record_t, typename T, typename... Ts>
-[[nodiscard]] constexpr inline bool fields_have_const_size(const record_t& s, T&& field, Ts&&... fields)
+[[nodiscard]] constexpr inline bool fields_have_const_size(
+    const record_t& s, T&& field, Ts&&... fields)
 {
-    return fields_have_const_size(s, std::forward<T>(field)) && fields_have_const_size(s, std::forward<Ts>(fields)...);
+    return fields_have_const_size(s, std::forward<T>(field))
+        && fields_have_const_size(s, std::forward<Ts>(fields)...);
 }
 
-SPLIT_FIELDS([[nodiscard]] constexpr bool, composite_have_const_size, fields_have_const_size, const);
+SPLIT_FIELDS(
+    [[nodiscard]] constexpr bool, composite_have_const_size, fields_have_const_size, const);
 
 template <typename composite_t>
 consteval std::size_t composite_have_const_size()
 {
-    if constexpr (std::is_fundamental_v<composite_t>)
+    if constexpr (std::is_fundamental_v<composite_t> || std::is_enum_v<composite_t>)
         return true;
     if constexpr (is_dyn_size_field_v<composite_t>)
         return false;
@@ -436,7 +439,8 @@ SPLIT_FIELDS([[nodiscard]] constexpr std::size_t, composite_size, fields_size, c
 template <typename composite_t>
 consteval std::size_t composite_size()
 {
-    static_assert(composite_have_const_size<composite_t>(), "Composite type must have a constant size");
+    static_assert(
+        composite_have_const_size<composite_t>(), "Composite type must have a constant size");
     return composite_size(composite_t {});
 }
 

include/cpp_utils/serde/deserialization.hpp

@@ -94,6 +94,14 @@ constexpr inline std::size_t load_field(const auto& parent_composite, auto& pars
     return load_value(parsing_context, offset, field, parent_composite);
 }
 
+constexpr inline std::size_t load_field(const auto& parent_composite, auto& parsing_context,
+    std::size_t offset, types::concepts::enum_type auto& field)
+{
+    using underlying_t = std::underlying_type_t<std::decay_t<decltype(field)>>;
+    underlying_t& underlying_field = reinterpret_cast<underlying_t&>(field);
+    return load_value(parsing_context, offset, underlying_field, parent_composite);
+}
+
 template <typename field_t>
 concept dyn_array_field = dynamic_array_field<field_t> && !dynamic_array_until_eof_field<field_t>;
 
@@ -121,8 +129,8 @@ constexpr inline std::size_t load_field(const auto& parent_composite, auto& pars
 }
 
 template <typename field_t>
-concept dy_arr_until_eof_of_const_size
-    = dynamic_array_until_eof_field<std::decay_t<field_t>> && const_size_field<typename std::decay_t<field_t>::value_type>;
+concept dy_arr_until_eof_of_const_size = dynamic_array_until_eof_field<std::decay_t<field_t>>
+    && const_size_field<typename std::decay_t<field_t>::value_type>;
 
 constexpr inline std::size_t load_field(const auto& parent_composite, auto& parsing_context,
     std::size_t offset, dy_arr_until_eof_of_const_size auto& array_field)
@@ -154,8 +162,8 @@ concept dy_arr_until_eof_of_dyn_size
     = dynamic_array_until_eof_field<field_t> && !const_size_field<typename field_t::value_type>;
 
 
-constexpr inline std::size_t load_field(const auto& parent_composite, auto& parsing_context,
-    std::size_t offset, dy_arr_until_eof_of_dyn_size auto& array_field)
+constexpr inline std::size_t load_field(const auto&, auto& parsing_context, std::size_t offset,
+    dy_arr_until_eof_of_dyn_size auto& array_field)
 {
     using array_field_t = std::decay_t<decltype(array_field)>;
     using field_t = typename array_field_t::value_type;

include/cpp_utils/types/concepts.hpp

@@ -45,6 +45,9 @@ concept pointer_to_contiguous_memory = requires(T t) {
 template <class T>
 concept fundamental_type = std::is_fundamental_v<std::decay_t<T>>;
 
+template <class T>
+concept enum_type = std::is_enum_v<std::decay_t<T>>;
+
 template <class T>
 concept container = requires(T t) {
     { t.size() } -> std::convertible_to<std::size_t>;