From f08ec4f2d6775c6572e20ba0cfd33783a6d88e80 Mon Sep 17 00:00:00 2001 From: qicosmos Date: Thu, 5 Sep 2024 16:35:52 +0800 Subject: [PATCH] remove and improve --- iguana/common.hpp | 54 +- iguana/dynamic.hpp | 10 +- iguana/pb_util.hpp | 1 - iguana/reflection.hpp | 1232 ----------------------------------------- test/test_pb.cpp | 12 +- 5 files changed, 42 insertions(+), 1267 deletions(-) delete mode 100644 iguana/reflection.hpp diff --git a/iguana/common.hpp b/iguana/common.hpp index 841f696d..97bc0901 100644 --- a/iguana/common.hpp +++ b/iguana/common.hpp @@ -128,19 +128,25 @@ inline constexpr bool is_custom_reflection_v = // owner_type: parant type, value_type: member value type, SubType: subtype from // variant -template ::value_type> +template struct pb_field_t { - using member_type = MemberPtr; - using owner_type = typename member_traits::owner_type; - using value_type = typename member_traits::value_type; + using owner_type = Owner; + using value_type = Value; using sub_type = ElementType; constexpr pb_field_t() = default; - auto& value(owner_type& value) const { return value.*member_ptr; } - auto const& value(owner_type const& value) const { return value.*member_ptr; } + auto& value(owner_type& value) const { + auto member_ptr = (value_type*)((char*)(&value) + offset); + return *member_ptr; + } + // auto const& value(owner_type const& value) const { + // auto member_ptr = + // (value_type *)((char *)(&value) + offset); + // return *member_ptr; + // } - MemberPtr member_ptr; + size_t offset; std::string_view field_name; inline static constexpr uint32_t field_no = FieldNo; @@ -170,14 +176,13 @@ inline constexpr auto get_field_no(std::index_sequence) { return arr; } -template -constexpr inline auto build_pb_variant_fields(MemberPtr field, +template +constexpr inline auto build_pb_variant_fields(size_t offset, std::string_view name, std::index_sequence) { - using value_type = typename member_traits::value_type; return std::tuple( - pb_field_t>{field, name}...); + pb_field_t>{offset, name}...); } template @@ -185,16 +190,14 @@ constexpr inline auto build_pb_fields_impl(size_t offset, std::string_view name) { using value_type = ylt::reflection::remove_cvref_t; using U = std::remove_reference_t; - using P = value_type U::*; - P member_ptr = *reinterpret_cast(&offset); if constexpr (is_variant::value) { constexpr uint32_t variant_size = std::variant_size_v; - return build_pb_variant_fields( - std::move(member_ptr), name, std::make_index_sequence{}); + return build_pb_variant_fields( + offset, name, std::make_index_sequence{}); } else { - return std::tuple(pb_field_t{member_ptr, name}); + return std::tuple(pb_field_t{offset, name}); } } @@ -260,4 +263,19 @@ inline bool register_type() { return true; #endif } + +template +IGUANA_INLINE constexpr size_t member_offset(T* t, U T::*member) { + return (char*)&(t->*member) - (char*)t; +} + +template +IGUANA_INLINE auto build_pb_field(std::string_view name) { + using owner = + typename ylt::reflection::member_traits::owner_type; + using value_type = + typename ylt::reflection::member_traits::value_type; + size_t offset = member_offset((owner*)nullptr, ptr); + return iguana::detail::pb_field_t{offset, name}; +} } // namespace iguana \ No newline at end of file diff --git a/iguana/dynamic.hpp b/iguana/dynamic.hpp index 00543b4e..47cf2015 100644 --- a/iguana/dynamic.hpp +++ b/iguana/dynamic.hpp @@ -4,11 +4,6 @@ namespace iguana { using base = detail::base; -template -IGUANA_INLINE constexpr size_t member_offset(T* t, U T::*member) { - return (char*)&(t->*member) - (char*)t; -} - constexpr inline uint8_t ENABLE_JSON = 0x01; constexpr inline uint8_t ENABLE_YAML = 0x02; constexpr inline uint8_t ENABLE_XML = 0x04; @@ -102,7 +97,7 @@ struct base_impl : public base { std::visit( [&](auto const& val) { if (val.field_name == name) { - info.offset = member_offset((T*)this, val.member_ptr); + info.offset = val.offset; using value_type = typename std::remove_reference_t::value_type; #if defined(__clang__) || defined(_MSC_VER) || \ @@ -151,8 +146,7 @@ struct base_impl : public base { if (val.field_name == name) { using value_type = typename std::remove_reference_t::value_type; - auto const offset = member_offset((T*)this, val.member_ptr); - auto ptr = (char*)this + offset; + auto ptr = (char*)this + val.offset; result = *((value_type*)ptr); } }, diff --git a/iguana/pb_util.hpp b/iguana/pb_util.hpp index e4cc73e2..bd8d5faa 100644 --- a/iguana/pb_util.hpp +++ b/iguana/pb_util.hpp @@ -15,7 +15,6 @@ #include "common.hpp" #include "detail/pb_type.hpp" -// #include "reflection.hpp" #include "util.hpp" namespace iguana { diff --git a/iguana/reflection.hpp b/iguana/reflection.hpp deleted file mode 100644 index 8ac38ae3..00000000 --- a/iguana/reflection.hpp +++ /dev/null @@ -1,1232 +0,0 @@ -// -// Created by Qiyu on 17-6-5. -// - -#ifndef IGUANA_REFLECTION_HPP -#define IGUANA_REFLECTION_HPP -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "detail/string_stream.hpp" -#include "detail/traits.hpp" -#include "field_reflection.hpp" -#include "frozen/string.h" -#include "frozen/unordered_map.h" - -namespace iguana::detail { -/******************************************/ -/* arg list expand macro, now support 120 args */ -#define MAKE_ARG_LIST_1(op, arg, ...) op(arg) -#define MAKE_ARG_LIST_2(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_1(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_3(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_2(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_4(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_3(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_5(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_4(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_6(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_5(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_7(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_6(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_8(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_7(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_9(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_8(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_10(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_9(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_11(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_10(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_12(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_11(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_13(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_12(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_14(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_13(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_15(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_14(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_16(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_15(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_17(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_16(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_18(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_17(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_19(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_18(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_20(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_19(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_21(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_20(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_22(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_21(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_23(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_22(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_24(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_23(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_25(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_24(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_26(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_25(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_27(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_26(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_28(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_27(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_29(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_28(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_30(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_29(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_31(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_30(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_32(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_31(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_33(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_32(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_34(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_33(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_35(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_34(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_36(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_35(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_37(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_36(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_38(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_37(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_39(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_38(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_40(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_39(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_41(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_40(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_42(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_41(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_43(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_42(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_44(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_43(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_45(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_44(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_46(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_45(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_47(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_46(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_48(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_47(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_49(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_48(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_50(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_49(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_51(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_50(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_52(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_51(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_53(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_52(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_54(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_53(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_55(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_54(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_56(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_55(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_57(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_56(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_58(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_57(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_59(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_58(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_60(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_59(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_61(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_60(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_62(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_61(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_63(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_62(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_64(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_63(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_65(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_64(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_66(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_65(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_67(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_66(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_68(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_67(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_69(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_68(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_70(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_69(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_71(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_70(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_72(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_71(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_73(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_72(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_74(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_73(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_75(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_74(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_76(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_75(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_77(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_76(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_78(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_77(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_79(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_78(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_80(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_79(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_81(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_80(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_82(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_81(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_83(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_82(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_84(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_83(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_85(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_84(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_86(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_85(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_87(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_86(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_88(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_87(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_89(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_88(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_90(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_89(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_91(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_90(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_92(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_91(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_93(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_92(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_94(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_93(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_95(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_94(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_96(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_95(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_97(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_96(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_98(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_97(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_99(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_98(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_100(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_99(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_101(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_100(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_102(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_101(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_103(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_102(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_104(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_103(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_105(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_104(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_106(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_105(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_107(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_106(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_108(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_107(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_109(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_108(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_110(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_109(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_111(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_110(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_112(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_111(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_113(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_112(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_114(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_113(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_115(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_114(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_116(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_115(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_117(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_116(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_118(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_117(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_119(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_118(op, __VA_ARGS__)) -#define MAKE_ARG_LIST_120(op, arg, ...) \ - op(arg), MARCO_EXPAND(MAKE_ARG_LIST_119(op, __VA_ARGS__)) - -#define ADD_VIEW(str) std::string_view(#str, sizeof(#str) - 1) - -#define SEPERATOR , -#define CON_STR_1(element, ...) ADD_VIEW(element) -#define CON_STR_2(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_1(__VA_ARGS__)) -#define CON_STR_3(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_2(__VA_ARGS__)) -#define CON_STR_4(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_3(__VA_ARGS__)) -#define CON_STR_5(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_4(__VA_ARGS__)) -#define CON_STR_6(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_5(__VA_ARGS__)) -#define CON_STR_7(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_6(__VA_ARGS__)) -#define CON_STR_8(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_7(__VA_ARGS__)) -#define CON_STR_9(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_8(__VA_ARGS__)) -#define CON_STR_10(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_9(__VA_ARGS__)) -#define CON_STR_11(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_10(__VA_ARGS__)) -#define CON_STR_12(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_11(__VA_ARGS__)) -#define CON_STR_13(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_12(__VA_ARGS__)) -#define CON_STR_14(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_13(__VA_ARGS__)) -#define CON_STR_15(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_14(__VA_ARGS__)) -#define CON_STR_16(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_15(__VA_ARGS__)) -#define CON_STR_17(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_16(__VA_ARGS__)) -#define CON_STR_18(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_17(__VA_ARGS__)) -#define CON_STR_19(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_18(__VA_ARGS__)) -#define CON_STR_20(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_19(__VA_ARGS__)) -#define CON_STR_21(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_20(__VA_ARGS__)) -#define CON_STR_22(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_21(__VA_ARGS__)) -#define CON_STR_23(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_22(__VA_ARGS__)) -#define CON_STR_24(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_23(__VA_ARGS__)) -#define CON_STR_25(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_24(__VA_ARGS__)) -#define CON_STR_26(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_25(__VA_ARGS__)) -#define CON_STR_27(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_26(__VA_ARGS__)) -#define CON_STR_28(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_27(__VA_ARGS__)) -#define CON_STR_29(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_28(__VA_ARGS__)) -#define CON_STR_30(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_29(__VA_ARGS__)) -#define CON_STR_31(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_30(__VA_ARGS__)) -#define CON_STR_32(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_31(__VA_ARGS__)) -#define CON_STR_33(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_32(__VA_ARGS__)) -#define CON_STR_34(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_33(__VA_ARGS__)) -#define CON_STR_35(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_34(__VA_ARGS__)) -#define CON_STR_36(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_35(__VA_ARGS__)) -#define CON_STR_37(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_36(__VA_ARGS__)) -#define CON_STR_38(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_37(__VA_ARGS__)) -#define CON_STR_39(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_38(__VA_ARGS__)) -#define CON_STR_40(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_39(__VA_ARGS__)) -#define CON_STR_41(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_40(__VA_ARGS__)) -#define CON_STR_42(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_41(__VA_ARGS__)) -#define CON_STR_43(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_42(__VA_ARGS__)) -#define CON_STR_44(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_43(__VA_ARGS__)) -#define CON_STR_45(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_44(__VA_ARGS__)) -#define CON_STR_46(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_45(__VA_ARGS__)) -#define CON_STR_47(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_46(__VA_ARGS__)) -#define CON_STR_48(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_47(__VA_ARGS__)) -#define CON_STR_49(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_48(__VA_ARGS__)) -#define CON_STR_50(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_49(__VA_ARGS__)) -#define CON_STR_51(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_50(__VA_ARGS__)) -#define CON_STR_52(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_51(__VA_ARGS__)) -#define CON_STR_53(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_52(__VA_ARGS__)) -#define CON_STR_54(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_53(__VA_ARGS__)) -#define CON_STR_55(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_54(__VA_ARGS__)) -#define CON_STR_56(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_55(__VA_ARGS__)) -#define CON_STR_57(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_56(__VA_ARGS__)) -#define CON_STR_58(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_57(__VA_ARGS__)) -#define CON_STR_59(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_58(__VA_ARGS__)) -#define CON_STR_60(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_59(__VA_ARGS__)) -#define CON_STR_61(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_60(__VA_ARGS__)) -#define CON_STR_62(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_61(__VA_ARGS__)) -#define CON_STR_63(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_62(__VA_ARGS__)) -#define CON_STR_64(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_63(__VA_ARGS__)) -#define CON_STR_65(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_64(__VA_ARGS__)) -#define CON_STR_66(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_65(__VA_ARGS__)) -#define CON_STR_67(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_66(__VA_ARGS__)) -#define CON_STR_68(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_67(__VA_ARGS__)) -#define CON_STR_69(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_68(__VA_ARGS__)) -#define CON_STR_70(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_69(__VA_ARGS__)) -#define CON_STR_71(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_70(__VA_ARGS__)) -#define CON_STR_72(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_71(__VA_ARGS__)) -#define CON_STR_73(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_72(__VA_ARGS__)) -#define CON_STR_74(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_73(__VA_ARGS__)) -#define CON_STR_75(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_74(__VA_ARGS__)) -#define CON_STR_76(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_75(__VA_ARGS__)) -#define CON_STR_77(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_76(__VA_ARGS__)) -#define CON_STR_78(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_77(__VA_ARGS__)) -#define CON_STR_79(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_78(__VA_ARGS__)) -#define CON_STR_80(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_79(__VA_ARGS__)) -#define CON_STR_81(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_80(__VA_ARGS__)) -#define CON_STR_82(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_81(__VA_ARGS__)) -#define CON_STR_83(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_82(__VA_ARGS__)) -#define CON_STR_84(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_83(__VA_ARGS__)) -#define CON_STR_85(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_84(__VA_ARGS__)) -#define CON_STR_86(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_85(__VA_ARGS__)) -#define CON_STR_87(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_86(__VA_ARGS__)) -#define CON_STR_88(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_87(__VA_ARGS__)) -#define CON_STR_89(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_88(__VA_ARGS__)) -#define CON_STR_90(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_89(__VA_ARGS__)) -#define CON_STR_91(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_90(__VA_ARGS__)) -#define CON_STR_92(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_91(__VA_ARGS__)) -#define CON_STR_93(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_92(__VA_ARGS__)) -#define CON_STR_94(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_93(__VA_ARGS__)) -#define CON_STR_95(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_94(__VA_ARGS__)) -#define CON_STR_96(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_95(__VA_ARGS__)) -#define CON_STR_97(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_96(__VA_ARGS__)) -#define CON_STR_98(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_97(__VA_ARGS__)) -#define CON_STR_99(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_98(__VA_ARGS__)) -#define CON_STR_100(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_99(__VA_ARGS__)) -#define CON_STR_101(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_100(__VA_ARGS__)) -#define CON_STR_102(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_101(__VA_ARGS__)) -#define CON_STR_103(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_102(__VA_ARGS__)) -#define CON_STR_104(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_103(__VA_ARGS__)) -#define CON_STR_105(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_104(__VA_ARGS__)) -#define CON_STR_106(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_105(__VA_ARGS__)) -#define CON_STR_107(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_106(__VA_ARGS__)) -#define CON_STR_108(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_107(__VA_ARGS__)) -#define CON_STR_109(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_108(__VA_ARGS__)) -#define CON_STR_110(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_109(__VA_ARGS__)) -#define CON_STR_111(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_110(__VA_ARGS__)) -#define CON_STR_112(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_111(__VA_ARGS__)) -#define CON_STR_113(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_112(__VA_ARGS__)) -#define CON_STR_114(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_113(__VA_ARGS__)) -#define CON_STR_115(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_114(__VA_ARGS__)) -#define CON_STR_116(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_115(__VA_ARGS__)) -#define CON_STR_117(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_116(__VA_ARGS__)) -#define CON_STR_118(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_117(__VA_ARGS__)) -#define CON_STR_119(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_118(__VA_ARGS__)) -#define CON_STR_120(element, ...) \ - ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_119(__VA_ARGS__)) -#define RSEQ_N() \ - 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, \ - 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, \ - 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, \ - 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, \ - 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, \ - 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, \ - 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 - -#define ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, \ - _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, \ - _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ - _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, \ - _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, \ - _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, _77, _78, _79, \ - _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, \ - _93, _94, _95, _96, _97, _98, _99, _100, _101, _102, _103, _104, \ - _105, _106, _107, _108, _109, _110, _111, _112, _113, _114, \ - _115, _116, _117, _118, _119, N, ...) \ - N - -#define MARCO_EXPAND(...) __VA_ARGS__ -#define APPLY_VARIADIC_MACRO(macro, ...) MARCO_EXPAND(macro(__VA_ARGS__)) - -#define ADD_REFERENCE(t) std::reference_wrapper(t) -#define ADD_REFERENCE_CONST(t) \ - std::reference_wrapper>(t) -#define FIELD(t) t -#define MAKE_NAMES(...) #__VA_ARGS__, - -// note use MACRO_CONCAT like A##_##B direct may cause marco expand error -#define MACRO_CONCAT(A, B) MACRO_CONCAT1(A, B) -#define MACRO_CONCAT1(A, B) A##_##B - -#define MAKE_ARG_LIST(N, op, arg, ...) \ - MACRO_CONCAT(MAKE_ARG_LIST, N)(op, arg, __VA_ARGS__) - -#define GET_ARG_COUNT_INNER(...) MARCO_EXPAND(ARG_N(__VA_ARGS__)) -#define GET_ARG_COUNT(...) GET_ARG_COUNT_INNER(__VA_ARGS__, RSEQ_N()) - -#define MAKE_STR_LIST(...) \ - MACRO_CONCAT(CON_STR, GET_ARG_COUNT(__VA_ARGS__))(__VA_ARGS__) - -template -inline bool register_type() { -#if defined(__clang__) || defined(_MSC_VER) || \ - (defined(__GNUC__) && __GNUC__ > 8) - if constexpr (std::is_base_of_v) { - auto it = g_pb_map.emplace(type_string(), [] { - return std::make_shared(); - }); - return it.second; - } - else { - return true; - } -#else - return true; -#endif -} - -#define MAKE_META_DATA_IMPL(STRUCT_NAME, ...) \ - static inline bool IGUANA_UNIQUE_VARIABLE(reg_var) = \ - iguana::detail::register_type(); \ - [[maybe_unused]] inline static auto iguana_reflect_members( \ - const iguana::detail::identity &) { \ - struct reflect_members { \ - constexpr decltype(auto) static apply_impl() { \ - return std::make_tuple(__VA_ARGS__); \ - } \ - using size_type = \ - std::integral_constant; \ - constexpr static std::string_view name() { return name_##STRUCT_NAME; } \ - constexpr static std::string_view struct_name() { \ - return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1); \ - } \ - constexpr static std::string_view fields() { \ - return fields_##STRUCT_NAME; \ - } \ - constexpr static size_t value() { return size_type::value; } \ - constexpr static std::array arr() { \ - return arr_##STRUCT_NAME; \ - } \ - }; \ - return reflect_members{}; \ - } - -#define MAKE_META_DATA(STRUCT_NAME, TABLE_NAME, N, ...) \ - static constexpr inline std::array arr_##STRUCT_NAME = { \ - MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__))}; \ - static constexpr inline std::string_view fields_##STRUCT_NAME = { \ - MAKE_NAMES(__VA_ARGS__)}; \ - static constexpr inline std::string_view name_##STRUCT_NAME = TABLE_NAME; \ - MAKE_META_DATA_IMPL(STRUCT_NAME, \ - MAKE_ARG_LIST(N, &STRUCT_NAME::FIELD, __VA_ARGS__)) - -#define REFLECTION_ALIAS_IMPL(STRUCT_NAME, ALIAS, N, ...) \ - MAKE_META_DATA_IMPL_ALIAS(STRUCT_NAME, ALIAS, __VA_ARGS__) - -#define FLDALIAS(a, b) \ - std::pair { a, b } - -template -constexpr auto get_mem_ptr_tp(Args... pair) { - return std::make_tuple(std::get<0>(pair)...); -} - -template -constexpr std::array get_alias_arr(Args... pairs) { - return std::array{ - frozen::string(std::get<1>(pairs))...}; -} - -#define MAKE_META_DATA_IMPL_ALIAS(STRUCT_NAME, ALIAS, ...) \ - [[maybe_unused]] inline static auto iguana_reflect_members( \ - const iguana::detail::identity &) { \ - struct reflect_members { \ - constexpr decltype(auto) static apply_impl() { \ - return iguana::detail::get_mem_ptr_tp(__VA_ARGS__); \ - } \ - using size_type = std::integral_constant< \ - size_t, std::tuple_size_v>; \ - constexpr static std::string_view name() { return ALIAS; } \ - constexpr static std::string_view struct_name() { \ - return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1); \ - } \ - constexpr static size_t value() { return size_type::value; } \ - constexpr static std::array arr() { \ - return iguana::detail::get_alias_arr(__VA_ARGS__); \ - } \ - }; \ - return reflect_members{}; \ - } - -#define MAKE_META_DATA_IMPL_EMPTY(STRUCT_NAME) \ - inline auto iguana_reflect_members( \ - const iguana::detail::identity &) { \ - struct reflect_members { \ - constexpr decltype(auto) static apply_impl() { \ - return std::make_tuple(); \ - } \ - using size_type = std::integral_constant; \ - constexpr static std::string_view name() { \ - return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1); \ - } \ - constexpr static size_t value() { return size_type::value; } \ - constexpr static std::array arr() { \ - return arr_##STRUCT_NAME; \ - } \ - }; \ - return reflect_members{}; \ - } - -#define MAKE_META_DATA_EMPTY(STRUCT_NAME) \ - constexpr inline std::array arr_##STRUCT_NAME = {}; \ - MAKE_META_DATA_IMPL_EMPTY(STRUCT_NAME) - -template -inline auto get_value_type(std::tuple) { - return std::variant{}; -} - -inline constexpr frozen::string filter_str(const frozen::string &str) { - if (str.size() > 3 && str[0] == '_' && str[1] == '_' && str[2] == '_') { - auto ptr = str.data() + 3; - return frozen::string(ptr, str.size() - 3); - } - return str; -} - -template -inline constexpr auto get_iguana_struct_map_impl( - const std::array &arr, T &&t, - std::index_sequence) { - using ValueType = decltype(get_value_type(t)); - return frozen::unordered_map{ - {filter_str(arr[Is]), - ValueType{std::in_place_index, std::get(t)}}...}; -} -} // namespace iguana::detail - -namespace iguana { -#define REFLECTION_WITH_NAME(STRUCT_NAME, TABLE_NAME, ...) \ - MAKE_META_DATA(STRUCT_NAME, TABLE_NAME, GET_ARG_COUNT(__VA_ARGS__), \ - __VA_ARGS__) - -struct iguana_adl_t {}; - -template -inline auto iguana_reflect_type(const T &t); - -inline std::unordered_map< - std::string_view, - std::vector>> - g_iguana_custom_map; -template -inline constexpr auto get_iguana_struct_map() { - using reflect_members = decltype(iguana_reflect_type(std::declval())); - if constexpr (reflect_members::value() == 0) { - return std::array{}; - } - else { - return detail::get_iguana_struct_map_impl( - reflect_members::arr(), reflect_members::apply_impl(), - std::make_index_sequence{}); - } -} - -template ::value_type> -struct field_t { - using member_type = T; - using owner_type = typename member_traits::owner_type; - using value_type = typename member_traits::value_type; - using sub_type = ElementType; - constexpr field_t() = default; - constexpr field_t(T member, uint32_t number, frozen::string name = "") - : member_ptr(member), field_name(name), field_no(number) {} - - T member_ptr; - frozen::string field_name; - uint32_t field_no; - - auto &value(owner_type &value) const { return value.*member_ptr; } - auto const &value(owner_type const &value) const { return value.*member_ptr; } -}; - -template -struct field_type_t; - -template -struct field_type_t> { - using value_type = std::variant; -}; - -template -struct is_custom_reflection : std::false_type {}; - -template -struct is_custom_reflection< - T, std::void_t()))>> - : std::true_type {}; - -template -struct is_reflection : std::false_type {}; - -template -inline constexpr bool is_reflection_v = is_reflection::value; - -template -constexpr inline bool refletable_v = is_reflection_v>; - -template -constexpr inline bool non_refletable_v = !refletable_v; - -template -inline constexpr bool is_custom_reflection_v = is_custom_reflection::value; - -template -constexpr inline auto build_variant_fields(T t, S &s, uint32_t base_idx, - std::index_sequence) { - using value_type = typename member_traits::value_type; - return std::tuple(field_t>{ - t, (base_idx + uint32_t(I)), s}...); -} - -template -constexpr inline auto build_fields(T t, S &s, uint32_t &index) { - using value_type = typename member_traits::value_type; - if constexpr (is_variant::value) { - constexpr uint32_t Size = std::variant_size_v; - index += (Size - 1); - return build_variant_fields(t, s, I + 1, std::make_index_sequence{}); - } - else { - uint32_t field_no = (I == index) ? (I + 1) : (2 + index); - index++; - return std::tuple(field_t{t, field_no, s}); - } -} - -template -constexpr inline auto get_members_tuple_impl(T &&tp, U &&arr, - std::index_sequence &&) { - uint32_t index = 0; - return std::tuple_cat(build_fields(std::get(tp), arr[I], index)...); -} - -template -constexpr inline auto get_members_tuple() { - if constexpr (is_reflection::value) { - using reflect_members = decltype(iguana_reflect_type(std::declval())); - using Tuple = decltype(reflect_members::apply_impl()); - constexpr size_t Size = std::tuple_size_v; - return get_members_tuple_impl(reflect_members::apply_impl(), - reflect_members::arr(), - std::make_index_sequence{}); - } - else if constexpr (is_custom_reflection_v) { - using U = std::remove_const_t>; - return get_members_impl((U *)nullptr); - } - else { - static_assert(!sizeof(T), "expected reflection or custom reflection"); - } -} - -template -constexpr auto inline get_members_impl(Tuple &&tp, std::index_sequence) { - return frozen::unordered_map{ - {std::get(tp).field_no, - T{std::in_place_index, std::move(std::get(tp))}}...}; -} - -template -constexpr size_t count_variant_size() { - if constexpr (is_variant::value) { - return std::variant_size_v; - } - else { - return 1; - } -} - -template -constexpr size_t tuple_type_count_impl(std::index_sequence) { - return ( - (count_variant_size>>() + - ...)); -} - -template -constexpr size_t tuple_type_count() { - return tuple_type_count_impl( - std::make_index_sequence>{}); -} - -template -constexpr inline auto get_members() { - if constexpr (is_reflection_v || is_custom_reflection_v) { - constexpr auto tp = get_members_tuple(); - using Tuple = std::decay_t; - using value_type = typename field_type_t::value_type; - constexpr auto Size = tuple_type_count(); - return get_members_impl(tp, - std::make_index_sequence{}); - } - else { - static_assert(!sizeof(T), "expected reflection or custom reflection"); - } -} - -#define REFLECTION(STRUCT_NAME, ...) \ - MAKE_META_DATA(STRUCT_NAME, #STRUCT_NAME, GET_ARG_COUNT(__VA_ARGS__), \ - __VA_ARGS__) - -#define REFLECTION_EMPTY(STRUCT_NAME) MAKE_META_DATA_EMPTY(STRUCT_NAME) - -#define REFLECTION_ALIAS(STRUCT_NAME, ALIAS, ...) \ - REFLECTION_ALIAS_IMPL( \ - STRUCT_NAME, ALIAS, \ - std::tuple_size_v, __VA_ARGS__) - -#define IGUANA_UNIQUE_VARIABLE(str) MACRO_CONCAT(str, __COUNTER__) - -inline std::string_view trim_sv(std::string_view str) { - std::string_view whitespaces(" \t\f\v\n\r"); - auto first = str.find_first_not_of(whitespaces); - auto last = str.find_last_not_of(whitespaces); - if (first == std::string_view::npos || last == std::string_view::npos) - return std::string_view(); - return str.substr(first, last - first + 1); -} - -inline int add_custom_fields(std::string_view key, - std::vector v) { - std::vector> vec; - for (auto val : v) { - std::string_view str = {val.data() + 1, val.size() - 2}; - size_t pos = str.find(','); - if (pos == std::string_view::npos || pos == str.size() - 1) { - continue; - } - - std::string_view origin = str.substr(0, pos); - std::string_view alias = str.substr(pos + 1); - - vec.push_back(std::make_pair(trim_sv(origin), trim_sv(alias))); - } - g_iguana_custom_map.emplace(key, std::move(vec)); - return 0; -} - -#define CUSTOM_FIELDS_IMPL(STRUCT_NAME, N, ...) \ - inline auto IGUANA_UNIQUE_VARIABLE(STRUCT_NAME) = iguana::add_custom_fields( \ - #STRUCT_NAME, {MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__))}); - -#define CUSTOM_FIELDS(STRUCT_NAME, ...) \ - CUSTOM_FIELDS_IMPL(STRUCT_NAME, GET_ARG_COUNT(__VA_ARGS__), __VA_ARGS__) - -template -using Reflect_members = decltype(iguana_reflect_members( - std::declval>())); - -template -struct is_public_reflection : std::false_type {}; - -template -struct is_public_reflection>()))>> - : std::true_type {}; - -template -constexpr bool is_public_reflection_v = is_public_reflection::value; - -template -struct is_private_reflection : std::false_type {}; - -template -struct is_private_reflection< - T, std::void_t().iguana_reflect_members( - std::declval>()))>> : std::true_type {}; - -template -constexpr bool is_private_reflection_v = is_private_reflection::value; - -template -struct is_reflection>> - : std::true_type {}; - -template -struct is_reflection>> - : std::true_type {}; - -template -inline auto iguana_reflect_type(const T &t) { - if constexpr (is_public_reflection_v>) { - return iguana_reflect_members(iguana::detail::identity{}); - } - else { - return t.iguana_reflect_members(iguana::detail::identity{}); - } -} - -template -constexpr decltype(auto) get(T &&t) { - using M = decltype(iguana_reflect_type(std::forward(t))); - using U = decltype(std::forward(t).*(std::get(M::apply_impl()))); - - if constexpr (std::is_array_v) { - auto s = std::forward(t).*(std::get(M::apply_impl())); - std::array arr; - memcpy(arr.data(), s, arr.size()); - return arr; - } - else - return std::forward(t).*(std::get(M::apply_impl())); -} - -template -constexpr auto get_impl(T const &t, std::index_sequence) { - return std::make_tuple(get(t)...); -} - -template -constexpr auto get_impl(T &t, std::index_sequence) { - return std::make_tuple(std::ref(get(t))...); -} - -template -constexpr auto get(T const &t) { - using M = decltype(iguana_reflect_type(t)); - return get_impl(t, std::make_index_sequence{}); -} - -template -constexpr auto get_ref(T &t) { - using M = decltype(iguana_reflect_type(t)); - return get_impl(t, std::make_index_sequence{}); -} - -template -constexpr const auto get_name() { - using M = decltype(iguana_reflect_type(std::declval())); - static_assert(I < M::value(), "out of range"); - return M::arr()[I]; -} - -template -constexpr const auto get_name(size_t i) { - using M = decltype(iguana_reflect_type(std::declval())); - // static_assert(I -constexpr const std::string_view get_name() { - using M = decltype(iguana_reflect_type(std::declval())); - return M::name(); -} - -namespace detail { -template -constexpr bool get_index_imple(T ptr, U ele) { - if constexpr (std::is_same_v) { - if (ele == ptr) { - return true; - } - else { - return false; - } - } - else { - return false; - } -} - -template -constexpr size_t member_index_impl(T ptr, Tuple &tp, - std::index_sequence) { - bool r = false; - size_t index = 0; - ((void)(!r && (r = get_index_imple(ptr, std::get(tp)), - !r ? index++ : index, true)), - ...); - return index; -} - -template -constexpr size_t member_index(T ptr, Tuple &tp) { - return member_index_impl( - ptr, tp, - std::make_index_sequence< - std::tuple_size_v>>{}); -} -} // namespace detail - -template -constexpr size_t index_of() { - using namespace detail; - using T = typename member_tratis::owner_type; - using M = Reflect_members; - constexpr auto tp = M::apply_impl(); - constexpr size_t Size = std::tuple_size_v; - constexpr size_t index = member_index(member, tp); - static_assert(index < Size, "out of range"); - return index; -} - -template -constexpr std::array indexs_of() { - return std::array{index_of()...}; -} - -template -constexpr auto name_of() { - using T = typename member_tratis::owner_type; - using M = Reflect_members; - constexpr auto s = M::arr()[index_of()]; - return std::string_view(s.data(), s.size()); -} - -template -constexpr std::array names_of() { - return std::array{ - name_of()...}; -} - -template -constexpr auto member_count_of() { - using T = typename member_tratis::owner_type; - using M = Reflect_members; - return M::value(); -} - -template -constexpr size_t duplicate_count(); - -template -constexpr void check_duplicate(Member member, size_t &index) { - using value_type = typename member_tratis::value_type; - - if (detail::get_index_imple(ptr, member)) { - index++; - } - - if constexpr (is_reflection_v) { - index += iguana::duplicate_count(); - } -} - -template -constexpr size_t duplicate_count() { - using M = Reflect_members; - constexpr auto name = name_of(); - constexpr auto arr = M::arr(); - - constexpr auto tp = M::apply_impl(); - size_t index = 0; - std::apply( - [&](auto... ele) { - (check_duplicate(ele, index), ...); - }, - tp); - - for (auto &s : arr) { - if (s == name) { - index++; - break; - } - } - - return index; -} - -template -constexpr const std::string_view get_fields() { - using M = Reflect_members; - return M::fields(); -} - -template -constexpr std::enable_if_t::value, size_t> get_value() { - using M = decltype(iguana_reflect_type(std::declval())); - return M::value(); -} - -template -constexpr std::enable_if_t::value, size_t> get_value() { - return 1; -} - -template -constexpr auto get_array() { - using M = decltype(iguana_reflect_type(std::declval())); - return M::arr(); -} - -template -inline bool has_custom_fields(std::string_view key = "") { - if (key.empty()) { - return !g_iguana_custom_map.empty(); - } - - return g_iguana_custom_map.find(key) != g_iguana_custom_map.end(); -} - -template -inline std::string_view get_custom_fields(std::string_view origin) { - constexpr std::string_view name = get_name(); - auto it = g_iguana_custom_map.find(name); - if (it == g_iguana_custom_map.end()) { - return ""; - } - - auto &vec = it->second; - auto find_it = std::find_if(vec.begin(), vec.end(), [origin](auto &pair) { - return pair.first == origin; - }); - - if (find_it == vec.end()) { - return ""; - } - - return (*find_it).second; -} - -template -constexpr auto get_index(std::string_view name) { - using M = decltype(iguana_reflect_type(std::declval())); - constexpr auto arr = M::arr(); - - auto it = std::find_if(arr.begin(), arr.end(), [name](auto str) { - return (str == name); - }); - - return std::distance(arr.begin(), it); -} - -template -void tuple_switch(std::size_t i, Tuple &&t, F &&f, std::index_sequence) { - ((i == Is && - ((std::forward(f)(std::get(std::forward(t)))), false)), - ...); -} - -//-------------------------------------------------------------------------------------------------------------// -//-------------------------------------------------------------------------------------------------------------// -template -constexpr void for_each(std::tuple &t, F &&f, - std::index_sequence) { - (std::forward(f)(std::get(t), std::integral_constant{}), - ...); -} - -template -constexpr void for_each(const std::tuple &t, F &&f, - std::index_sequence) { - (std::forward(f)(std::get(t), std::integral_constant{}), - ...); -} - -template -constexpr std::enable_if_t>::value> for_each( - T &&t, F &&f) { - using M = decltype(iguana_reflect_type(std::forward(t))); - for_each(M::apply_impl(), std::forward(f), - std::make_index_sequence{}); -} - -template -constexpr std::enable_if_t>::value> for_each(T &&t, - F &&f) { - constexpr const size_t SIZE = std::tuple_size_v>; - for_each(std::forward(t), std::forward(f), - std::make_index_sequence{}); -} -} // namespace iguana -#endif // IGUANA_REFLECTION_HPP diff --git a/test/test_pb.cpp b/test/test_pb.cpp index 43b452ae..0b9b2d8e 100644 --- a/test/test_pb.cpp +++ b/test/test_pb.cpp @@ -40,14 +40,10 @@ struct inner_struct { int z; }; -constexpr inline auto get_members_impl(inner_struct *) { - return std::make_tuple( - iguana::detail::pb_field_t{ - &inner_struct::x, "a"}, - iguana::detail::pb_field_t{ - &inner_struct::y, "b"}, - iguana::detail::pb_field_t{ - &inner_struct::z, "c"}); +inline auto get_members_impl(inner_struct *) { + return std::make_tuple(iguana::build_pb_field<&inner_struct::x, 7>("a"), + iguana::build_pb_field<&inner_struct::y, 9>("b"), + iguana::build_pb_field<&inner_struct::z, 12>("c")); } } // namespace my_space