Serde WIP

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

Author: jeandet

include/cpp_utils/endianness/endianness.hpp

@@ -117,6 +117,7 @@ enum class Endianness
 struct big_endian_t
 {
 };
+
 struct little_endian_t
 {
 };

include/cpp_utils/reflexion/reflection.hpp

@@ -40,54 +40,20 @@ struct anything
     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>                                                        \
@@ -99,7 +65,7 @@ inline constexpr std::size_t count_members
     template <typename T, typename... Args>                                                        \
     constexpr 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,7 @@ inline constexpr std::size_t count_members
 
 namespace cpp_utils::reflexion
 {
-
-SPLIT_FIELDS_FW_DECL(std::size_t, load_record, );
-
-
-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)
-{
-    return load_field(r, parsing_context, offset, field);
-}
-
-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)
-{
-    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);
-    else
-        return _load_field(r, parsing_context, offset, std::forward<T>(field));
-}
-
-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)
-{
-    offset = load_fields(r, parsing_context, offset, std::forward<T>(field));
-    return load_fields(r, parsing_context, offset, std::forward<Ts>(fields)...);
-}
-
-SPLIT_FIELDS(std::size_t, load_record, load_fields, );
-
-template <typename record_t>
-constexpr record_t load_record(auto&& parsing_context, [[maybe_unused]] std::size_t offset)
-{
-    record_t r;
-    load_record(r, std::forward<decltype(parsing_context)>(parsing_context), offset);
-    return r;
-}
+template <typename T>
+inline constexpr std::size_t count_members = details::MemberCounter<T>();
 
 } // namespace cpp_utils::reflexion

include/cpp_utils/serde/deserialization.hpp

@@ -0,0 +1,110 @@
+/*------------------------------------------------------------------------------
+-- The MIT License (MIT)
+--
+-- Copyright © 2024, Laboratory of Plasma Physics- CNRS
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and associated documentation files (the “Software”), to deal
+-- in the Software without restriction, including without limitation the rights
+-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+-- INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+-- PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+-- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-------------------------------------------------------------------------------*/
+/*-- Author : Alexis Jeandet
+-- Mail : [email protected]
+----------------------------------------------------------------------------*/
+#pragma once
+#include "../endianness/endianness.hpp"
+#include "../reflexion/reflection.hpp"
+#include "special_fields.hpp"
+
+namespace cpp_utils::serde
+{
+
+SPLIT_FIELDS_FW_DECL(std::size_t, deserialize, );
+
+template <typename input_t, typename field_t, typename parent_composite_t>
+std::size_t load_field(const input_t& input, std::size_t offset, field_t& field,
+    const parent_composite_t& parent_composite);
+
+
+namespace details
+{
+
+    std::size_t _load_value_from_memory(const char* const input_address, std::size_t offset,
+        types::concepts::fundamental_type auto& dest, const auto& parent_composite)
+    {
+        using T = std::decay_t<decltype(dest)>;
+        using parent_composite_t = std::decay_t<decltype(parent_composite)>;
+        dest = endianness::decode<endianness_t<parent_composite_t>,T>(input_address + offset);
+        return offset + sizeof(T);
+    }
+}
+
+std::size_t load_value(const char* input, std::size_t offset,
+    types::concepts::fundamental_type auto& dest, const auto& parent_composite)
+{
+    return details::_load_value_from_memory(input, offset, dest, parent_composite);
+}
+
+std::size_t load_value(const types::concepts::contiguous_sequence_container auto& input,
+    std::size_t offset, types::concepts::fundamental_type auto& dest, const auto& parent_composite)
+{
+    return details::_load_value_from_memory(reinterpret_cast<const char*>(std::data(input)), offset, dest, parent_composite);
+}
+
+constexpr inline std::size_t load_field(const auto& parent_composite, auto& parsing_context,
+    std::size_t offset, types::concepts::fundamental_type auto&& field)
+{
+    return load_value(
+        parsing_context, offset, std::forward<decltype(field)>(field), parent_composite);
+}
+
+constexpr inline std::size_t load_field(const auto&, auto& parsing_context, std::size_t offset,
+    types::concepts::contiguous_sequence_container auto&& container_field)
+{
+    // return load_value(parsing_context, offset, std::forward<decltype(field)>(field));
+    return offset;
+}
+
+template <typename composite_t, typename parsing_context_t, typename T>
+constexpr inline std::size_t load_fields(const composite_t& r, parsing_context_t& parsing_context,
+    [[maybe_unused]] std::size_t offset, T&& field)
+{
+    using Field_t = std::remove_cv_t<std::remove_reference_t<T>>;
+    constexpr std::size_t count = reflexion::count_members<Field_t>;
+    if constexpr (std::is_compound_v<Field_t> && (count > 1) && (not is_field_v<Field_t>))
+        return deserialize(field, parsing_context, offset);
+    else
+        return load_field(r, parsing_context, offset, std::forward<T>(field));
+}
+
+template <typename composite_t, typename parsing_context_t, typename T, typename... Ts>
+constexpr inline std::size_t load_fields(const composite_t& r, parsing_context_t& parsing_context,
+    [[maybe_unused]] std::size_t offset, 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)...);
+}
+
+SPLIT_FIELDS(std::size_t, deserialize, load_fields, );
+
+template <typename composite_t>
+constexpr composite_t deserialize(auto&& parsing_context, [[maybe_unused]] std::size_t offset = 0)
+{
+    composite_t r;
+    deserialize(r, std::forward<decltype(parsing_context)>(parsing_context), offset);
+    return r;
+}
+
+}

include/cpp_utils/serde/serde.hpp

@@ -0,0 +1,28 @@
+/*------------------------------------------------------------------------------
+-- The MIT License (MIT)
+--
+-- Copyright © 2024, Laboratory of Plasma Physics- CNRS
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and associated documentation files (the “Software”), to deal
+-- in the Software without restriction, including without limitation the rights
+-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+-- INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+-- PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+-- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-------------------------------------------------------------------------------*/
+/*-- Author : Alexis Jeandet
+-- Mail : [email protected]
+----------------------------------------------------------------------------*/
+#pragma once
+#include "special_fields.hpp"
+#include "deserialization.hpp"

include/cpp_utils/serde/special_fields.hpp

@@ -0,0 +1,69 @@
+/*------------------------------------------------------------------------------
+-- The MIT License (MIT)
+--
+-- Copyright © 2024, Laboratory of Plasma Physics- CNRS
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and associated documentation files (the “Software”), to deal
+-- in the Software without restriction, including without limitation the rights
+-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+-- INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+-- PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+-- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-------------------------------------------------------------------------------*/
+/*-- Author : Alexis Jeandet
+-- Mail : [email protected]
+----------------------------------------------------------------------------*/
+#pragma once
+#include "../endianness/endianness.hpp"
+#include "../reflexion/reflection.hpp"
+
+namespace cpp_utils::serde
+{
+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;
+
+
+template <std::size_t size, uint8_t value>
+struct padding_bytes_t
+{
+    static constexpr std::size_t padding_size = size;
+    static constexpr uint8_t padding_value = value;
+};
+
+
+template <typename composite_t>
+consteval auto _endianness()
+{
+    if constexpr (requires { typename composite_t::endianness; })
+    {
+        return typename composite_t::endianness{};
+    }
+    else
+    {
+        return endianness::little_endian_t{};
+    }
+}
+
+template <typename composite_t>
+using endianness_t = decltype(_endianness<composite_t>());
+
+template <typename composite_t>
+inline constexpr bool is_big_endian_v = std::is_same_v<endianness_t<composite_t>,endianness::big_endian_t>;
+
+
+}