From fd6097564ca8c5d19e08c47fc3d22f1369968da6 Mon Sep 17 00:00:00 2001 From: wyc <1104749580@qq.com> Date: Fri, 26 Jun 2026 09:36:15 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BD=BF=E7=94=A8boost=20pfr=20=E9=81=8D?= =?UTF-8?q?=E5=8E=86=E7=BB=93=E6=9E=84=E4=BD=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 3rd/magic_enum/export.h | 52 +- 3rd/pfr/.gitattributes | 97 + 3rd/pfr/.github/workflows/ci.yml | 190 ++ 3rd/pfr/.gitignore | 2 + 3rd/pfr/CMakeLists.txt | 20 + 3rd/pfr/LICENSE_1_0.txt | 23 + 3rd/pfr/README.md | 158 + 3rd/pfr/doc/Jamfile.v2 | 72 + 3rd/pfr/doc/pfr.qbk | 596 ++++ 3rd/pfr/example/get.cpp | 42 + 3rd/pfr/example/get_name.cpp | 43 + 3rd/pfr/example/motivating_example0.cpp | 26 + 3rd/pfr/example/quick_examples.cpp | 207 ++ 3rd/pfr/example/sample_printing.cpp | 95 + 3rd/pfr/include/boost/pfr.hpp | 25 + 3rd/pfr/include/boost/pfr/config.hpp | 148 + 3rd/pfr/include/boost/pfr/core.hpp | 265 ++ 3rd/pfr/include/boost/pfr/core_name.hpp | 88 + .../pfr/detail/cast_to_layout_compatible.hpp | 75 + 3rd/pfr/include/boost/pfr/detail/config.hpp | 26 + 3rd/pfr/include/boost/pfr/detail/core.hpp | 24 + .../boost/pfr/detail/core14_classic.hpp | 706 +++++ .../boost/pfr/detail/core14_loophole.hpp | 201 ++ 3rd/pfr/include/boost/pfr/detail/core17.hpp | 72 + .../boost/pfr/detail/core17_generated.hpp | 2754 +++++++++++++++++ .../include/boost/pfr/detail/core_name.hpp | 29 + .../boost/pfr/detail/core_name14_disabled.hpp | 43 + .../boost/pfr/detail/core_name20_static.hpp | 242 ++ .../include/boost/pfr/detail/detectors.hpp | 70 + .../include/boost/pfr/detail/fake_object.hpp | 25 + .../include/boost/pfr/detail/fields_count.hpp | 330 ++ .../boost/pfr/detail/for_each_field_impl.hpp | 66 + .../include/boost/pfr/detail/functional.hpp | 239 ++ 3rd/pfr/include/boost/pfr/detail/io.hpp | 85 + .../detail/make_flat_tuple_of_references.hpp | 96 + .../pfr/detail/make_integer_sequence.hpp | 90 + .../boost/pfr/detail/offset_based_getter.hpp | 141 + .../boost/pfr/detail/possible_reflectable.hpp | 49 + 3rd/pfr/include/boost/pfr/detail/rvalue_t.hpp | 35 + .../boost/pfr/detail/sequence_tuple.hpp | 178 ++ .../include/boost/pfr/detail/size_array.hpp | 79 + 3rd/pfr/include/boost/pfr/detail/size_t_.hpp | 18 + 3rd/pfr/include/boost/pfr/detail/stdarray.hpp | 41 + 3rd/pfr/include/boost/pfr/detail/stdtuple.hpp | 46 + .../pfr/detail/tie_from_structure_tuple.hpp | 44 + .../boost/pfr/detail/unsafe_declval.hpp | 37 + 3rd/pfr/include/boost/pfr/functions_for.hpp | 93 + 3rd/pfr/include/boost/pfr/functors.hpp | 221 ++ 3rd/pfr/include/boost/pfr/io.hpp | 113 + 3rd/pfr/include/boost/pfr/io_fields.hpp | 164 + 3rd/pfr/include/boost/pfr/ops.hpp | 187 ++ 3rd/pfr/include/boost/pfr/ops_fields.hpp | 127 + 3rd/pfr/include/boost/pfr/traits.hpp | 60 + 3rd/pfr/include/boost/pfr/traits_fwd.hpp | 21 + 3rd/pfr/include/boost/pfr/tuple_size.hpp | 48 + 3rd/pfr/index.html | 37 + 3rd/pfr/meta/libraries.json | 17 + 3rd/pfr/misc/generate_cpp17.py | 173 ++ 3rd/pfr/misc/generate_fields_names_big.cpp.py | 267 ++ 3rd/pfr/misc/strip_boost_namespace.sh | 84 + 3rd/pfr/source.success | 1 + 3rd/pfr/test/Jamfile | 10 + 3rd/pfr/test/appveyor.yml | 104 + 3rd/pfr/test/config/Jamfile.v2 | 22 + 3rd/pfr/test/config/print_config.cpp | 45 + 3rd/pfr/test/core/Jamfile.v2 | 133 + .../core/can_be_as_fallback_in_the_fusion.cpp | 37 + .../boost_pfr_disabled_via_macro.cpp | 10 + .../fields_count_on_reference.cpp | 15 + 3rd/pfr/test/core/compile-fail/inherited.cpp | 21 + .../core/compile-fail/inherited_nonempty.cpp | 20 + .../movable_and_lvalue_references.cpp | 25 + .../test/core/compile-fail/non_aggregate.cpp | 16 + .../test/core/compile-fail/ops_on_union.cpp | 18 + 3rd/pfr/test/core/compile-fail/ops_unions.cpp | 22 + .../compile-fail/ops_unrestricted_unions.cpp | 28 + .../core/compile-fail/pfr_review_test2.cpp | 39 + .../test/core/compile-fail/private_fields.cpp | 30 + .../core/compile-fail/protected_fields.cpp | 26 + 3rd/pfr/test/core/compile-fail/rvalue_tie.cpp | 17 + .../core/compile-fail/virtual_functions.cpp | 20 + 3rd/pfr/test/core/loophole_detection.cpp | 29 + 3rd/pfr/test/core/offset_based_getter.cpp | 37 + 3rd/pfr/test/core/run/bitfields_count.cpp | 21 + 3rd/pfr/test/core/run/constexpr_ops.cpp | 81 + 3rd/pfr/test/core/run/core17_generated.cpp | 125 + 3rd/pfr/test/core/run/destructuring_tie.cpp | 60 + 3rd/pfr/test/core/run/error_pfr_c1202.cpp | 101 + .../test/core/run/fields_count_on_const.cpp | 15 + 3rd/pfr/test/core/run/for_each_field.cpp | 137 + 3rd/pfr/test/core/run/functions_for.cpp | 160 + 3rd/pfr/test/core/run/get_by_type.cpp | 67 + 3rd/pfr/test/core/run/get_const_field.cpp | 55 + .../run/get_non_default_constructible.cpp | 27 + 3rd/pfr/test/core/run/get_rvalue.cpp | 31 + .../core/run/is_implicitly_reflectable.cpp | 83 + 3rd/pfr/test/core/run/is_reflectable.cpp | 112 + 3rd/pfr/test/core/run/issue30.cpp | 37 + 3rd/pfr/test/core/run/issue33.cpp | 37 + 3rd/pfr/test/core/run/motivating_example.cpp | 22 + 3rd/pfr/test/core/run/motivating_example2.cpp | 21 + .../core/run/non_copyable_but_movable.cpp | 43 + .../test/core/run/non_dc_non_cop_but_mov.cpp | 44 + .../core/run/non_default_constructible.cpp | 34 + 3rd/pfr/test/core/run/non_movable.cpp | 51 + 3rd/pfr/test/core/run/non_std_layout.cpp | 26 + 3rd/pfr/test/core/run/ops.cpp | 108 + 3rd/pfr/test/core/run/optional_chrono.cpp | 78 + 3rd/pfr/test/core/run/optional_like.cpp | 27 + 3rd/pfr/test/core/run/read_write.cpp | 90 + .../test/core/run/read_write_non_literal.cpp | 73 + 3rd/pfr/test/core/run/std_interactions.cpp | 36 + .../test/core/run/template_constructor.cpp | 56 + .../test/core/run/template_forwarding_ref.cpp | 69 + .../test/core/run/template_unconstrained.cpp | 69 + 3rd/pfr/test/core/run/tie_anonymous.cpp | 108 + .../core/run/tie_anonymous_const_field.cpp | 60 + 3rd/pfr/test/core/run/tuple_size.cpp | 19 + 3rd/pfr/test/core/test_tuple_sizes_on.cpp | 53 + 3rd/pfr/test/core_name/Jamfile.v2 | 60 + ...fields_names_could_not_detect_compiler.cpp | 20 + .../fields_names_disabled_via_macro_00.cpp | 20 + .../fields_names_disabled_via_macro_01.cpp | 20 + .../fields_names_get_name_on_array.cpp | 17 + .../fields_names_get_name_on_union.cpp | 22 + .../fields_names_misconfigured_compiler.cpp | 21 + .../fields_names_names_as_array_on_array.cpp | 17 + .../fields_names_names_as_array_on_union.cpp | 22 + ...elds_names_wrongly_configured_compiler.cpp | 21 + .../compile-fail/poor_fields_name.cpp | 25 + ..._of_non_static_member_tplarg_detection.cpp | 23 + .../cxx20_nontype_tplarg_detection.cpp | 32 + 3rd/pfr/test/core_name/print_name.cpp | 44 + 3rd/pfr/test/core_name/run/fields_names.cpp | 86 + .../test/core_name/run/fields_names_big.cpp | 170 + .../core_name/run/fields_names_constexpr.cpp | 40 + .../run/fields_names_internal_parser.cpp | 47 + .../core_name/run/fields_names_nonascii.cpp | 44 + Core/Base/JSON.cpp | 9 + Core/Base/JSON.h | 859 ++--- Core/system.zip | Bin 19701 -> 0 bytes main.cmake | 3 +- 142 files changed, 13775 insertions(+), 410 deletions(-) create mode 100644 3rd/pfr/.gitattributes create mode 100644 3rd/pfr/.github/workflows/ci.yml create mode 100644 3rd/pfr/.gitignore create mode 100644 3rd/pfr/CMakeLists.txt create mode 100644 3rd/pfr/LICENSE_1_0.txt create mode 100644 3rd/pfr/README.md create mode 100644 3rd/pfr/doc/Jamfile.v2 create mode 100644 3rd/pfr/doc/pfr.qbk create mode 100644 3rd/pfr/example/get.cpp create mode 100644 3rd/pfr/example/get_name.cpp create mode 100644 3rd/pfr/example/motivating_example0.cpp create mode 100644 3rd/pfr/example/quick_examples.cpp create mode 100644 3rd/pfr/example/sample_printing.cpp create mode 100644 3rd/pfr/include/boost/pfr.hpp create mode 100644 3rd/pfr/include/boost/pfr/config.hpp create mode 100644 3rd/pfr/include/boost/pfr/core.hpp create mode 100644 3rd/pfr/include/boost/pfr/core_name.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/cast_to_layout_compatible.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/config.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core14_classic.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core14_loophole.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core17.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core17_generated.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core_name.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core_name14_disabled.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/core_name20_static.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/detectors.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/fake_object.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/fields_count.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/for_each_field_impl.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/functional.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/io.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/make_flat_tuple_of_references.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/make_integer_sequence.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/offset_based_getter.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/possible_reflectable.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/rvalue_t.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/sequence_tuple.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/size_array.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/size_t_.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/stdarray.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/stdtuple.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/tie_from_structure_tuple.hpp create mode 100644 3rd/pfr/include/boost/pfr/detail/unsafe_declval.hpp create mode 100644 3rd/pfr/include/boost/pfr/functions_for.hpp create mode 100644 3rd/pfr/include/boost/pfr/functors.hpp create mode 100644 3rd/pfr/include/boost/pfr/io.hpp create mode 100644 3rd/pfr/include/boost/pfr/io_fields.hpp create mode 100644 3rd/pfr/include/boost/pfr/ops.hpp create mode 100644 3rd/pfr/include/boost/pfr/ops_fields.hpp create mode 100644 3rd/pfr/include/boost/pfr/traits.hpp create mode 100644 3rd/pfr/include/boost/pfr/traits_fwd.hpp create mode 100644 3rd/pfr/include/boost/pfr/tuple_size.hpp create mode 100644 3rd/pfr/index.html create mode 100644 3rd/pfr/meta/libraries.json create mode 100644 3rd/pfr/misc/generate_cpp17.py create mode 100644 3rd/pfr/misc/generate_fields_names_big.cpp.py create mode 100644 3rd/pfr/misc/strip_boost_namespace.sh create mode 100644 3rd/pfr/source.success create mode 100644 3rd/pfr/test/Jamfile create mode 100644 3rd/pfr/test/appveyor.yml create mode 100644 3rd/pfr/test/config/Jamfile.v2 create mode 100644 3rd/pfr/test/config/print_config.cpp create mode 100644 3rd/pfr/test/core/Jamfile.v2 create mode 100644 3rd/pfr/test/core/can_be_as_fallback_in_the_fusion.cpp create mode 100644 3rd/pfr/test/core/compile-fail/boost_pfr_disabled_via_macro.cpp create mode 100644 3rd/pfr/test/core/compile-fail/fields_count_on_reference.cpp create mode 100644 3rd/pfr/test/core/compile-fail/inherited.cpp create mode 100644 3rd/pfr/test/core/compile-fail/inherited_nonempty.cpp create mode 100644 3rd/pfr/test/core/compile-fail/movable_and_lvalue_references.cpp create mode 100644 3rd/pfr/test/core/compile-fail/non_aggregate.cpp create mode 100644 3rd/pfr/test/core/compile-fail/ops_on_union.cpp create mode 100644 3rd/pfr/test/core/compile-fail/ops_unions.cpp create mode 100644 3rd/pfr/test/core/compile-fail/ops_unrestricted_unions.cpp create mode 100644 3rd/pfr/test/core/compile-fail/pfr_review_test2.cpp create mode 100644 3rd/pfr/test/core/compile-fail/private_fields.cpp create mode 100644 3rd/pfr/test/core/compile-fail/protected_fields.cpp create mode 100644 3rd/pfr/test/core/compile-fail/rvalue_tie.cpp create mode 100644 3rd/pfr/test/core/compile-fail/virtual_functions.cpp create mode 100644 3rd/pfr/test/core/loophole_detection.cpp create mode 100644 3rd/pfr/test/core/offset_based_getter.cpp create mode 100644 3rd/pfr/test/core/run/bitfields_count.cpp create mode 100644 3rd/pfr/test/core/run/constexpr_ops.cpp create mode 100644 3rd/pfr/test/core/run/core17_generated.cpp create mode 100644 3rd/pfr/test/core/run/destructuring_tie.cpp create mode 100644 3rd/pfr/test/core/run/error_pfr_c1202.cpp create mode 100644 3rd/pfr/test/core/run/fields_count_on_const.cpp create mode 100644 3rd/pfr/test/core/run/for_each_field.cpp create mode 100644 3rd/pfr/test/core/run/functions_for.cpp create mode 100644 3rd/pfr/test/core/run/get_by_type.cpp create mode 100644 3rd/pfr/test/core/run/get_const_field.cpp create mode 100644 3rd/pfr/test/core/run/get_non_default_constructible.cpp create mode 100644 3rd/pfr/test/core/run/get_rvalue.cpp create mode 100644 3rd/pfr/test/core/run/is_implicitly_reflectable.cpp create mode 100644 3rd/pfr/test/core/run/is_reflectable.cpp create mode 100644 3rd/pfr/test/core/run/issue30.cpp create mode 100644 3rd/pfr/test/core/run/issue33.cpp create mode 100644 3rd/pfr/test/core/run/motivating_example.cpp create mode 100644 3rd/pfr/test/core/run/motivating_example2.cpp create mode 100644 3rd/pfr/test/core/run/non_copyable_but_movable.cpp create mode 100644 3rd/pfr/test/core/run/non_dc_non_cop_but_mov.cpp create mode 100644 3rd/pfr/test/core/run/non_default_constructible.cpp create mode 100644 3rd/pfr/test/core/run/non_movable.cpp create mode 100644 3rd/pfr/test/core/run/non_std_layout.cpp create mode 100644 3rd/pfr/test/core/run/ops.cpp create mode 100644 3rd/pfr/test/core/run/optional_chrono.cpp create mode 100644 3rd/pfr/test/core/run/optional_like.cpp create mode 100644 3rd/pfr/test/core/run/read_write.cpp create mode 100644 3rd/pfr/test/core/run/read_write_non_literal.cpp create mode 100644 3rd/pfr/test/core/run/std_interactions.cpp create mode 100644 3rd/pfr/test/core/run/template_constructor.cpp create mode 100644 3rd/pfr/test/core/run/template_forwarding_ref.cpp create mode 100644 3rd/pfr/test/core/run/template_unconstrained.cpp create mode 100644 3rd/pfr/test/core/run/tie_anonymous.cpp create mode 100644 3rd/pfr/test/core/run/tie_anonymous_const_field.cpp create mode 100644 3rd/pfr/test/core/run/tuple_size.cpp create mode 100644 3rd/pfr/test/core/test_tuple_sizes_on.cpp create mode 100644 3rd/pfr/test/core_name/Jamfile.v2 create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_could_not_detect_compiler.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_disabled_via_macro_00.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_disabled_via_macro_01.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_get_name_on_array.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_get_name_on_union.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_misconfigured_compiler.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_names_as_array_on_array.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_names_as_array_on_union.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/fields_names_wrongly_configured_compiler.cpp create mode 100644 3rd/pfr/test/core_name/compile-fail/poor_fields_name.cpp create mode 100644 3rd/pfr/test/core_name/cxx20_address_of_non_static_member_tplarg_detection.cpp create mode 100644 3rd/pfr/test/core_name/cxx20_nontype_tplarg_detection.cpp create mode 100644 3rd/pfr/test/core_name/print_name.cpp create mode 100644 3rd/pfr/test/core_name/run/fields_names.cpp create mode 100644 3rd/pfr/test/core_name/run/fields_names_big.cpp create mode 100644 3rd/pfr/test/core_name/run/fields_names_constexpr.cpp create mode 100644 3rd/pfr/test/core_name/run/fields_names_internal_parser.cpp create mode 100644 3rd/pfr/test/core_name/run/fields_names_nonascii.cpp delete mode 100644 Core/system.zip diff --git a/3rd/magic_enum/export.h b/3rd/magic_enum/export.h index 3c606c1..dd19801 100644 --- a/3rd/magic_enum/export.h +++ b/3rd/magic_enum/export.h @@ -14,6 +14,54 @@ namespace Psc { + template + class Copyable_Atomic { + public: + using value_type = T; + Copyable_Atomic() = default; + Copyable_Atomic(T value) : value_(value) {} + Copyable_Atomic(const Copyable_Atomic& other) : value_(other.load()) {} + Copyable_Atomic& operator=(const Copyable_Atomic& other) { + store(other.load()); + return *this; + } + + Copyable_Atomic& operator=(T value) { + store(value); + return *this; + } + T load(std::memory_order order = std::memory_order_seq_cst) const { + return value_.load(order); + } + void store(T value, std::memory_order order = std::memory_order_seq_cst) { + value_.store(value, order); + } + operator T() const { + return load(); + } + private: + std::atomic value_{}; + }; + + template + using clean_t = std::remove_cv_t>; + + namespace PV { + template struct is_copyable_atomic_helper : std::false_type {}; + template struct is_copyable_atomic_helper> : std::true_type {}; + template struct is_copyable_atomic : is_copyable_atomic_helper> {}; + template struct copyable_atomic_value; + template struct copyable_atomic_value> { + using type = U; + }; + } + + template + constexpr bool is_copyable_atomic_v = PV::is_copyable_atomic::value; + + template + using copyable_atomic_value_t = typename PV::copyable_atomic_value>::type; + template struct always_false : std::false_type {}; template using clean_t = std::remove_cv_t>; namespace PV { @@ -165,10 +213,12 @@ namespace Psc { else if constexpr (std::is_arithmetic_v) { return std::to_string(v); // 使用 std::to_string 转换数值类型 } - else if constexpr (is_atomic_v) { return to_string(v.load()); } + else if constexpr (is_copyable_atomic_v) { + return to_string(v.load()); + } else if constexpr (is_optional_v) { return v.has_value() ? to_string(v.value()) : "nullopt"; } diff --git a/3rd/pfr/.gitattributes b/3rd/pfr/.gitattributes new file mode 100644 index 0000000..20e6a8c --- /dev/null +++ b/3rd/pfr/.gitattributes @@ -0,0 +1,97 @@ +* text=auto !eol svneol=native#text/plain +*.gitattributes text svneol=native#text/plain + +# Scriptish formats +*.bat text svneol=native#text/plain +*.bsh text svneol=native#text/x-beanshell +*.cgi text svneol=native#text/plain +*.cmd text svneol=native#text/plain +*.js text svneol=native#text/javascript +*.php text svneol=native#text/x-php +*.pl text svneol=native#text/x-perl +*.pm text svneol=native#text/x-perl +*.py text svneol=native#text/x-python +*.sh eol=lf svneol=LF#text/x-sh +configure eol=lf svneol=LF#text/x-sh + +# Image formats +*.bmp binary svneol=unset#image/bmp +*.gif binary svneol=unset#image/gif +*.ico binary svneol=unset#image/ico +*.jpeg binary svneol=unset#image/jpeg +*.jpg binary svneol=unset#image/jpeg +*.png binary svneol=unset#image/png +*.tif binary svneol=unset#image/tiff +*.tiff binary svneol=unset#image/tiff +*.svg text svneol=native#image/svg%2Bxml + +# Data formats +*.pdf binary svneol=unset#application/pdf +*.avi binary svneol=unset#video/avi +*.doc binary svneol=unset#application/msword +*.dsp text svneol=crlf#text/plain +*.dsw text svneol=crlf#text/plain +*.eps binary svneol=unset#application/postscript +*.gz binary svneol=unset#application/gzip +*.mov binary svneol=unset#video/quicktime +*.mp3 binary svneol=unset#audio/mpeg +*.ppt binary svneol=unset#application/vnd.ms-powerpoint +*.ps binary svneol=unset#application/postscript +*.psd binary svneol=unset#application/photoshop +*.rdf binary svneol=unset#text/rdf +*.rss text svneol=unset#text/xml +*.rtf binary svneol=unset#text/rtf +*.sln text svneol=native#text/plain +*.swf binary svneol=unset#application/x-shockwave-flash +*.tgz binary svneol=unset#application/gzip +*.vcproj text svneol=native#text/xml +*.vcxproj text svneol=native#text/xml +*.vsprops text svneol=native#text/xml +*.wav binary svneol=unset#audio/wav +*.xls binary svneol=unset#application/vnd.ms-excel +*.zip binary svneol=unset#application/zip + +# Text formats +.htaccess text svneol=native#text/plain +*.bbk text svneol=native#text/xml +*.cmake text svneol=native#text/plain +*.css text svneol=native#text/css +*.dtd text svneol=native#text/xml +*.htm text svneol=native#text/html +*.html text svneol=native#text/html +*.ini text svneol=native#text/plain +*.log text svneol=native#text/plain +*.mak text svneol=native#text/plain +*.qbk text svneol=native#text/plain +*.rst text svneol=native#text/plain +*.sql text svneol=native#text/x-sql +*.txt text svneol=native#text/plain +*.xhtml text svneol=native#text/xhtml%2Bxml +*.xml text svneol=native#text/xml +*.xsd text svneol=native#text/xml +*.xsl text svneol=native#text/xml +*.xslt text svneol=native#text/xml +*.xul text svneol=native#text/xul +*.yml text svneol=native#text/plain +boost-no-inspect text svneol=native#text/plain +CHANGES text svneol=native#text/plain +COPYING text svneol=native#text/plain +INSTALL text svneol=native#text/plain +Jamfile text svneol=native#text/plain +Jamroot text svneol=native#text/plain +Jamfile.v2 text svneol=native#text/plain +Jamrules text svneol=native#text/plain +Makefile* text svneol=native#text/plain +README text svneol=native#text/plain +TODO text svneol=native#text/plain + +# Code formats +*.c text svneol=native#text/plain +*.cpp text svneol=native#text/plain +*.h text svneol=native#text/plain +*.hpp text svneol=native#text/plain +*.ipp text svneol=native#text/plain +*.pp text svneol=native#text/plain +*.tpp text svneol=native#text/plain +*.jam text svneol=native#text/plain +*.java text svneol=native#text/plain diff --git a/3rd/pfr/.github/workflows/ci.yml b/3rd/pfr/.github/workflows/ci.yml new file mode 100644 index 0000000..c7b41ea --- /dev/null +++ b/3rd/pfr/.github/workflows/ci.yml @@ -0,0 +1,190 @@ +name: CI + +on: + pull_request: + push: + branches: + - master + - develop + - feature/** + +env: + UBSAN_OPTIONS: print_stacktrace=1 + +jobs: + posix: + strategy: + fail-fast: false + matrix: + include: + - toolset: gcc-12 # Do not remove! It is the only toolset that tests misc/strip_boost_namespace.sh + cxxstd: "03,11,14,17,2a" + os: ubuntu-22.04 + cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined" + linkflags: "linkflags=--coverage -lasan -lubsan" + gcov_tool: "gcov-12" + - toolset: gcc-11 + cxxstd: "03,11,14,17,2a" + os: ubuntu-22.04 + cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined" + linkflags: "linkflags=--coverage -lasan -lubsan" + gcov_tool: "gcov-11" + - toolset: gcc-10 + cxxstd: "03,11,14,17,2a" + os: ubuntu-22.04 + cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined" + linkflags: "linkflags=--coverage -lasan -lubsan" + gcov_tool: "gcov-10" + - toolset: gcc-9 + cxxstd: "03,11,14,17,2a" + os: ubuntu-22.04 + cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined" + linkflags: "linkflags=--coverage -lasan -lubsan" + gcov_tool: "gcov-9" + - toolset: clang-14 + cxxstd: "03,11,14,17,20" + os: ubuntu-22.04 + - toolset: clang-13 + cxxstd: "03,11,14,17,20" + os: ubuntu-22.04 + # - toolset: clang + # cxxstd: "03,11,14,17,2a" + # os: macos-10.15 + # cxxflags: "cxxflags=-fsanitize=address,undefined -fno-sanitize-recover=undefined" + # linkflags: "linkflags=-fsanitize=address,undefined" + + runs-on: ${{matrix.os}} + + steps: + - uses: actions/checkout@v2 + + - name: Install packages + if: matrix.install + run: sudo apt install ${{matrix.install}} + + - name: Setup Boost + run: | + echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY + LIBRARY=pfr # Note: changed from ${GITHUB_REPOSITORY#*/} + echo LIBRARY: $LIBRARY + echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV + echo GITHUB_BASE_REF: $GITHUB_BASE_REF + echo GITHUB_REF: $GITHUB_REF + REF=${GITHUB_BASE_REF:-$GITHUB_REF} + REF=${REF#refs/heads/} + echo REF: $REF + BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true + echo BOOST_BRANCH: $BOOST_BRANCH + cd .. + git clone -b $BOOST_BRANCH --depth 10 https://github.com/boostorg/boost.git boost-root + cd boost-root + git submodule update --init --depth 10 --jobs 2 tools/boostdep tools/inspect libs/filesystem + python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 3" filesystem + rm -rf libs/$LIBRARY/* + cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY + python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--depth 10 --jobs 3" $LIBRARY + ./bootstrap.sh + ./b2 -d0 headers + ./b2 -j4 variant=debug tools/inspect/build + + - name: Run tests + run: | + cd ../boost-root + ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release "${{matrix.cxxflags}}" "${{matrix.linkflags}}" "${{matrix.launcher}}" + dist/bin/inspect libs/$LIBRARY + + - name: Test boost namespace stripping + if: ${{matrix.toolset == 'gcc-12'}} + run: ../boost-root/libs/$LIBRARY/misc/strip_boost_namespace.sh + + - name: Prepare coverage data + if: matrix.gcov_tool + run: | + mkdir -p $GITHUB_WORKSPACE/coveralls + + echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh + chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh + wget https://github.com/linux-test-project/lcov/archive/v1.16.zip + unzip v1.16.zip + LCOV="`pwd`/lcov-1.16/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh" + + echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info" + $LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info + $LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info "/usr*" "*/$LIBRARY/test/*" ${{matrix.ignore_coverage}} "*/$LIBRARY/tests/*" "*/$LIBRARY/examples/*" "*/$LIBRARY/example/*" -o $GITHUB_WORKSPACE/coveralls/coverage.info + + cd ../boost-root + OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$LIBRARY\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'` + echo $OTHER_LIBS + eval "$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info $OTHER_LIBS -o $GITHUB_WORKSPACE/coveralls/coverage.info" + + - name: Coveralls + uses: coverallsapp/github-action@master + if: matrix.gcov_tool + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + path-to-lcov: ./coveralls/coverage.info + parallel: true + + windows: + strategy: + fail-fast: false + matrix: + include: + - toolset: msvc-14.0 + cxxstd: "14,latest" + addrmd: 32,64 + os: windows-2019 + threads: "-j3" + - toolset: gcc + cxxstd: "03,11,14,17,2a" + addrmd: 64 + os: windows-2019 + threads: "-j3" + - toolset: msvc-14.3 + cxxstd: "20,latest" + addrmd: 64 + os: windows-2022 + threads: "-j1" + + runs-on: ${{matrix.os}} + + steps: + - uses: actions/checkout@v2 + + - name: Setup Boost + shell: cmd + run: | + echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY% + set LIBRARY=pfr + echo LIBRARY: %LIBRARY% + echo LIBRARY=%LIBRARY%>>%GITHUB_ENV% + echo GITHUB_BASE_REF: %GITHUB_BASE_REF% + echo GITHUB_REF: %GITHUB_REF% + if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF% + set BOOST_BRANCH=develop + for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master + echo BOOST_BRANCH: %BOOST_BRANCH% + cd .. + git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git boost-root + cd boost-root + xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\ + git submodule update --init tools/boostdep + python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--jobs 3" %LIBRARY% + cmd /c bootstrap + b2 -d0 headers + + - name: Run tests + shell: cmd + run: | + cd ../boost-root + b2 ${{matrix.threads}} libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release + + finish: + needs: posix + runs-on: ubuntu-latest + steps: + - name: Coveralls Finished + uses: coverallsapp/github-action@master + with: + github-token: ${{ secrets.github_token }} + parallel-finished: true diff --git a/3rd/pfr/.gitignore b/3rd/pfr/.gitignore new file mode 100644 index 0000000..8009751 --- /dev/null +++ b/3rd/pfr/.gitignore @@ -0,0 +1,2 @@ +doc/autodoc* +doc/html diff --git a/3rd/pfr/CMakeLists.txt b/3rd/pfr/CMakeLists.txt new file mode 100644 index 0000000..d8a636f --- /dev/null +++ b/3rd/pfr/CMakeLists.txt @@ -0,0 +1,20 @@ +# Generated by `boostdep --cmake pfr` +# Copyright 2020 Peter Dimov +# Distributed under the Boost Software License, Version 1.0. +# https://www.boost.org/LICENSE_1_0.txt + +cmake_minimum_required(VERSION 3.5...3.16) + +project(boost_pfr VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX) + +add_library(boost_pfr INTERFACE) +add_library(Boost::pfr ALIAS boost_pfr) + +target_include_directories(boost_pfr INTERFACE include) + +if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt") + + add_subdirectory(test) + +endif() + diff --git a/3rd/pfr/LICENSE_1_0.txt b/3rd/pfr/LICENSE_1_0.txt new file mode 100644 index 0000000..36b7cd9 --- /dev/null +++ b/3rd/pfr/LICENSE_1_0.txt @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +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, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/3rd/pfr/README.md b/3rd/pfr/README.md new file mode 100644 index 0000000..5daac19 --- /dev/null +++ b/3rd/pfr/README.md @@ -0,0 +1,158 @@ +# [Boost.PFR](https://boost.org/libs/pfr) + +This is a C++14 library for very basic reflection that gives you access to structure elements by index and provides other `std::tuple` like methods for user defined types without any macro or boilerplate code. + +[Boost.PFR](https://boost.org/libs/pfr) is a part of the [Boost C++ Libraries](https://github.com/boostorg). However, Boost.PFR is a header only library that does not depend on Boost. You can just copy the content of the "include" folder from the github into your project, and the library will work fine. + +For a version of the library without `boost::` namespace see [PFR](https://github.com/apolukhin/pfr_non_boost). + +### Test results + +Branches | Build | Tests coverage | More info +----------------|-------------- | -------------- |----------- +Develop: | [![CI](https://github.com/boostorg/pfr/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/pfr/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/0mavmnkdmltcdmqa/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/pfr/branch/develop) | [![Coverage Status](https://coveralls.io/repos/github/apolukhin/magic_get/badge.png?branch=develop)](https://coveralls.io/github/apolukhin/magic_get?branch=develop) | [details...](https://www.boost.org/development/tests/develop/developer/pfr.html) +Master: | [![CI](https://github.com/boostorg/pfr/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/pfr/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/0mavmnkdmltcdmqa/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/pfr/branch/master) | [![Coverage Status](https://coveralls.io/repos/github/apolukhin/magic_get/badge.png?branch=master)](https://coveralls.io/github/apolukhin/magic_get?branch=master) | [details...](https://www.boost.org/development/tests/master/developer/pfr.html) + +[Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html) + +### Motivating Example #0 +```c++ +#include +#include +#include + +#include "boost/pfr.hpp" + +struct some_person { + std::string name; + unsigned birth_year; +}; + +int main(int argc, const char* argv[]) { + some_person val{"Edgar Allan Poe", 1809}; + + std::cout << boost::pfr::get<0>(val) // No macro! + << " was born in " << boost::pfr::get<1>(val); // Works with any aggregate initializables! + + if (argc > 1) { + std::ofstream ofs(argv[1]); + ofs << boost::pfr::io(val); // File now contains: {"Edgar Allan Poe", 1809} + } +} +``` +Outputs: +``` +Edgar Allan Poe was born in 1809 +``` + +[Run the above sample](https://godbolt.org/z/PfYsWKb7v) + + +### Motivating Example #1 +```c++ +#include +#include "boost/pfr.hpp" + +struct my_struct { // no ostream operator defined! + int i; + char c; + double d; +}; + +int main() { + my_struct s{100, 'H', 3.141593}; + std::cout << "my_struct has " << boost::pfr::tuple_size::value + << " fields: " << boost::pfr::io(s) << "\n"; +} + +``` + +Outputs: +``` +my_struct has 3 fields: {100, H, 3.14159} +``` + +### Motivating Example #2 + +```c++ +#include +#include "boost/pfr.hpp" + +struct my_struct { // no ostream operator defined! + std::string s; + int i; +}; + +int main() { + my_struct s{{"Das ist fantastisch!"}, 100}; + std::cout << "my_struct has " << boost::pfr::tuple_size::value + << " fields: " << boost::pfr::io(s) << "\n"; +} + +``` + +Outputs: +``` +my_struct has 2 fields: {"Das ist fantastisch!", 100} +``` + +### Motivating Example #3 + +```c++ +#include +#include + +#include +#include +#include + +#include "boost/pfr/io.hpp" + +namespace x3 = boost::spirit::x3; + +struct ast_employee { // No BOOST_FUSION_ADAPT_STRUCT defined + int age; + std::string forename; + std::string surname; + double salary; +}; + +auto const quoted_string = x3::lexeme['"' >> +(x3::ascii::char_ - '"') >> '"']; + +x3::rule const employee = "employee"; +auto const employee_def = + x3::lit("employee") + >> '{' + >> x3::int_ >> ',' + >> quoted_string >> ',' + >> quoted_string >> ',' + >> x3::double_ + >> '}' + ; +BOOST_SPIRIT_DEFINE(employee); + +int main() { + std::string str = R"(employee{34, "Chip", "Douglas", 2500.00})"; + ast_employee emp; + x3::phrase_parse(str.begin(), + str.end(), + employee, + x3::ascii::space, + emp); + std::cout << boost::pfr::io(emp) << std::endl; +} + +``` +Outputs: +``` +(34 Chip Douglas 2500) +``` + + +### Requirements and Limitations + +[See docs](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html). + +### License + +Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt). diff --git a/3rd/pfr/doc/Jamfile.v2 b/3rd/pfr/doc/Jamfile.v2 new file mode 100644 index 0000000..078881e --- /dev/null +++ b/3rd/pfr/doc/Jamfile.v2 @@ -0,0 +1,72 @@ +# Copyright Antony Polukhin 2016-2019. +# Use, modification, and distribution are +# subject to the Boost Software License, Version 1.0. (See accompanying +# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +using quickbook ; +using boostbook ; +using doxygen ; +using xsltproc ; + +import set ; +import doxygen ; +import xsltproc ; +import notfile ; +import path ; + +project pfr/doc ; + +# +# Common params for doxygen +# + +local doxygen_params = + EXTRACT_ALL=NO + HIDE_UNDOC_MEMBERS=YES + EXTRACT_PRIVATE=NO + ENABLE_PREPROCESSING=YES + EXPAND_ONLY_PREDEF=YES + MACRO_EXPANSION=YES + INLINE_SIMPLE_STRUCTS=YES + SORT_MEMBER_DOCS=NO + "ALIASES= \\ + \"forcedlink{1}=\\xmlonly\\endxmlonly boost::pfr::\\1\\xmlonly\\endxmlonly\" \\ + \"podops=\\b See \\b Also : \\xmlonly\\endxmlonly 'Three ways of getting operators' \\xmlonly\\endxmlonly\" \\ + \"fnrefl=\\b See \\b Also : \\xmlonly\\endxmlonly 'Reflection of field names' \\xmlonly\\endxmlonly\" \\ + \"customio=\\b See \\b Also : \\xmlonly\\endxmlonly 'Custom printing of aggregates' \\xmlonly\\endxmlonly for info on how to implement your own manipulator with custom format.\" \\ + \"aggregate=\\xmlonly\\endxmlonly simple aggregate \\xmlonly\\endxmlonly\" \\ + " + "PREDEFINED= \\ + \"BOOST_PFR_DOXYGEN_INVOKED=1\" \\ + " + ; + +doxygen autodoc_pfr + : + [ glob ../../../boost/pfr.hpp ] + [ glob ../../../boost/pfr/*.hpp ] + : + $(doxygen_params) + "boost.doxygen.reftitle=Reference Section of PFR" + ; + +boostbook pfr-doc + : + pfr.qbk + : + autodoc_pfr + boost.root=https://www.boost.org/doc/libs/1_81_0 + #boost.root=../../../. + html.stylesheet=../../../../doc/src/boostbook.css + ; + +############################################################################### +alias boostdoc + : pfr-doc/docbook + : + : + : ; +explicit boostdoc ; +alias boostrelease ; +explicit boostrelease ; + diff --git a/3rd/pfr/doc/pfr.qbk b/3rd/pfr/doc/pfr.qbk new file mode 100644 index 0000000..131b30d --- /dev/null +++ b/3rd/pfr/doc/pfr.qbk @@ -0,0 +1,596 @@ +[library Boost.PFR + [quickbook 1.6] + [version 2.2] + [copyright 2016-2023 Antony Polukhin] + [category Language Features Emulation] + [license + Distributed under the Boost Software License, Version 1.0. + (See accompanying file LICENSE_1_0.txt or copy at + [@http://www.boost.org/LICENSE_1_0.txt]) + ] +] + +[section Intro] + +Boost.PFR is a C++14 library for a very basic reflection. It gives you access to structure elements by index and provides other `std::tuple` like methods for user defined types without macro or boilerplate code: + +[import ../example/motivating_example0.cpp] +[pfr_motivating_example] + +Experiment with the sample [@https://godbolt.org/z/PfYsWKb7v online]. +See [link boost_pfr.limitations_and_configuration [*limitations]]. + + +[h2 Usecase example] + +Imagine that you are writing the wrapper library for a database. Depending on the usage of Boost.PFR users code will look differently: + +[table:hand_made_vs_pfr_1 +[[ Without Boost.PFR ] [ With Boost.PFR ]] +[[ +``` +#include + +struct user_info { + std::int64_t id; + std::string name, email, login; +}; + +user_info retrieve_friend(std::string_view name) { + std::tuple info_tuple + = db::one_row_as( + "SELECT id, name, email, login FROM user_infos WHERE name=$0", + name + ); + + ///////////////////////////////////////////////////////////////////////////// + user_info info { + std::move(std::get<0>(info_tuple)), + std::move(std::get<1>(info_tuple)), + std::move(std::get<2>(info_tuple)), + std::move(std::get<3>(info_tuple)), + } + ///////////////////////////////////////////////////////////////////////////// + + auto friend_info = ask_user_for_friend(std::move(info)); + + db::insert( + "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)", + friend_info.id, ////////////////////////////////////////////////////// + friend_info.name, // Users are forced to enumerate fields because your + friend_info.email, // library can not iterate over the fields of a user + friend_info.login // provided structure + ); + + return friend_info; +} +``` +][ +``` +#include + +struct user_info { + std::int64_t id; + std::string name, email, login; +}; + +user_info retrieve_friend(std::string_view name) { + // With Boost.PFR you can put data directly into user provided structures + user_info info = db::one_row_as( + "SELECT id, name, email, login FROM user_infos WHERE name=$0", + name + ); + + ////////////////// No boilerplate code to move data around ////////////////// + + + + + + + ///////////////////////////////////////////////////////////////////////////// + + auto friend_info = ask_user_for_friend(std::move(info)); + + db::insert( + "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)", + friend_info ///////////////////////////////////////////////////////// + // Boost.PFR allows you to iterate over all the fields + // of a user provided structure + // + ); + + return friend_info; +} +``` +]] +] + +Otherwise your library could require a customization point for a user type: + + +[table:hand_made_vs_pfr_2 +[[ Without Boost.PFR ] [ With Boost.PFR ]] +[[ +``` +#include + +struct user_info { + std::int64_t id; + std::string name, email, login; +}; + +/// Customizations via hand-written code //////////////////////////////////////// +auto db_api_tie(user_info& ui) noexcept { + return std::tie(ui.id, ui.name, ui.email, ui.login); +} + +auto db_api_tie(const user_info& ui) noexcept { + return std::tie(ui.id, ui.name, ui.email, ui.login); +} +///////////////////////////////////////////////////////////////////////////////// +``` +][ +``` +#include + +struct user_info { + std::int64_t id; + std::string name, email, login; +}; + +//////// With Boost.PFR there's no need in hand written customizations ////////// + + + + + + + +///////////////////////////////////////////////////////////////////////////////// +``` +]] +] + + +Imagine that you are writing a serialization library. Serialization of user +provided structures (and nested structures) with Boost.PFR it is just as simple as: + +``` +void Write(Writer& writer, int value); +void Write(Writer& writer, std::string_view value); + +template +std::enable_if_t> Write(Writer& writer, const T& value) { + boost::pfr::for_each_field( + value, [&writer](const auto& field) { Write(writer, field); }); +} +``` + +With Boost.PFR the code is shorter, more readable and more pleasant to write. + +[note All the above examples were inspired by the Boost.PFR usage in [@https://github.com/userver-framework/userver 🐙 userver framework].] + + +[h2 Out of the box functionality ] + +Boost.PFR adds the following out-of-the-box functionality for aggregate initializable structures: + +* comparison functions +* heterogeneous comparators +* hash +* IO streaming +* access to members by index or type +* access to member's names by index +* member type retrieval +* methods for cooperation with `std::tuple` for members +* methods for cooperation with `std::array` for member's names +* methods to visit each field of the structure +* trait to detect potential ability to reflect type, and ability to override trait's decision in user-side code + +Boost.PFR is a header only library that does not depend on Boost. You can just copy the content of the "include" folder [@https://github.com/boostorg/pfr from the Boost.PFR github] into your project, and the library will work fine. For a version of the library without `boost::` namespace see [@https://github.com/apolukhin/pfr_non_boost PFR]. + +[caution Recommended C++ Standards are C++20 and above. C++17 completely enough for a user who doesn't want accessing name of structure member. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported] + +[endsect] + + +[section Short Examples for the Impatient] + +[import ../example/quick_examples.cpp] + + +[table:quick_examples +[[ Code snippet ] [ Reference: ]] +[ + [ [pfr_quick_examples_get] ] + [ [funcref boost::pfr::get] ] +][ + [ [pfr_quick_examples_get_name] ] + [ [funcref boost::pfr::get_name] ] +][ + [ [pfr_quick_examples_ops] ] + [ + + [headerref boost/pfr/ops.hpp Header boost/pfr/ops.hpp]: + + * [funcref boost::pfr::eq] + + * [funcref boost::pfr::ne] + + * [funcref boost::pfr::gt] + + * ... + + ] +][ + [ [pfr_quick_examples_for_each] ] + [ + [funcref boost::pfr::for_each_field] + + [funcref boost::pfr::io] + ] +][ + [ [pfr_quick_examples_functions_for] ] + [ [macroref BOOST_PFR_FUNCTIONS_FOR] ] +][ + [ [pfr_quick_examples_eq_fields] ] + [ + [headerref boost/pfr/ops_fields.hpp Header boost/pfr/ops_fields.hpp ]: + + * [funcref boost::pfr::eq_fields] + + * [funcref boost::pfr::ne_fields] + + * [funcref boost::pfr::gt_fields] + + * ... + + [headerref boost/pfr/io_fields.hpp Header boost/pfr/io_fields.hpp ] + + * [funcref boost::pfr::io_fields] + + ] +][ + [ [pfr_quick_examples_for_each_idx] ] + [ [funcref boost::pfr::for_each_field] ] +][ + [ [pfr_quick_examples_tuple_size] ] + [ [classref boost::pfr::tuple_size] ] +][ + [ [pfr_quick_examples_structure_to_tuple] ] + [ [funcref boost::pfr::structure_to_tuple] ] +][ + [ [pfr_quick_examples_structure_tie] ] + [ [funcref boost::pfr::structure_tie] ] +]] + + + +[endsect] + + +[section Tutorial] + +[import ../example/sample_printing.cpp] +[import ../example/get.cpp] +[import ../example/get_name.cpp] + + +[section Why tuples are bad and aggregates are more preferable?] + +`std::tuple` and `std::pair` are good for generic programming, however they have disadvantages. First of all, code that uses them becomes barely readable. Consider two definitions: + +[table:tuples_vs_aggregates +[[ Tuple ] [ Aggregate ]] +[[ +``` +using auth_info_tuple = std::tuple< + std::int64_t, // What does this integer represents? + std::int64_t, + std::time_t +>; +``` +][ +``` +struct auth_info_aggregate { + std::int64_t user_id; // Oh, now I see! + std::int64_t session_id; + std::time_t valid_till; +}; +``` +]] +] + +Definition via aggregate initializable structure is much more clear. Same story with usages: `return std::get<1>(value);` vs. `return value.session_id;`. + +Another advantage of aggregates is a more efficient copy, move construction and assignments. + +Because of the above issues some guidelines recommend to [*use aggregates instead of tuples]. However aggregates fail when it comes to the functional like programming. + +Boost.PFR library [*provides tuple like methods for aggregate initializable structures], making aggregates usable in contexts where only tuples were useful. + +[endsect] + +[section Accessing structure member by index] [pfr_example_get] [endsect] +[section Custom printing of aggregates] [pfr_sample_printing] [endsect] + + +[section Three ways of getting operators ] + +There are three ways to start using Boost.PFR hashing, comparison and streaming for type `T` in your code. Each method has its own drawbacks and suits own cases. + +[table:ops_comp Different approaches for operators + [[ Approach + ][ When to use + ][ Operators could be found by ADL ][ Works for local types ][ Usable locally, without affecting code from other scopes ][ Ignores implicit conversion operators ][ Respects user defined operators ]] + + [[ + [headerref boost/pfr/ops.hpp boost/pfr/ops.hpp: eq, ne, gt, lt, le, ge] + + [headerref boost/pfr/io.hpp boost/pfr/io.hpp: io] + ][ + Use when you need to compare values by provided for them operators or via field-by-field comparison. + ][ no ][ yes ][ yes ][ no ][ yes ]] + + [[ + [macroref BOOST_PFR_FUNCTIONS_FOR BOOST_PFR_FUNCTIONS_FOR(T)] + ][ + Use near the type definition to define the whole set of operators for your type. + ][ yes ][ no ][ no ][ yes for T ] [ no (compile time error) ]] + + [[ + [headerref boost/pfr/ops_fields.hpp boost/pfr/ops_fields.hpp: eq_fields, ne_fields, gt_fields, lt_fields, le_fields, ge_fields] + + [headerref boost/pfr/io.hpp boost/pfr/io_fields.hpp: io_fields] + ][ + Use to implement the required set of operators for your type. + ][ no ][ yes ][ yes ][ yes ][ yes ]] +] + +More detailed description follows: + +[*1. `eq, ne, gt, lt, le, ge, io` approach] + +This method is good if you're writing generic algorithms and need to use operators from Boost.PFR only if there are no operators defined for the type: + +``` +#include + +template +struct uniform_comparator_less { + bool operator()(const T& lhs, const T& rhs) const noexcept { + // If T has operator< or conversion operator then it is used. + return boost::pfr::lt(lhs, rhs); + } +}; +``` +This methods effects are local to the function. It works even for local types, like structures defined in functions. + + +[*2. BOOST_PFR_FUNCTIONS_FOR(T) approach] + +This method is good if you're writing a structure and wish to define operators for that structure. +``` +#include + +struct pair_like { + int first; + short second; +}; + +BOOST_PFR_FUNCTIONS_FOR(pair_like) // Defines operators + +// ... + +assert(pair_like{1, 2} < pair_like{1, 3}); +``` +Argument Dependant Lookup works well. `std::less` will find the operators for `struct pair_like`. [macroref BOOST_PFR_FUNCTIONS_FOR BOOST_PFR_FUNCTIONS_FOR(T)] +can not be used for local types. It does not respect conversion operators of `T`, so for example the following code +will output different values: +``` +#include + +struct empty { + operator std::string() { return "empty{}"; } +}; +// Uncomment to get different output: +// BOOST_PFR_FUNCTIONS_FOR(empty) + +// ... +std::cout << empty{}; // Outputs `empty{}` if BOOST_PFR_FUNCTIONS_FOR(empty) is commented out, '{}' otherwise. +``` + +[*3. `eq_fields, ne_fields, gt_fields, lt_fields, le_fields, ge_fields, io_fields` approach] + +This method is good if you're willing to provide only some operators for your type: + +``` +#include + +struct pair_like { + int first; + std::string second; +}; + +inline std::ostream& operator<<(std::ostream& os, const pair_like& x) { + return os << bost::pfr::io_fields(x); +} +``` + +All the `*_fields` functions do ignore user defined operators and work only with fields of a type. This makes them perfect for defining you own operators. + +[endsect] + + +[section Reflection of unions ] + +You could use tuple-like representation if a type contains union. But be sure that operations for union are manually defined: + +``` +#include + +union test_union { + int i; + float f; +}; + +inline bool operator==(test_union l, test_union r) noexcept; // Compile time error without this operator + +bool some_function(test_union f1, test_union f2) { + return boost::pfr::eq(f1, f2); // OK +} + +``` + +Reflection of unions is disabled in the Boost.PFR library for safety reasons. Alas, there's no way to find out [*active] member of a union and accessing an inactive member is an Undefined Behavior. For example, library could always return the first member, but ostreaming `u` in `union {char* c; long long ll; } u; u.ll= 1;` will crash your program with an invalid pointer dereference. + +Any attempt to reflect unions leads to a compile time error. In many cases a static assert is triggered that outputs the following message: + +``` +error: static_assert failed "====================> Boost.PFR: For safety reasons it is forbidden + to reflect unions. See `Reflection of unions` section in the docs for more info." +``` + +[endsect] + + +[section Reflection of field name ] + +[pfr_example_get_name] + +See [link boost_pfr.limitations_and_configuration [*Limitations and Configuration]]. + +[endsect] + +[endsect] + + +[section Limitations and Configuration] + +[caution Recommended C++ Standards are C++20 and above. C++17 completely enough for a user who doesn't want accessing name of structure member. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported. ] + +Boost.PFR library works with types that satisfy the requirements of `SimpleAggregate`: aggregate types without base classes, `const` fields, references, or C arrays: + +``` +struct simple_aggregate { // SimpleAggregate + std::string name; + int age; + boost::uuids::uuid uuid; +}; + +struct empty { // SimpleAggregate +}; + +struct aggregate : empty { // not a SimpleAggregate + std::string name; + int age; + boost::uuids::uuid uuid; +}; +``` +The library may work with aggregates that don't satisfy the requirements of `SimpleAggregate`, but the behavior tends to be non-portable. + +Boost.PFRs extraction of field name works with a `SimpleAggregate` with non-internal linkage (with aggregats that could be used as `extern T t;`). +Do not use this functionality with anonymous structures, local structures +or a structure defined inside anonymous namespace as the behavior tends to be non-portable. + + +[h2 Configuration Macro] + +By default Boost.PFR [*auto-detects your compiler abilities] and automatically defines the configuration macro into appropriate values. If you wish to override that behavior, just define: +[table:linkmacro Macros + [[Macro name] [Effect]] + [[*BOOST_PFR_USE_CPP17*] [Define to `1` if you wish to override Boost.PFR choice and use C++17 structured bindings for reflection. Define to `0` to override Boost.PFR choice and disable C++17 structured bindings usage.]] + [[*BOOST_PFR_USE_LOOPHOLE*] [Define to `1` if you wish to override Boost.PFR choice and exploit [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118 CWG 2118] for reflection. Define to `0` to override Boost.PFR choice and disable CWG 2118 usage.]] + [[*BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE*] [Define to `0` if you are hit by the template instantiation depth issues with `std::make_integer_sequence` and wish to use Boost.PFR version of that metafunction. Define to `1` to override Boost.PFR detection logic. ]] + [[*BOOST_PFR_HAS_GUARANTEED_COPY_ELISION*] [Define to `0` if your compiler does not implement C++17 guaranteed copy elision properly and fails to reflect aggregates with non-movable fields. Define to `1` to override Boost.PFR detection logic. ]] + [[*BOOST_PFR_ENABLE_IMPLICIT_REFLECTION*] [Define to `0` if you are hit by lots of non-effective choices made by implicitly reflection. Define to `1` to override Boost.PFR detection logic. ]] + [[*BOOST_PFR_CORE_NAME_ENABLED*] [On platforms where field name extraction is not supported, the 'boost/pfr/config.hpp' header defines the BOOST_PFR_CORE_NAME_ENABLED macro equal to 0. Defining this macro as 0 before including the header disables the ability to get a field name. ]] + [[*BOOST_PFR_FUNCTION_SIGNATURE*] [For known compilers defined to a compiler specific macro, that outputs the whole function signature including non-type template parameters. ]] + [[*BOOST_PFR_CORE_NAME_PARSING*] [Describes extraction of field name from BOOST_PFR_FUNCTION_SIGNATURE macro. See details below. ]] + [[*BOOST_PFR_ENABLED*] [On platforms where Boost.PFR is not supported, the `boost/pfr/config.hpp` header defines the BOOST_PFR_ENABLED macro equal to 0. Defining this macro as 0 before including the header disables the Boost.PFR library. ]] +] + + +[h2 Details on Limitations] + +The Boost.PFRs reflection has some limitations that depend on a C++ Standard and compiler capabilities: + +* Static variables are ignored +* T must be aggregate initializable without base classes +* if T contains C arrays then the result of reflection may differ depending on the C++ version and library configuration +* Additional limitations if [*BOOST_PFR_USE_CPP17 == 0]: + * Non of the member fields should have a template constructor from one parameter. + * Additional limitations if [*BOOST_PFR_USE_LOOPHOLE == 0]: + * T must be constexpr aggregate initializable and all its fields must be constexpr default constructible + * [funcref boost::pfr::get], [funcref boost::pfr::structure_to_tuple], [funcref boost::pfr::structure_tie], [headerref boost/pfr/core.hpp boost::pfr::tuple_element] require T to be a POD type with built-in types only. + +The Boost.PFRs extraction of field name has some limitations that depend on a C++ Standard and compiler capabilities: + +* T should be usable like `extern T t;`, i.e. has a non-internal linkage. + +[h2 Adjusting BOOST_PFR_CORE_NAME_PARSING] + +`BOOST_PFR_CORE_NAME_PARSING` is already set up for most of the popular compilers. You need to adjust it only +if some static_assert in the library complained on `BOOST_PFR_CORE_NAME_PARSING`. + +To do that: + +# Build `test/core_name/print_name.cpp` with your compiler and run it +# Define BOOST_PFR_CORE_NAME_PARSING to `(skip_at_begin, skip_at_end, "")`, where + * `skip_at_begin` is equal to characters count before the first occurrence of `user_defined_field` in output + * `skip_at_end` is equal to characters count after last occurrence of `user_defined_field` in output +# Check that `test/core_name/print_name.cpp` returns "user_defined_field" +# If it does not return `user_defined_field`, then define BOOST_PFR_CORE_NAME_PARSING to `(skip_at_begin, skip_at_end, "T = ")`, where + * `skip_at_begin` is equal to `skip_at_begin` at step 2 + * `skip_at_end` is equal to `skip_at_end` at step 2 + * `"T = "` is equal to characters that are right before the `user_defined_field` in output, use `backward("T = ")` to search for the occurange in the string from the right +# (optional, but highly recommended) [@https://github.com/boostorg/pfr/issues create ticket] with +feature request to add your compiler to supported compilers list. Include +parameters provided to `BOOST_PFR_CORE_NAME_PARSING` macro [*and] the initial output of `test/core_name/print_name.cpp`. + +[endsect] + +[section How it works] + +Short description: + +# at compile-time: use aggregate initialization to detect fields count in user-provided structure + * [*BOOST_PFR_USE_CPP17 == 1]: + # at compile-time: structured bindings are used to decompose a type `T` to known amount of fields + * [*BOOST_PFR_USE_CPP17 == 0 && BOOST_PFR_USE_LOOPHOLE == 1]: + # at compile-time: use aggregate initialization to detect fields count in user-provided structure + # at compile-time: make a structure that is convertible to anything and remember types it has been converted to during aggregate initialization of user-provided structure + # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure + # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step + # at run-time: get pointer to each field, knowing the structure address and each field offset + # at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure + * [*BOOST_PFR_USE_CPP17 == 0 && BOOST_PFR_USE_LOOPHOLE == 0]: + # at compile-time: let `I` be is an index of current field, it equals 0 + # at run-time: `T` is constructed and field `I` is aggregate initialized using a separate instance of structure that is convertible to anything [note Additional care is taken to make sure that all the information about `T` is available to the compiler and that operations on `T` have no side effects, so the compiler can optimize away the unnecessary temporary objects.] + # at compile-time: `I += 1` + # at compile-time: if `I` does not equal fields count goto step [~c.] from inside of the conversion operator of the structure that is convertible to anything + # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure + # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step + # at run-time: get pointer to each field, knowing the structure address and each field offset +# at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure + +Long description of some basics: [@https://youtu.be/UlNUNxLtBI0 Antony Polukhin: Better C++14 reflections]. +Long description of some basics of C++14 with [link boost_pfr.limitations_and_configuration [*BOOST_PFR_USE_LOOPHOLE == 0]]: [@https://youtu.be/abdeAew3gmQ Antony Polukhin: C++14 Reflections Without Macros, Markup nor External Tooling]. +Description of the [*BOOST_PFR_USE_LOOPHOLE == 1] technique by its inventor Alexandr Poltavsky [@http://alexpolt.github.io/type-loophole.html in his blog]. + +[endsect] + +[section Acknowledgements] + +Many thanks to Bruno Dutra for showing the technique to precisely reflect aggregate initializable type in C++14 [@https://github.com/boostorg/pfr/issues/5 Manual type registering/structured bindings might be unnecessary]. + +Many thanks to Alexandr Poltavsky for initial implementation the [*BOOST_PFR_USE_LOOPHOLE == 1] technique and for describing it [@http://alexpolt.github.io/type-loophole.html in his blog]. + +Many thanks to Chris Beck for implementing the detect-offsets-and-get-field-address functionality that avoids Undefined Behavior of reinterpret_casting layout compatible structures. + +Many thanks to the Boost people who participated in the formal review, especially to Benedek Thaler, Steven Watanabe and Andrzej Krzemienski. + +[endsect] + +[xinclude autodoc_pfr.xml] diff --git a/3rd/pfr/example/get.cpp b/3rd/pfr/example/get.cpp new file mode 100644 index 0000000..ce836a7 --- /dev/null +++ b/3rd/pfr/example/get.cpp @@ -0,0 +1,42 @@ +// Copyright 2016-2023 Antony Polukhin + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at .) + +//[pfr_example_get +/*` + The following example shows how to access structure fields by index using [funcref boost::pfr::get]. + + Let's define some structure: +*/ +#include + +struct foo { // defining structure + int some_integer; + char c; +}; + +/*` + We can access fields of that structure by index: +*/ +foo f {777, '!'}; +auto& r1 = boost::pfr::get<0>(f); // accessing field with index 0, returns reference to `foo::some_integer` +auto& r2 = boost::pfr::get<1>(f); // accessing field with index 1, returns reference to `foo::c` +//] [/pfr_example_get] + + +int main() { + if (r1 != 777) return 1; + if (r2 != '!') return 2; + + r1 = 42; + r2 = 'A'; + + if (r1 != 42) return 3; + if (r2 != 'A') return 4; + if (f.some_integer != 42) return 5; + if (f.c != 'A') return 6; + + return 0; +} diff --git a/3rd/pfr/example/get_name.cpp b/3rd/pfr/example/get_name.cpp new file mode 100644 index 0000000..0a62c13 --- /dev/null +++ b/3rd/pfr/example/get_name.cpp @@ -0,0 +1,43 @@ +// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// Initial implementation by Bela Schaum, https://github.com/schaumb +// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669 +// + +#include + +#if BOOST_PFR_CORE_NAME_ENABLED && BOOST_PFR_USE_CPP17 +//[pfr_example_get_name +/*` + Since C++20 it's possible to read name of a structure field by index using Boost.PFR library. + The following example shows how to do it using [funcref boost::pfr::get_name]. + + Let's define some structure: +*/ +#include + +struct foo { // defining structure + int some_integer; + char c; +}; + +/*` + We can access field's names of that structure by index: +*/ +constexpr std::string_view n1 = boost::pfr::get_name<0, foo>(); // returns "some_integer" +constexpr std::string_view n2 = boost::pfr::get_name<1, foo>(); // returns "c" +//] [/pfr_example_get_name] +#endif + +int main() { +#if BOOST_PFR_CORE_NAME_ENABLED && BOOST_PFR_USE_CPP17 + if (n1 != "some_integer") return 1; + if (n2 != "c") return 2; +#endif + + return 0; +} diff --git a/3rd/pfr/example/motivating_example0.cpp b/3rd/pfr/example/motivating_example0.cpp new file mode 100644 index 0000000..252a412 --- /dev/null +++ b/3rd/pfr/example/motivating_example0.cpp @@ -0,0 +1,26 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +//[pfr_motivating_example +#include +#include + +#include "boost/pfr.hpp" + +struct some_person { + std::string name; + unsigned birth_year; +}; + +int main() { + some_person val{"Edgar Allan Poe", 1809}; + + std::cout << boost::pfr::get<0>(val) // No macro! + << " was born in " << boost::pfr::get<1>(val); // Works with any aggregate initializables! + + std::cout << boost::pfr::io(val); // Outputs: {"Edgar Allan Poe", 1809} +} +//] diff --git a/3rd/pfr/example/quick_examples.cpp b/3rd/pfr/example/quick_examples.cpp new file mode 100644 index 0000000..8166641 --- /dev/null +++ b/3rd/pfr/example/quick_examples.cpp @@ -0,0 +1,207 @@ +// Copyright 2016-2023 Antony Polukhin + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at .) + +#include +#include +#include +#include + +#include +#include + +// boost-no-inspect +void test_examples() { + +#if BOOST_PFR_USE_CPP17 + { +//[pfr_quick_examples_ops + // Assert equality. + // Note that the equality operator for structure is not defined. + + struct test { + std::string f1; + std::string_view f2; + }; + + assert( + boost::pfr::eq(test{"aaa", "zomg"}, test{"aaa", "zomg"}) + ); +//] + } +#endif + + { +//[pfr_quick_examples_for_each + // Increment each field of the variable on 1 and + // output the content of the variable. + + struct test { + int f1; + long f2; + }; + + test var{42, 43}; + + boost::pfr::for_each_field(var, [](auto& field) { + field += 1; + }); + + // Outputs: {43, 44} + std::cout << boost::pfr::io(var); +//] + } + + { +//[pfr_quick_examples_for_each_idx + // Iterate over fields of a variable and output index and + // type of a variable. + + struct tag0{}; + struct tag1{}; + struct sample { + tag0 a; + tag1 b; + }; + + // Outputs: + // 0: tag0 + // 1: tag1 + boost::pfr::for_each_field(sample{}, [](const auto& field, std::size_t idx) { + std::cout << '\n' << idx << ": " + << boost::typeindex::type_id_runtime(field); + }); +//] + } + + + { +//[pfr_quick_examples_tuple_size + // Getting fields count of some structure + + struct some { int a,b,c,d,e; }; + + std::cout << "Fields count in structure: " + << boost::pfr::tuple_size::value // Outputs: 5 + << '\n'; +//] + } + + { +//[pfr_quick_examples_get + // Get field by index/type and assign new value to that field + + struct sample { + char c; + float f; + }; + + sample var{}; + boost::pfr::get<1>(var) = 42.01f; + boost::pfr::get(var) = 'A'; + + std::cout << var.c << var.f; // Outputs: A 42.01 +//] + } + + // Disabled from testing since it's unportable +#if 0 + { +//[pfr_quick_examples_get_name + // Get name of field by index + + struct sample { + int f1; + long f2; + }; + + std::cout << boost::pfr::get_name<0, sample>() + << boost::pfr::get_name<1, sample>(); // Outputs: f1 f2 +//] + } +#endif + +#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE + { +//[pfr_quick_examples_structure_to_tuple + // Getting a std::tuple of values from structures fields + + struct foo { int a, b; }; + struct other { + char c; + foo nested; + }; + + other var{'A', {3, 4}}; + std::tuple t = boost::pfr::structure_to_tuple(var); + assert(std::get<0>(t) == 'A'); + assert( + boost::pfr::eq(std::get<1>(t), foo{3, 4}) + ); +//] + } +#endif + +#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE + { +//[pfr_quick_examples_structure_tie + // Getting a std::tuple of references to structure fields + + struct foo { int a, b; }; + struct other { + char c; + foo f; + }; + + other var{'A', {14, 15}}; + std::tuple t = boost::pfr::structure_tie(var); + std::get<1>(t) = foo{1, 2}; + + std::cout << boost::pfr::io(var.f); // Outputs: {1, 2} +//] + } +#endif + +} // void test_examples() + +//[pfr_quick_examples_functions_for +// Define all the comparison and IO operators for my_structure type along +// with hash_value function. + +#include + +namespace my_namespace { + struct my_structure { + int a,b,c,d,e,f,g; + // ... + }; + BOOST_PFR_FUNCTIONS_FOR(my_structure) +} +//] + +//[pfr_quick_examples_eq_fields +// Define only the equality and inequality operators for my_eq_ne_structure. + +#include + +namespace my_namespace { + struct my_eq_ne_structure { + float a,b,c,d,e,f,g; + // ... + }; + + inline bool operator==(const my_eq_ne_structure& x, const my_eq_ne_structure& y) { + return boost::pfr::eq_fields(x, y); + } + + inline bool operator!=(const my_eq_ne_structure& x, const my_eq_ne_structure& y) { + return boost::pfr::ne_fields(x, y); + } +} +//] + +int main() { + test_examples(); +} diff --git a/3rd/pfr/example/sample_printing.cpp b/3rd/pfr/example/sample_printing.cpp new file mode 100644 index 0000000..fdbfe92 --- /dev/null +++ b/3rd/pfr/example/sample_printing.cpp @@ -0,0 +1,95 @@ +// Copyright 2016-2023 Antony Polukhin + +// Distributed under the Boost Software License, Version 1.0. +// (See the accompanying file LICENSE_1_0.txt +// or a copy at .) + +//[pfr_sample_printing +/*` + The following example shows how to write your own io-manipulator for printing: +*/ +#include +#include + +namespace my_ns { + +/// Usage: +/// struct foo {std::uint8_t a, b;}; +/// ... +/// std::cout << my_ns::my_io(foo{42, 22}); +/// +/// Output: 42, 22 +template +auto my_io(const T& value); + +namespace detail { + // Helpers to print individual values + template + void print_each(std::ostream& out, const T& v) { out << v; } + void print_each(std::ostream& out, std::uint8_t v) { out << static_cast(v); } + void print_each(std::ostream& out, std::int8_t v) { out << static_cast(v); } + + // Structure to keep a reference to value, that will be ostreamed lower + template + struct io_reference { + const T& value; + }; + + // Output each field of io_reference::value + template + std::ostream& operator<<(std::ostream& out, io_reference&& x) { + const char* sep = ""; + + boost::pfr::for_each_field(x.value, [&](const auto& v) { + out << std::exchange(sep, ", "); + detail::print_each(out, v); + }); + return out; + } +} + +// Definition: +template +auto my_io(const T& value) { + return detail::io_reference{value}; +} + +} // namespace my_ns +//] [/pfr_sample_printing] + + +#include +#include + +int main() { + struct foo {std::uint8_t a, b;}; + + std::ostringstream oss; + oss << my_ns::my_io(foo{42, 22}); + + if (oss.str() != "42, 22") { + return 1; + } + + struct two_big_strings { + std::string first; + std::string second; + }; + +#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE + const char* huge_string = "Some huge string that should not fit into std::string SSO." + "And by 'huge' I mean really HUGE string with multiple statements and a lot of periods........." + ; + + oss.str({}); + oss << my_ns::my_io(two_big_strings{ + huge_string, huge_string + }); + + if (oss.str() != huge_string + std::string(", ") + huge_string) { + return 2; + } +#endif + + return 0; +} diff --git a/3rd/pfr/include/boost/pfr.hpp b/3rd/pfr/include/boost/pfr.hpp new file mode 100644 index 0000000..8194ef4 --- /dev/null +++ b/3rd/pfr/include/boost/pfr.hpp @@ -0,0 +1,25 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_HPP +#define BOOST_PFR_HPP + +/// \file boost/pfr.hpp +/// Includes all the Boost.PFR headers + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_PFR_HPP diff --git a/3rd/pfr/include/boost/pfr/config.hpp b/3rd/pfr/include/boost/pfr/config.hpp new file mode 100644 index 0000000..9c778c1 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/config.hpp @@ -0,0 +1,148 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// Copyright (c) 2022 Denis Mikhailov +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_CONFIG_HPP +#define BOOST_PFR_CONFIG_HPP +#pragma once + +#if __cplusplus >= 201402L || (defined(_MSC_VER) && defined(_MSVC_LANG) && _MSC_VER > 1900) +#include // to get non standard platform macro definitions (__GLIBCXX__ for example) +#endif + +/// \file boost/pfr/config.hpp +/// Contains all the macros that describe Boost.PFR configuration, like BOOST_PFR_ENABLED +/// +/// \note This header file doesn't require C++14 Standard and supports all C++ compilers, even pre C++14 compilers (C++11, C++03...). + +// Reminder: +// * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????) +// * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017) +// * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) +// * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) + +#ifdef BOOST_PFR_NOT_SUPPORTED +# error Please, do not set BOOST_PFR_NOT_SUPPORTED value manually, use '-DBOOST_PFR_ENABLED=0' instead of it +#endif + +#if defined(_MSC_VER) +# if !defined(_MSVC_LANG) || _MSC_VER <= 1900 +# define BOOST_PFR_NOT_SUPPORTED 1 +# endif +#elif __cplusplus < 201402L +# define BOOST_PFR_NOT_SUPPORTED 1 +#endif + +#ifndef BOOST_PFR_USE_LOOPHOLE +# if defined(_MSC_VER) +# if _MSC_VER >= 1927 +# define BOOST_PFR_USE_LOOPHOLE 1 +# else +# define BOOST_PFR_USE_LOOPHOLE 0 +# endif +# elif defined(__clang_major__) && __clang_major__ >= 8 +# define BOOST_PFR_USE_LOOPHOLE 0 +# else +# define BOOST_PFR_USE_LOOPHOLE 1 +# endif +#endif + +#ifndef BOOST_PFR_USE_CPP17 +# ifdef __cpp_structured_bindings +# define BOOST_PFR_USE_CPP17 1 +# elif defined(_MSVC_LANG) +# if _MSVC_LANG >= 201703L +# define BOOST_PFR_USE_CPP17 1 +# else +# define BOOST_PFR_USE_CPP17 0 +# endif +# else +# define BOOST_PFR_USE_CPP17 0 +# endif +#endif + +#if (!BOOST_PFR_USE_CPP17 && !BOOST_PFR_USE_LOOPHOLE) +# if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works +# define BOOST_PFR_NOT_SUPPORTED 1 +# endif +#endif + +#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE +// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence +# if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101 +# define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1 +# elif defined(_MSC_VER) +# define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1 +//# elif other known working lib +# else +# define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0 +# endif +#endif + +#ifndef BOOST_PFR_HAS_GUARANTEED_COPY_ELISION +# if defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928) +# define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 1 +# else +# define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 0 +# endif +#endif + +#ifndef BOOST_PFR_ENABLE_IMPLICIT_REFLECTION +# if defined(__cpp_lib_is_aggregate) +# define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 1 +# else +// There is no way to detect potential ability to be reflectable without std::is_aggregare +# define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 0 +# endif +#endif + +#ifndef BOOST_PFR_CORE_NAME_ENABLED +# if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L)) +# if (defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911) \ + || (defined(__clang_major__) && __clang_major__ >= 12) +# define BOOST_PFR_CORE_NAME_ENABLED 1 +# else +# define BOOST_PFR_CORE_NAME_ENABLED 0 +# endif +# else +# define BOOST_PFR_CORE_NAME_ENABLED 0 +# endif +#endif + + +#ifndef BOOST_PFR_CORE_NAME_PARSING +# if defined(_MSC_VER) +# define BOOST_PFR_CORE_NAME_PARSING (sizeof("auto __cdecl boost::pfr::detail::name_of_field_impl<") - 1, sizeof(">(void) noexcept") - 1, backward("->")) +# elif defined(__clang__) +# define BOOST_PFR_CORE_NAME_PARSING (sizeof("auto boost::pfr::detail::name_of_field_impl() [MsvcWorkaround = ") - 1, sizeof("}]") - 1, backward(".")) +# elif defined(__GNUC__) +# define BOOST_PFR_CORE_NAME_PARSING (sizeof("consteval auto boost::pfr::detail::name_of_field_impl() [with MsvcWorkaround = ") - 1, sizeof(")]") - 1, backward("::")) +# else +// Default parser for other platforms... Just skip nothing! +# define BOOST_PFR_CORE_NAME_PARSING (0, 0, "") +# endif +#endif + +#if defined(__has_cpp_attribute) +# if __has_cpp_attribute(maybe_unused) +# define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]] +# endif +#endif + +#ifndef BOOST_PFR_MAYBE_UNUSED +# define BOOST_PFR_MAYBE_UNUSED +#endif + +#ifndef BOOST_PFR_ENABLED +# ifdef BOOST_PFR_NOT_SUPPORTED +# define BOOST_PFR_ENABLED 0 +# else +# define BOOST_PFR_ENABLED 1 +# endif +#endif + +#undef BOOST_PFR_NOT_SUPPORTED + +#endif // BOOST_PFR_CONFIG_HPP diff --git a/3rd/pfr/include/boost/pfr/core.hpp b/3rd/pfr/include/boost/pfr/core.hpp new file mode 100644 index 0000000..22a8c25 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/core.hpp @@ -0,0 +1,265 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_CORE_HPP +#define BOOST_PFR_CORE_HPP +#pragma once + +#include + +#include + +#include +#include +#include +#include +#include + +#include +#include // metaprogramming stuff + +#include + +/// \file boost/pfr/core.hpp +/// Contains all the basic tuple-like interfaces \forcedlink{get}, \forcedlink{tuple_size}, \forcedlink{tuple_element_t}, and others. +/// +/// \b Synopsis: + +namespace boost { namespace pfr { + +/// \brief Returns reference or const reference to a field with index `I` in \aggregate `val`. +/// Overload taking the type `U` returns reference or const reference to a field +/// with provided type `U` in \aggregate `val` if there's only one field of such type in `val`. +/// +/// \b Example: +/// \code +/// struct my_struct { int i, short s; }; +/// my_struct s {10, 11}; +/// +/// assert(boost::pfr::get<0>(s) == 10); +/// boost::pfr::get<1>(s) = 0; +/// +/// assert(boost::pfr::get(s) == 10); +/// boost::pfr::get(s) = 11; +/// \endcode +template +constexpr decltype(auto) get(const T& val) noexcept { + return detail::sequence_tuple::get( detail::tie_as_tuple(val) ); +} + +/// \overload get +template +constexpr decltype(auto) get(T& val +#if !BOOST_PFR_USE_CPP17 + , std::enable_if_t::value>* = nullptr +#endif +) noexcept { + return detail::sequence_tuple::get( detail::tie_as_tuple(val) ); +} + +#if !BOOST_PFR_USE_CPP17 +/// \overload get +template +constexpr auto get(T&, std::enable_if_t::value>* = nullptr) noexcept { + static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17"); + return 0; +} +#endif + + +/// \overload get +template +constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference::value>* = nullptr) noexcept { + return std::move(detail::sequence_tuple::get( detail::tie_as_tuple(val) )); +} + + +/// \overload get +template +constexpr const U& get(const T& val) noexcept { + return detail::sequence_tuple::get_by_type_impl( detail::tie_as_tuple(val) ); +} + + +/// \overload get +template +constexpr U& get(T& val +#if !BOOST_PFR_USE_CPP17 + , std::enable_if_t::value>* = nullptr +#endif +) noexcept { + return detail::sequence_tuple::get_by_type_impl( detail::tie_as_tuple(val) ); +} + +#if !BOOST_PFR_USE_CPP17 +/// \overload get +template +constexpr U& get(T&, std::enable_if_t::value>* = nullptr) noexcept { + static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17"); + return 0; +} +#endif + + +/// \overload get +template +constexpr U&& get(T&& val, std::enable_if_t< std::is_rvalue_reference::value>* = nullptr) noexcept { + return std::move(detail::sequence_tuple::get_by_type_impl( detail::tie_as_tuple(val) )); +} + + +/// \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T. +/// +/// \b Example: +/// \code +/// std::vector< boost::pfr::tuple_element<0, my_structure>::type > v; +/// \endcode +template +using tuple_element = detail::sequence_tuple::tuple_element()) ) >; + + +/// \brief Type of a field with index `I` in \aggregate `T`. +/// +/// \b Example: +/// \code +/// std::vector< boost::pfr::tuple_element_t<0, my_structure> > v; +/// \endcode +template +using tuple_element_t = typename tuple_element::type; + + +/// \brief Creates a `std::tuple` from fields of an \aggregate `val`. +/// +/// \b Example: +/// \code +/// struct my_struct { int i, short s; }; +/// my_struct s {10, 11}; +/// std::tuple t = boost::pfr::structure_to_tuple(s); +/// assert(get<0>(t) == 10); +/// \endcode +template +constexpr auto structure_to_tuple(const T& val) noexcept { + return detail::make_stdtuple_from_tietuple( + detail::tie_as_tuple(val), + detail::make_index_sequence< tuple_size_v >() + ); +} + + +/// \brief std::tie` like function that ties fields of a structure. +/// +/// \returns a `std::tuple` with lvalue and const lvalue references to fields of an \aggregate `val`. +/// +/// \b Example: +/// \code +/// void foo(const int&, const short&); +/// struct my_struct { int i, short s; }; +/// +/// const my_struct const_s{1, 2}; +/// std::apply(foo, boost::pfr::structure_tie(const_s)); +/// +/// my_struct s; +/// boost::pfr::structure_tie(s) = std::tuple{10, 11}; +/// assert(s.s == 11); +/// \endcode +template +constexpr auto structure_tie(const T& val) noexcept { + return detail::make_conststdtiedtuple_from_tietuple( + detail::tie_as_tuple(const_cast(val)), + detail::make_index_sequence< tuple_size_v >() + ); +} + + +/// \overload structure_tie +template +constexpr auto structure_tie(T& val +#if !BOOST_PFR_USE_CPP17 + , std::enable_if_t::value>* = nullptr +#endif +) noexcept { + return detail::make_stdtiedtuple_from_tietuple( + detail::tie_as_tuple(val), + detail::make_index_sequence< tuple_size_v >() + ); +} + +#if !BOOST_PFR_USE_CPP17 +/// \overload structure_tie +template +constexpr auto structure_tie(T&, std::enable_if_t::value>* = nullptr) noexcept { + static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on non const non assignable type is allowed only in C++17"); + return 0; +} +#endif + + +/// \overload structure_tie +template +constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference::value>* = nullptr) noexcept { + static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on rvalue references is forbidden"); + return 0; +} + +/// Calls `func` for each field of a `value`. +/// +/// \param func must have one of the following signatures: +/// * any_return_type func(U&& field) // field of value is perfect forwarded to function +/// * any_return_type func(U&& field, std::size_t i) +/// * any_return_type func(U&& value, I i) // Here I is an `std::integral_constant` +/// +/// \param value To each field of this variable will be the `func` applied. +/// +/// \b Example: +/// \code +/// struct my_struct { int i, short s; }; +/// int sum = 0; +/// boost::pfr::for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; }); +/// assert(sum == 42); +/// \endcode +template +constexpr void for_each_field(T&& value, F&& func) { + constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count>(); + + ::boost::pfr::detail::for_each_field_dispatcher( + value, + [f = std::forward(func)](auto&& t) mutable { + // MSVC related workaround. Its lambdas do not capture constexprs. + constexpr std::size_t fields_count_val_in_lambda + = boost::pfr::detail::fields_count>(); + + ::boost::pfr::detail::for_each_field_impl( + t, + std::forward(f), + detail::make_index_sequence{}, + std::is_rvalue_reference{} + ); + }, + detail::make_index_sequence{} + ); +} + +/// \brief std::tie-like function that allows assigning to tied values from aggregates. +/// +/// \returns an object with lvalue references to `args...`; on assignment of an \aggregate value to that +/// object each field of an aggregate is assigned to the corresponding `args...` reference. +/// +/// \b Example: +/// \code +/// auto f() { +/// struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 }; +/// return res; +/// } +/// auto [p, s] = f(); +/// boost::pfr::tie_from_structure(p, s) = f(); +/// \endcode +template +constexpr detail::tie_from_structure_tuple tie_from_structure(Elements&... args) noexcept { + return detail::tie_from_structure_tuple(args...); +} + +}} // namespace boost::pfr + +#endif // BOOST_PFR_CORE_HPP diff --git a/3rd/pfr/include/boost/pfr/core_name.hpp b/3rd/pfr/include/boost/pfr/core_name.hpp new file mode 100644 index 0000000..8b0d012 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/core_name.hpp @@ -0,0 +1,88 @@ +// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// Initial implementation by Bela Schaum, https://github.com/schaumb +// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669 +// + +#ifndef BOOST_PFR_CORE_NAME_HPP +#define BOOST_PFR_CORE_NAME_HPP +#pragma once + +#include + +#include + +#include +#include +#include + +#include // for std::size_t + +#include + +/// \file boost/pfr/core_name.hpp +/// Contains functions \forcedlink{get_name} and \forcedlink{names_as_array} to know which names each field of any \aggregate has. +/// +/// \fnrefl for details. +/// +/// \b Synopsis: + +namespace boost { namespace pfr { + +/// \brief Returns name of a field with index `I` in \aggregate `T`. +/// +/// \b Example: +/// \code +/// struct my_struct { int i, short s; }; +/// +/// assert(boost::pfr::get_name<0, my_struct>() == "i"); +/// assert(boost::pfr::get_name<1, my_struct>() == "s"); +/// \endcode +template +constexpr +#ifdef BOOST_PFR_DOXYGEN_INVOKED +std::string_view +#else +auto +#endif +get_name() noexcept { + return detail::get_name(); +} + +// FIXME: implement this +// template +// constexpr auto get_name() noexcept { +// return detail::sequence_tuple::get_by_type_impl( detail::tie_as_names_tuple() ); +// } + +/// \brief Creates a `std::array` from names of fields of an \aggregate `T`. +/// +/// \b Example: +/// \code +/// struct my_struct { int i, short s; }; +/// std::array a = boost::pfr::names_as_array(); +/// assert(a[0] == "i"); +/// \endcode +template +constexpr +#ifdef BOOST_PFR_DOXYGEN_INVOKED +std::array> +#else +auto +#endif +names_as_array() noexcept { + return detail::make_stdarray_from_tietuple( + detail::tie_as_names_tuple(), + detail::make_index_sequence< tuple_size_v >(), + 1L + ); +} + +}} // namespace boost::pfr + +#endif // BOOST_PFR_CORE_NAME_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/cast_to_layout_compatible.hpp b/3rd/pfr/include/boost/pfr/detail/cast_to_layout_compatible.hpp new file mode 100644 index 0000000..c9f440e --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/cast_to_layout_compatible.hpp @@ -0,0 +1,75 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP +#define BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP +#pragma once + +#include + +#include +#include // metaprogramming stuff +#include + +namespace boost { namespace pfr { namespace detail { + +template +constexpr void static_assert_layout_compatible() noexcept { + static_assert( + std::alignment_of::value == std::alignment_of::value, + "====================> Boost.PFR: Alignment check failed, probably your structure has user-defined alignment for the whole structure or for some of the fields." + ); + static_assert(sizeof(T) == sizeof(U), "====================> Boost.PFR: Size check failed, probably your structure has bitfields or user-defined alignment."); +} + +/// @cond +#ifdef __GNUC__ +#define MAY_ALIAS __attribute__((__may_alias__)) +#else +#define MAY_ALIAS +#endif +/// @endcond + +template +MAY_ALIAS const To& cast_to_layout_compatible(const From& val) noexcept { + MAY_ALIAS const To* const t = reinterpret_cast( std::addressof(val) ); + detail::static_assert_layout_compatible(); + return *t; +} + +template +MAY_ALIAS const volatile To& cast_to_layout_compatible(const volatile From& val) noexcept { + MAY_ALIAS const volatile To* const t = reinterpret_cast( std::addressof(val) ); + detail::static_assert_layout_compatible(); + return *t; +} + + +template +MAY_ALIAS volatile To& cast_to_layout_compatible(volatile From& val) noexcept { + MAY_ALIAS volatile To* const t = reinterpret_cast( std::addressof(val) ); + detail::static_assert_layout_compatible(); + return *t; +} + + +template +MAY_ALIAS To& cast_to_layout_compatible(From& val) noexcept { + MAY_ALIAS To* const t = reinterpret_cast( std::addressof(val) ); + detail::static_assert_layout_compatible(); + return *t; +} + +#ifdef BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING +template +To&& cast_to_layout_compatible(rvalue_t val) noexcept = delete; +#endif + +#undef MAY_ALIAS + + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP diff --git a/3rd/pfr/include/boost/pfr/detail/config.hpp b/3rd/pfr/include/boost/pfr/detail/config.hpp new file mode 100644 index 0000000..665e990 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/config.hpp @@ -0,0 +1,26 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// Copyright (c) 2022 Denis Mikhailov +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_DETAIL_CONFIG_HPP +#define BOOST_PFR_DETAIL_CONFIG_HPP +#pragma once + +#include + +#if !BOOST_PFR_ENABLED + +#error Boost.PFR library is not supported in your environment. \ + Try one of the possible solutions: \ + 1. try to take away an '-DBOOST_PFR_ENABLED=0', if it exists \ + 2. enable C++14; \ + 3. enable C++17; \ + 4. update your compiler; \ + or disable this error by '-DBOOST_PFR_ENABLED=1' if you really know what are you doing. + +#endif // !BOOST_PFR_ENABLED + +#endif // BOOST_PFR_DETAIL_CONFIG_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/core.hpp b/3rd/pfr/include/boost/pfr/detail/core.hpp new file mode 100644 index 0000000..2815437 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core.hpp @@ -0,0 +1,24 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_DETAIL_CORE_HPP +#define BOOST_PFR_DETAIL_CORE_HPP +#pragma once + +#include + +// Each core provides `boost::pfr::detail::tie_as_tuple` and +// `boost::pfr::detail::for_each_field_dispatcher` functions. +// +// The whole PFR library is build on top of those two functions. +#if BOOST_PFR_USE_CPP17 +# include +#elif BOOST_PFR_USE_LOOPHOLE +# include +#else +# include +#endif + +#endif // BOOST_PFR_DETAIL_CORE_HPP diff --git a/3rd/pfr/include/boost/pfr/detail/core14_classic.hpp b/3rd/pfr/include/boost/pfr/detail/core14_classic.hpp new file mode 100644 index 0000000..fd349d9 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core14_classic.hpp @@ -0,0 +1,706 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP +#define BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP +#pragma once + +#include + +#include +#include // metaprogramming stuff + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wmissing-braces" +# pragma clang diagnostic ignored "-Wundefined-inline" +# pragma clang diagnostic ignored "-Wundefined-internal" +# pragma clang diagnostic ignored "-Wmissing-field-initializers" +#endif + +namespace boost { namespace pfr { namespace detail { + +///////////////////// General utility stuff + +template struct identity { + typedef T type; +}; + +template +constexpr T construct_helper() noexcept { // adding const here allows to deal with copyable only types + return {}; +} + +template constexpr size_array fields_count_and_type_ids_with_zeros() noexcept; +template constexpr auto flat_array_of_type_ids() noexcept; + +///////////////////// All the stuff for representing Type as integer and converting integer back to type +namespace typeid_conversions { + +///////////////////// Helper constants and typedefs + +#ifdef _MSC_VER +# pragma warning( push ) + // '<<': check operator precedence for possible error; use parentheses to clarify precedence +# pragma warning( disable : 4554 ) +#endif + +constexpr std::size_t native_types_mask = 31; +constexpr std::size_t bits_per_extension = 3; +constexpr std::size_t extension_mask = ( + static_cast((1 << bits_per_extension) - 1) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); +constexpr std::size_t native_ptr_type = ( + static_cast(1) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); +constexpr std::size_t native_const_ptr_type = ( + static_cast(2) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); + +constexpr std::size_t native_const_volatile_ptr_type = ( + static_cast(3) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); + +constexpr std::size_t native_volatile_ptr_type = ( + static_cast(4) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); + +constexpr std::size_t native_ref_type = ( + static_cast(5) + << static_cast(sizeof(std::size_t) * 8 - bits_per_extension) +); + +template +using if_extension = std::enable_if_t< (Index & extension_mask) == Extension >*; + +///////////////////// Helper functions +template +constexpr std::size_t type_to_id_extension_apply(std::size_t ext) noexcept { + constexpr std::size_t native_id = (Unptr & native_types_mask); + constexpr std::size_t extensions = (Unptr & ~native_types_mask); + static_assert( + !((extensions >> bits_per_extension) & native_types_mask), + "====================> Boost.PFR: Too many extensions for a single field (something close to `int************************** p;` is in the POD type)." + ); + + return (extensions >> bits_per_extension) | native_id | ext; +} + +template +using remove_1_ext = size_t_< + ((Index & ~native_types_mask) << bits_per_extension) | (Index & native_types_mask) +>; + +#ifdef _MSC_VER +# pragma warning( pop ) +#endif + +///////////////////// Forward declarations + +template constexpr std::size_t type_to_id(identity) noexcept; +template constexpr std::size_t type_to_id(identity) noexcept; +template constexpr std::size_t type_to_id(identity) noexcept; +template constexpr std::size_t type_to_id(identity) noexcept; +template constexpr std::size_t type_to_id(identity) noexcept; +template constexpr std::size_t type_to_id(identity, std::enable_if_t::value>* = nullptr) noexcept; +template constexpr std::size_t type_to_id(identity, std::enable_if_t::value>* = nullptr) noexcept; +template constexpr std::size_t type_to_id(identity, std::enable_if_t::value>* = nullptr) noexcept; +template constexpr size_array type_to_id(identity, std::enable_if_t::value && !std::is_empty::value && !std::is_union::value>* = 0) noexcept; + +template constexpr auto id_to_type(size_t_, if_extension = nullptr) noexcept; +template constexpr auto id_to_type(size_t_, if_extension = nullptr) noexcept; +template constexpr auto id_to_type(size_t_, if_extension = nullptr) noexcept; +template constexpr auto id_to_type(size_t_, if_extension = nullptr) noexcept; +template constexpr auto id_to_type(size_t_, if_extension = nullptr) noexcept; + + +///////////////////// Definitions of type_to_id and id_to_type for fundamental types +/// @cond +#define BOOST_MAGIC_GET_REGISTER_TYPE(Type, Index) \ + constexpr std::size_t type_to_id(identity) noexcept { \ + return Index; \ + } \ + constexpr Type id_to_type( size_t_ ) noexcept { \ + return detail::construct_helper(); \ + } \ + /**/ +/// @endcond + + +// Register all base types here +BOOST_MAGIC_GET_REGISTER_TYPE(unsigned char , 1) +BOOST_MAGIC_GET_REGISTER_TYPE(unsigned short , 2) +BOOST_MAGIC_GET_REGISTER_TYPE(unsigned int , 3) +BOOST_MAGIC_GET_REGISTER_TYPE(unsigned long , 4) +BOOST_MAGIC_GET_REGISTER_TYPE(unsigned long long , 5) +BOOST_MAGIC_GET_REGISTER_TYPE(signed char , 6) +BOOST_MAGIC_GET_REGISTER_TYPE(short , 7) +BOOST_MAGIC_GET_REGISTER_TYPE(int , 8) +BOOST_MAGIC_GET_REGISTER_TYPE(long , 9) +BOOST_MAGIC_GET_REGISTER_TYPE(long long , 10) +BOOST_MAGIC_GET_REGISTER_TYPE(char , 11) +BOOST_MAGIC_GET_REGISTER_TYPE(wchar_t , 12) +BOOST_MAGIC_GET_REGISTER_TYPE(char16_t , 13) +BOOST_MAGIC_GET_REGISTER_TYPE(char32_t , 14) +BOOST_MAGIC_GET_REGISTER_TYPE(float , 15) +BOOST_MAGIC_GET_REGISTER_TYPE(double , 16) +BOOST_MAGIC_GET_REGISTER_TYPE(long double , 17) +BOOST_MAGIC_GET_REGISTER_TYPE(bool , 18) +BOOST_MAGIC_GET_REGISTER_TYPE(void* , 19) +BOOST_MAGIC_GET_REGISTER_TYPE(const void* , 20) +BOOST_MAGIC_GET_REGISTER_TYPE(volatile void* , 21) +BOOST_MAGIC_GET_REGISTER_TYPE(const volatile void* , 22) +BOOST_MAGIC_GET_REGISTER_TYPE(std::nullptr_t , 23) +constexpr std::size_t tuple_begin_tag = 24; +constexpr std::size_t tuple_end_tag = 25; + +#undef BOOST_MAGIC_GET_REGISTER_TYPE + +///////////////////// Definitions of type_to_id and id_to_type for types with extensions and nested types +template +constexpr std::size_t type_to_id(identity) noexcept { + constexpr auto unptr = typeid_conversions::type_to_id(identity{}); + static_assert( + std::is_same::value, + "====================> Boost.PFR: Pointers to user defined types are not supported." + ); + return typeid_conversions::type_to_id_extension_apply(native_ptr_type); +} + +template +constexpr std::size_t type_to_id(identity) noexcept { + constexpr auto unptr = typeid_conversions::type_to_id(identity{}); + static_assert( + std::is_same::value, + "====================> Boost.PFR: Const pointers to user defined types are not supported." + ); + return typeid_conversions::type_to_id_extension_apply(native_const_ptr_type); +} + +template +constexpr std::size_t type_to_id(identity) noexcept { + constexpr auto unptr = typeid_conversions::type_to_id(identity{}); + static_assert( + std::is_same::value, + "====================> Boost.PFR: Const volatile pointers to user defined types are not supported." + ); + return typeid_conversions::type_to_id_extension_apply(native_const_volatile_ptr_type); +} + +template +constexpr std::size_t type_to_id(identity) noexcept { + constexpr auto unptr = typeid_conversions::type_to_id(identity{}); + static_assert( + std::is_same::value, + "====================> Boost.PFR: Volatile pointers to user defined types are not supported." + ); + return typeid_conversions::type_to_id_extension_apply(native_volatile_ptr_type); +} + +template +constexpr std::size_t type_to_id(identity) noexcept { + constexpr auto unptr = typeid_conversions::type_to_id(identity{}); + static_assert( + std::is_same::value, + "====================> Boost.PFR: References to user defined types are not supported." + ); + return typeid_conversions::type_to_id_extension_apply(native_ref_type); +} + +template +constexpr std::size_t type_to_id(identity, std::enable_if_t::value>*) noexcept { + return typeid_conversions::type_to_id(identity::type >{}); +} + +template +constexpr std::size_t type_to_id(identity, std::enable_if_t::value>*) noexcept { + static_assert(!std::is_empty::value, "====================> Boost.PFR: Empty classes/structures as members are not supported."); + return 0; +} + +template +constexpr std::size_t type_to_id(identity, std::enable_if_t::value>*) noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + return 0; +} + +template +constexpr size_array type_to_id(identity, std::enable_if_t::value && !std::is_empty::value && !std::is_union::value>*) noexcept { + constexpr auto t = detail::flat_array_of_type_ids(); + size_array result {{tuple_begin_tag}}; + constexpr bool requires_tuplening = ( + (t.count_nonzeros() != 1) || (t.count_nonzeros() == t.count_from_opening_till_matching_parenthis_seq(0, tuple_begin_tag, tuple_end_tag)) + ); + + if (requires_tuplening) { + for (std::size_t i = 0; i < t.size(); ++i) + result.data[i + 1] = t.data[i]; + result.data[result.size() - 1] = tuple_end_tag; + } else { + for (std::size_t i = 0; i < t.size(); ++i) + result.data[i] = t.data[i]; + } + return result; +} + + + +template +constexpr auto id_to_type(size_t_, if_extension) noexcept { + typedef decltype( typeid_conversions::id_to_type(remove_1_ext()) )* res_t; + return detail::construct_helper(); +} + +template +constexpr auto id_to_type(size_t_, if_extension) noexcept { + typedef const decltype( typeid_conversions::id_to_type(remove_1_ext()) )* res_t; + return detail::construct_helper(); +} + +template +constexpr auto id_to_type(size_t_, if_extension) noexcept { + typedef const volatile decltype( typeid_conversions::id_to_type(remove_1_ext()) )* res_t; + return detail::construct_helper(); +} + + +template +constexpr auto id_to_type(size_t_, if_extension) noexcept { + typedef volatile decltype( typeid_conversions::id_to_type(remove_1_ext()) )* res_t; + return detail::construct_helper(); +} + + +template +constexpr auto id_to_type(size_t_, if_extension) noexcept { + static_assert(!Index, "====================> Boost.PFR: References are not supported"); + return nullptr; +} + +} // namespace typeid_conversions + +///////////////////// Structure that remembers types as integers on a `constexpr operator Type()` call +struct ubiq_val { + std::size_t* ref_; + + template + constexpr void assign(const T& typeids) const noexcept { + for (std::size_t i = 0; i < T::size(); ++i) + ref_[i] = typeids.data[i]; + } + + constexpr void assign(std::size_t val) const noexcept { + ref_[0] = val; + } + + template + constexpr operator Type() const noexcept { + constexpr auto typeids = typeid_conversions::type_to_id(identity{}); + assign(typeids); + return detail::construct_helper(); + } +}; + +///////////////////// Structure that remembers size of the type on a `constexpr operator Type()` call +struct ubiq_sizes { + std::size_t& ref_; + + template + constexpr operator Type() const noexcept { + ref_ = sizeof(Type); + return detail::construct_helper(); + } +}; + +///////////////////// Returns array of (offsets without accounting alignments). Required for keeping places for nested type ids +template +constexpr size_array get_type_offsets() noexcept { + typedef size_array array_t; + array_t sizes{}; + T tmp{ ubiq_sizes{sizes.data[I]}... }; + (void)tmp; + + array_t offsets{{0}}; + for (std::size_t i = 1; i < N; ++i) + offsets.data[i] = offsets.data[i - 1] + sizes.data[i - 1]; + + return offsets; +} + +///////////////////// Returns array of typeids and zeros if constructor of a type accepts sizeof...(I) parameters +template +constexpr void* flat_type_to_array_of_type_ids(std::size_t* types, std::index_sequence) noexcept +{ + static_assert( + N <= sizeof(T), + "====================> Boost.PFR: Bit fields are not supported." + ); + + constexpr auto offsets = detail::get_type_offsets(); + T tmp{ ubiq_val{types + get(offsets) * 3}... }; + (void)types; + (void)tmp; + (void)offsets; // If type is empty offsets are not used + return nullptr; +} + +///////////////////// Returns array of typeids and zeros +template +constexpr size_array fields_count_and_type_ids_with_zeros() noexcept { + size_array types{}; + constexpr std::size_t N = detail::fields_count(); + detail::flat_type_to_array_of_type_ids(types.data, detail::make_index_sequence()); + return types; +} + +///////////////////// Returns array of typeids without zeros +template +constexpr auto flat_array_of_type_ids() noexcept { + constexpr auto types = detail::fields_count_and_type_ids_with_zeros(); + constexpr std::size_t count = types.count_nonzeros(); + size_array res{}; + std::size_t j = 0; + for (std::size_t i = 0; i < decltype(types)::size(); ++i) { + if (types.data[i]) { + res.data[j] = types.data[i]; + ++ j; + } + } + + return res; +} + +///////////////////// Convert array of typeids into sequence_tuple::tuple + +template +constexpr auto as_flat_tuple_impl(std::index_sequence) noexcept; + +template +constexpr sequence_tuple::tuple<> as_flat_tuple_impl(std::index_sequence<>) noexcept { + return sequence_tuple::tuple<>{}; +} + +template +constexpr auto increment_index_sequence(std::index_sequence) noexcept { + return std::index_sequence{}; +} + +template +constexpr auto prepare_subtuples(size_t_, size_t_, size_t_) noexcept { + static_assert(SubtupleLength == 0, "====================> Boost.PFR: Internal error while representing nested field as tuple"); + return typeid_conversions::id_to_type(size_t_{}); +} + +template +constexpr auto prepare_subtuples(size_t_, size_t_, size_t_) noexcept { + static_assert(sizeof(T) == 0, "====================> Boost.PFR: Internal error while representing nested field as tuple"); + return int{}; +} + +template +constexpr auto prepare_subtuples(size_t_, size_t_, size_t_) noexcept { + static_assert(SubtupleLength > 2, "====================> Boost.PFR: Internal error while representing nested field as tuple"); + constexpr auto seq = detail::make_index_sequence{}; + return detail::as_flat_tuple_impl( detail::increment_index_sequence(seq) ); +} + + +template +constexpr Array remove_subtuples(Array indexes_plus_1, const Array& subtuple_lengths) noexcept { + for (std::size_t i = 0; i < subtuple_lengths.size(); ++i) { + if (subtuple_lengths.data[i]) { + const std::size_t skips_count = subtuple_lengths.data[i]; + for (std::size_t j = i + 1; j < skips_count + i; ++j) { + indexes_plus_1.data[j] = 0; + } + i += skips_count - 1; + } + } + return indexes_plus_1; +} + +template +constexpr size_array resize_dropping_zeros_and_decrementing(size_t_, const Array& a) noexcept { + size_array result{}; + std::size_t result_indx = 0; + for (std::size_t i = 0; i < a.size(); ++i) { + if (a.data[i]) { + result.data[result_indx] = static_cast(a.data[i] - 1); + ++ result_indx; + } + } + + return result; +} + +template +constexpr auto as_flat_tuple_impl_drop_helpers(std::index_sequence, std::index_sequence) noexcept { + constexpr auto a = detail::flat_array_of_type_ids(); + + constexpr size_array subtuples_length {{ + a.count_from_opening_till_matching_parenthis_seq(First, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag), + a.count_from_opening_till_matching_parenthis_seq(I, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag)... + }}; + + constexpr size_array type_indexes_with_subtuple_internals {{ 1, 1 + I - First...}}; + constexpr auto type_indexes_plus_1_and_zeros_as_skips = detail::remove_subtuples(type_indexes_with_subtuple_internals, subtuples_length); + constexpr auto new_size = size_t_{}; + constexpr auto type_indexes = detail::resize_dropping_zeros_and_decrementing(new_size, type_indexes_plus_1_and_zeros_as_skips); + + typedef sequence_tuple::tuple< + decltype(detail::prepare_subtuples( + size_t_< a.data[ First + type_indexes.data[INew] ] >{}, // id of type + size_t_< First + type_indexes.data[INew] >{}, // index of current id in `a` + size_t_< subtuples_length.data[ type_indexes.data[INew] ] >{} // if id of type is tuple, then length of that tuple + ))... + > subtuples_uncleanuped_t; + + return subtuples_uncleanuped_t{}; +} + +template +constexpr std::size_t count_skips_in_array(std::size_t begin_index, std::size_t end_index, const Array& a) noexcept { + std::size_t skips = 0; + for (std::size_t i = begin_index; i < end_index; ++i) { + if (a.data[i] == typeid_conversions::tuple_begin_tag) { + const std::size_t this_tuple_size = a.count_from_opening_till_matching_parenthis_seq(i, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag) - 1; + skips += this_tuple_size; + i += this_tuple_size - 1; + } + } + + return skips; +} + +template +constexpr auto as_flat_tuple_impl(std::index_sequence) noexcept { + constexpr auto a = detail::flat_array_of_type_ids(); + constexpr std::size_t count_of_I = sizeof...(I); + + return detail::as_flat_tuple_impl_drop_helpers( + std::index_sequence{}, + detail::make_index_sequence< 1 + count_of_I - count_skips_in_array(First, First + count_of_I, a) >{} + ); +} + +template +constexpr auto internal_tuple_with_same_alignment() noexcept { + typedef typename std::remove_cv::type type; + + static_assert( + std::is_trivial::value && std::is_standard_layout::value, + "====================> Boost.PFR: Type can not be reflected without Loophole or C++17, because it's not POD" + ); + static_assert(!std::is_reference::value, "====================> Boost.PFR: Not applyable"); + constexpr auto res = detail::as_flat_tuple_impl( + detail::make_index_sequence< decltype(detail::flat_array_of_type_ids())::size() >() + ); + + return res; +} + +template +using internal_tuple_with_same_alignment_t = decltype( detail::internal_tuple_with_same_alignment() ); + + +///////////////////// Flattening +struct ubiq_is_flat_refelectable { + bool& is_flat_refelectable; + + template + constexpr operator Type() const noexcept { + is_flat_refelectable = std::is_fundamental>::value; + return {}; + } +}; + +template +constexpr bool is_flat_refelectable(std::index_sequence) noexcept { + constexpr std::size_t fields = sizeof...(I); + bool result[fields] = {static_cast(I)...}; + const T v{ ubiq_is_flat_refelectable{result[I]}... }; + (void)v; + + for (std::size_t i = 0; i < fields; ++i) { + if (!result[i]) { + return false; + } + } + + return true; +} + +template +constexpr bool is_flat_refelectable(std::index_sequence<>) noexcept { + return true; ///< all empty structs always flat refelectable +} + +template +auto tie_as_flat_tuple(T& lvalue) noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + using type = std::remove_cv_t; + using tuple_type = internal_tuple_with_same_alignment_t; + + offset_based_getter getter; + return boost::pfr::detail::make_flat_tuple_of_references(lvalue, getter, size_t_<0>{}, size_t_{}); +} + +template +auto tie_as_tuple(T& val) noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + static_assert( + boost::pfr::detail::is_flat_refelectable( detail::make_index_sequence()>{} ), + "====================> Boost.PFR: Not possible in C++14 to represent that type without loosing information. Change type definition or enable C++17" + ); + return boost::pfr::detail::tie_as_flat_tuple(val); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +///////////////////// Structure that can be converted to copy of anything +struct ubiq_constructor_constexpr_copy { + std::size_t ignore; + + template + constexpr operator Type() const noexcept { + static_assert( + std::is_trivially_destructible::value, + "====================> Boost.PFR: One of the fields in the type passed to `for_each_field` has non trivial destructor." + ); + return {}; + } +}; + +///////////////////// + +template +struct is_constexpr_aggregate_initializable { + template + static constexpr void* constexpr_aggregate_initializer() noexcept { + T2 tmp{ ubiq_constructor_constexpr_copy{I2}... }; + (void)tmp; + return nullptr; + } + + template () > + static std::true_type test(long) noexcept; + + static std::false_type test(...) noexcept; + + static constexpr bool value = decltype(test(0)){}; +}; + + +template +void for_each_field_in_depth(T& t, F&& f, std::index_sequence, identity...); + +template +void for_each_field_in_depth(T& t, F&& f, std::index_sequence<>, identity...); + +template +struct next_step { + T& t; + F& f; + + template + operator Field() const { + boost::pfr::detail::for_each_field_in_depth( + t, + std::forward(f), + IndexSeq{}, + identity{}..., + identity{} + ); + + return {}; + } +}; + +template +void for_each_field_in_depth(T& t, F&& f, std::index_sequence, identity...) { + (void)std::add_const_t>{ + Fields{}..., + next_step, Fields...>{t, f}, + ubiq_constructor_constexpr_copy{I}... + }; +} + +template +void for_each_field_in_depth(T& lvalue, F&& f, std::index_sequence<>, identity...) { + using tuple_type = sequence_tuple::tuple; + + offset_based_getter>, tuple_type> getter; + std::forward(f)( + boost::pfr::detail::make_flat_tuple_of_references(lvalue, getter, size_t_<0>{}, size_t_{}) + ); +} + +template +void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence, std::true_type /*is_flat_refelectable*/) { + std::forward(f)( + boost::pfr::detail::tie_as_flat_tuple(t) + ); +} + + +template +void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence, std::false_type /*is_flat_refelectable*/) { + boost::pfr::detail::for_each_field_in_depth( + t, + std::forward(f), + std::index_sequence{} + ); +} + +template +void for_each_field_dispatcher(T& t, F&& f, std::index_sequence) { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + static_assert(is_constexpr_aggregate_initializable::value, "====================> Boost.PFR: T must be a constexpr initializable type"); + + constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable( std::index_sequence{} ); + detail::for_each_field_dispatcher_1( + t, + std::forward(f), + std::index_sequence{}, + std::integral_constant{} + ); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +#ifdef __clang__ +# pragma clang diagnostic pop +#endif + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP diff --git a/3rd/pfr/include/boost/pfr/detail/core14_loophole.hpp b/3rd/pfr/include/boost/pfr/detail/core14_loophole.hpp new file mode 100644 index 0000000..78534b5 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core14_loophole.hpp @@ -0,0 +1,201 @@ +// Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin. +// Copyright (c) 2019-2023 Antony Polukhin. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// The Great Type Loophole (C++14) +// Initial implementation by Alexandr Poltavsky, http://alexpolt.github.io +// +// Description: +// The Great Type Loophole is a technique that allows to exchange type information with template +// instantiations. Basically you can assign and read type information during compile time. +// Here it is used to detect data members of a data type. I described it for the first time in +// this blog post http://alexpolt.github.io/type-loophole.html . +// +// This technique exploits the http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118 +// CWG 2118. Stateful metaprogramming via friend injection +// Note: CWG agreed that such techniques should be ill-formed, although the mechanism for prohibiting them is as yet undetermined. + +#ifndef BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP +#define BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP +#pragma once + +#include + +#include +#include + +#include // still needed for enums +#include +#include +#include +#include +#include +#include +#include + + +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wmissing-braces" +# pragma clang diagnostic ignored "-Wundefined-inline" +# pragma clang diagnostic ignored "-Wundefined-internal" +# pragma clang diagnostic ignored "-Wmissing-field-initializers" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wnon-template-friend" +#endif + + +namespace boost { namespace pfr { namespace detail { + +// tag generates friend declarations and helps with overload resolution. +// There are two types: one with the auto return type, which is the way we read types later. +// The second one is used in the detection of instantiations without which we'd get multiple +// definitions. + +template +struct tag { + friend auto loophole(tag); +}; + +// The definitions of friend functions. +template +struct fn_def_lref { + friend auto loophole(tag) { + // Standard Library containers do not SFINAE on invalid copy constructor. Because of that std::vector> reports that it is copyable, + // which leads to an instantiation error at this place. + // + // To workaround the issue, we check that the type U is movable, and move it in that case. + using no_extents_t = std::remove_all_extents_t; + return static_cast< std::conditional_t::value, no_extents_t&&, no_extents_t&> >( + boost::pfr::detail::unsafe_declval() + ); + } +}; +template +struct fn_def_rref { + friend auto loophole(tag) { return std::move(boost::pfr::detail::unsafe_declval< std::remove_all_extents_t& >()); } +}; + + +// Those specializations are to avoid multiple definition errors. +template +struct fn_def_lref {}; + +template +struct fn_def_rref {}; + + +// This has a templated conversion operator which in turn triggers instantiations. +// Important point, using sizeof seems to be more reliable. Also default template +// arguments are "cached" (I think). To fix that I provide a U template parameter to +// the ins functions which do the detection using constexpr friend functions and SFINAE. +template +struct loophole_ubiq_lref { + template static std::size_t ins(...); + template{})) > static char ins(int); + + template(0)) == sizeof(char)>)> + constexpr operator U&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior. +}; + +template +struct loophole_ubiq_rref { + template static std::size_t ins(...); + template{})) > static char ins(int); + + template(0)) == sizeof(char)>)> + constexpr operator U&&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior. +}; + + +// This is a helper to turn a data structure into a tuple. +template +struct loophole_type_list_lref; + +template +struct loophole_type_list_lref< T, std::index_sequence > + // Instantiating loopholes: + : sequence_tuple::tuple< decltype(T{ loophole_ubiq_lref{}... }, 0) > +{ + using type = sequence_tuple::tuple< decltype(loophole(tag{}))... >; +}; + + +template +struct loophole_type_list_rref; + +template +struct loophole_type_list_rref< T, std::index_sequence > + // Instantiating loopholes: + : sequence_tuple::tuple< decltype(T{ loophole_ubiq_rref{}... }, 0) > +{ + using type = sequence_tuple::tuple< decltype(loophole(tag{}))... >; +}; + + +// Lazily returns loophole_type_list_{lr}ref. +template +struct loophole_type_list_selector { + using type = loophole_type_list_lref; +}; + +template +struct loophole_type_list_selector { + using type = loophole_type_list_rref; +}; + +template +auto tie_as_tuple_loophole_impl(T& lvalue) noexcept { + using type = std::remove_cv_t>; + using indexes = detail::make_index_sequence()>; + using loophole_type_list = typename detail::loophole_type_list_selector< + std::is_copy_constructible>::value, type, indexes + >::type; + using tuple_type = typename loophole_type_list::type; + + return boost::pfr::detail::make_flat_tuple_of_references( + lvalue, + offset_based_getter{}, + size_t_<0>{}, + size_t_{} + ); +} + +template +auto tie_as_tuple(T& val) noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + return boost::pfr::detail::tie_as_tuple_loophole_impl( + val + ); +} + +template +void for_each_field_dispatcher(T& t, F&& f, std::index_sequence) { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + std::forward(f)( + boost::pfr::detail::tie_as_tuple_loophole_impl(t) + ); +} + +}}} // namespace boost::pfr::detail + + +#ifdef __clang__ +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + + +#endif // BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/core17.hpp b/3rd/pfr/include/boost/pfr/detail/core17.hpp new file mode 100644 index 0000000..d28de57 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core17.hpp @@ -0,0 +1,72 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_PFR_DETAIL_CORE17_HPP +#define BOOST_PFR_DETAIL_CORE17_HPP +#pragma once + +#include +#include +#include +#include + +namespace boost { namespace pfr { namespace detail { + +#ifndef _MSC_VER // MSVC fails to compile the following code, but compiles the structured bindings in core17_generated.hpp +struct do_not_define_std_tuple_size_for_me { + bool test1 = true; +}; + +template +constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE: + T val{}; + auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE: + + /**************************************************************************** + * + * It looks like your compiler or Standard Library can not handle C++17 + * structured bindings. + * + * Workaround: Define BOOST_PFR_USE_CPP17 to 0 + * It will disable the C++17 features for Boost.PFR library. + * + * Sorry for the inconvenience caused. + * + ****************************************************************************/ + + return a; +} + +static_assert( + do_structured_bindings_work(), + "====================> Boost.PFR: Your compiler can not handle C++17 structured bindings. Read the above comments for workarounds." +); +#endif // #ifndef _MSC_VER + +template +constexpr auto tie_as_tuple(T& val) noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + typedef size_t_()> fields_count_tag; + return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{}); +} + +template +constexpr void for_each_field_dispatcher(T& t, F&& f, std::index_sequence) { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + std::forward(f)( + detail::tie_as_tuple(t) + ); +} + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CORE17_HPP diff --git a/3rd/pfr/include/boost/pfr/detail/core17_generated.hpp b/3rd/pfr/include/boost/pfr/detail/core17_generated.hpp new file mode 100644 index 0000000..8052096 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core17_generated.hpp @@ -0,0 +1,2754 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// Copyright (c) 2023 Denis Mikhailov +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////// THIS HEADER IS AUTO GENERATED BY misc/generate_cpp17.py //////////////// +//////////////// MODIFY AND RUN THE misc/generate_cpp17.py INSTEAD OF DIRECTLY MODIFYING THE GENERATED FILE //////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_PFR_DETAIL_CORE17_GENERATED_HPP +#define BOOST_PFR_DETAIL_CORE17_GENERATED_HPP +#pragma once + +#include +#if !BOOST_PFR_USE_CPP17 +# error C++17 is required for this header. +#endif + +#include +#include +#include // for std::conditional_t, std::is_reference + +namespace boost { namespace pfr { namespace detail { + +template +constexpr auto make_tuple_of_references(Args&&... args) noexcept { + return sequence_tuple::tuple{ args... }; +} + +template +constexpr decltype(auto) add_cv_like(Arg& arg) noexcept { + if constexpr (std::is_const::value && std::is_volatile::value) { + return const_cast(arg); + } + else if constexpr (std::is_const::value) { + return const_cast(arg); + } + else if constexpr (std::is_volatile::value) { + return const_cast(arg); + } + else { + return const_cast(arg); + } +} + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78939 +template +constexpr decltype(auto) workaround_cast(Arg& arg) noexcept { + using output_arg_t = std::conditional_t(), decltype(detail::add_cv_like(arg)), Sb>; + return const_cast(arg); +} + +template +constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept { + return sequence_tuple::tuple<>{}; +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t >::value>* = nullptr) noexcept { + auto& [a] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + return ::boost::pfr::detail::make_tuple_of_references(detail::workaround_cast(a)); +} + + +template +constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t >::value>* = nullptr) noexcept { + return ::boost::pfr::detail::make_tuple_of_references( val ); +} + + +template +constexpr auto tie_as_tuple(T& val, size_t_<2>) noexcept { + auto& [a,b] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + return ::boost::pfr::detail::make_tuple_of_references(detail::workaround_cast(a),detail::workaround_cast(b)); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<3>) noexcept { + auto& [a,b,c] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<4>) noexcept { + auto& [a,b,c,d] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<5>) noexcept { + auto& [a,b,c,d,e] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<6>) noexcept { + auto& [a,b,c,d,e,f] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<7>) noexcept { + auto& [a,b,c,d,e,f,g] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<8>) noexcept { + auto& [a,b,c,d,e,f,g,h] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<9>) noexcept { + auto& [a,b,c,d,e,f,g,h,j] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<10>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<11>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<12>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<13>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<14>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<15>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<16>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<17>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<18>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<19>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<20>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<21>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<22>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<23>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<24>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<25>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<26>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<27>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<28>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<29>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<30>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<31>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<32>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<33>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<34>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<35>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<36>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<37>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<38>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<39>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<40>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<41>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<42>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<43>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<44>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<45>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<46>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<47>) noexcept { + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<48>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<49>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<50>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<51>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<52>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<53>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<54>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<55>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<56>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<57>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<58>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<59>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<60>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<61>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<62>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<63>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<64>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<65>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<66>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<67>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<68>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<69>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<70>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<71>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<72>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<73>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<74>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<75>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<76>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<77>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<78>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<79>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<80>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<81>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<82>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<83>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<84>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<85>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<86>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<87>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<88>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<89>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<90>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<91>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<92>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<93>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<94>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<95>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<96>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba,bb + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba),detail::workaround_cast(bb) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<97>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba,bb,bc + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba),detail::workaround_cast(bb), + detail::workaround_cast(bc) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<98>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba,bb,bc,bd + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba),detail::workaround_cast(bb), + detail::workaround_cast(bc),detail::workaround_cast(bd) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<99>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba,bb,bc,bd,be + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba),detail::workaround_cast(bb), + detail::workaround_cast(bc),detail::workaround_cast(bd),detail::workaround_cast(be) + ); +} + +template +constexpr auto tie_as_tuple(T& val, size_t_<100>) noexcept { + auto& [ + a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z, + aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ, + ba,bb,bc,bd,be,bf + ] = const_cast&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate. + + return ::boost::pfr::detail::make_tuple_of_references( + detail::workaround_cast(a),detail::workaround_cast(b),detail::workaround_cast(c), + detail::workaround_cast(d),detail::workaround_cast(e),detail::workaround_cast(f), + detail::workaround_cast(g),detail::workaround_cast(h),detail::workaround_cast(j), + detail::workaround_cast(k),detail::workaround_cast(l),detail::workaround_cast(m), + detail::workaround_cast(n),detail::workaround_cast(p),detail::workaround_cast(q), + detail::workaround_cast(r),detail::workaround_cast(s),detail::workaround_cast(t), + detail::workaround_cast(u),detail::workaround_cast(v),detail::workaround_cast(w), + detail::workaround_cast(x),detail::workaround_cast(y),detail::workaround_cast(z), + detail::workaround_cast(A),detail::workaround_cast(B),detail::workaround_cast(C), + detail::workaround_cast(D),detail::workaround_cast(E),detail::workaround_cast(F), + detail::workaround_cast(G),detail::workaround_cast(H),detail::workaround_cast(J), + detail::workaround_cast(K),detail::workaround_cast(L),detail::workaround_cast(M), + detail::workaround_cast(N),detail::workaround_cast(P),detail::workaround_cast(Q), + detail::workaround_cast(R),detail::workaround_cast(S),detail::workaround_cast(U), + detail::workaround_cast(V),detail::workaround_cast(W),detail::workaround_cast(X), + detail::workaround_cast(Y),detail::workaround_cast(Z),detail::workaround_cast(aa), + detail::workaround_cast(ab),detail::workaround_cast(ac),detail::workaround_cast(ad), + detail::workaround_cast(ae),detail::workaround_cast(af),detail::workaround_cast(ag), + detail::workaround_cast(ah),detail::workaround_cast(aj),detail::workaround_cast(ak), + detail::workaround_cast(al),detail::workaround_cast(am),detail::workaround_cast(an), + detail::workaround_cast(ap),detail::workaround_cast(aq),detail::workaround_cast(ar), + detail::workaround_cast(as),detail::workaround_cast(at),detail::workaround_cast(au), + detail::workaround_cast(av),detail::workaround_cast(aw),detail::workaround_cast(ax), + detail::workaround_cast(ay),detail::workaround_cast(az),detail::workaround_cast(aA), + detail::workaround_cast(aB),detail::workaround_cast(aC),detail::workaround_cast(aD), + detail::workaround_cast(aE),detail::workaround_cast(aF),detail::workaround_cast(aG), + detail::workaround_cast(aH),detail::workaround_cast(aJ),detail::workaround_cast(aK), + detail::workaround_cast(aL),detail::workaround_cast(aM),detail::workaround_cast(aN), + detail::workaround_cast(aP),detail::workaround_cast(aQ),detail::workaround_cast(aR), + detail::workaround_cast(aS),detail::workaround_cast(aU),detail::workaround_cast(aV), + detail::workaround_cast(aW),detail::workaround_cast(aX),detail::workaround_cast(aY), + detail::workaround_cast(aZ),detail::workaround_cast(ba),detail::workaround_cast(bb), + detail::workaround_cast(bc),detail::workaround_cast(bd),detail::workaround_cast(be), + detail::workaround_cast(bf) + ); +} + + +template +constexpr void tie_as_tuple(T& /*val*/, size_t_) noexcept { + static_assert(sizeof(T) && false, + "====================> Boost.PFR: Too many fields in a structure T. Regenerate include/boost/pfr/detail/core17_generated.hpp file for appropriate count of fields. For example: `python ./misc/generate_cpp17.py 300 > include/boost/pfr/detail/core17_generated.hpp`"); +} + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CORE17_GENERATED_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/core_name.hpp b/3rd/pfr/include/boost/pfr/detail/core_name.hpp new file mode 100644 index 0000000..f266ef2 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core_name.hpp @@ -0,0 +1,29 @@ +// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// Initial implementation by Bela Schaum, https://github.com/schaumb +// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669 +// + +#ifndef BOOST_PFR_DETAIL_CORE_NAME_HPP +#define BOOST_PFR_DETAIL_CORE_NAME_HPP +#pragma once + +#include + +// Each core_name provides `boost::pfr::detail::get_name` and +// `boost::pfr::detail::tie_as_names_tuple` functions. +// +// The whole functional of extracting field's names is build on top of those +// two functions. +#if BOOST_PFR_CORE_NAME_ENABLED +#include +#else +#include +#endif + +#endif // BOOST_PFR_DETAIL_CORE_NAME_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/core_name14_disabled.hpp b/3rd/pfr/include/boost/pfr/detail/core_name14_disabled.hpp new file mode 100644 index 0000000..115e838 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core_name14_disabled.hpp @@ -0,0 +1,43 @@ +// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// Initial implementation by Bela Schaum, https://github.com/schaumb +// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669 +// + +#ifndef BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP +#define BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP +#pragma once + +#include +#include + +namespace boost { namespace pfr { namespace detail { + +template +constexpr auto get_name() noexcept { + static_assert( + sizeof(T) && false, + "====================> Boost.PFR: Field's names extracting functionality requires C++20." + ); + + return nullptr; +} + +template +constexpr auto tie_as_names_tuple() noexcept { + static_assert( + sizeof(T) && false, + "====================> Boost.PFR: Field's names extracting functionality requires C++20." + ); + + return detail::sequence_tuple::make_sequence_tuple(); +} + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/core_name20_static.hpp b/3rd/pfr/include/boost/pfr/detail/core_name20_static.hpp new file mode 100644 index 0000000..e54d95e --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/core_name20_static.hpp @@ -0,0 +1,242 @@ +// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov. +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// Initial implementation by Bela Schaum, https://github.com/schaumb +// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669 +// + +#ifndef BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP +#define BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for std::addressof + +namespace boost { namespace pfr { namespace detail { + +struct core_name_skip { + std::size_t size_at_begin; + std::size_t size_at_end; + bool is_backward; + std::string_view until_runtime; + + consteval std::string_view apply(std::string_view sv) const noexcept { + // We use std::min here to make the compiler diagnostic shorter and + // cleaner in case of misconfigured BOOST_PFR_CORE_NAME_PARSING + sv.remove_prefix((std::min)(size_at_begin, sv.size())); + sv.remove_suffix((std::min)(size_at_end, sv.size())); + if (until_runtime.empty()) { + return sv; + } + + const auto found = is_backward ? sv.rfind(until_runtime) + : sv.find(until_runtime); + + const auto cut_until = found + until_runtime.size(); + const auto safe_cut_until = (std::min)(cut_until, sv.size()); + return sv.substr(safe_cut_until); + } +}; + +struct backward { + explicit consteval backward(std::string_view value) noexcept + : value(value) + {} + + std::string_view value; +}; + +consteval core_name_skip make_core_name_skip(std::size_t size_at_begin, + std::size_t size_at_end, + std::string_view until_runtime) noexcept +{ + return core_name_skip{size_at_begin, size_at_end, false, until_runtime}; +} + +consteval core_name_skip make_core_name_skip(std::size_t size_at_begin, + std::size_t size_at_end, + backward until_runtime) noexcept +{ + return core_name_skip{size_at_begin, size_at_end, true, until_runtime.value}; +} + +// it might be compilation failed without this workaround sometimes +// See https://github.com/llvm/llvm-project/issues/41751 for details +template +consteval std::string_view clang_workaround(std::string_view value) noexcept +{ + return value; +} + +template +consteval auto name_of_field_impl() noexcept { + // Some of the following compiler specific macro may be defined only + // inside the function body: + +#ifndef BOOST_PFR_FUNCTION_SIGNATURE +# if defined(__FUNCSIG__) +# define BOOST_PFR_FUNCTION_SIGNATURE __FUNCSIG__ +# elif defined(__PRETTY_FUNCTION__) || defined(__GNUC__) || defined(__clang__) +# define BOOST_PFR_FUNCTION_SIGNATURE __PRETTY_FUNCTION__ +# else +# define BOOST_PFR_FUNCTION_SIGNATURE "" +# endif +#endif + + constexpr std::string_view sv = detail::clang_workaround(BOOST_PFR_FUNCTION_SIGNATURE); + static_assert(!sv.empty(), + "====================> Boost.PFR: Field reflection parser configured in a wrong way. " + "Please define the BOOST_PFR_FUNCTION_SIGNATURE to a compiler specific macro, " + "that outputs the whole function signature including non-type template parameters." + ); + + constexpr auto skip = detail::make_core_name_skip BOOST_PFR_CORE_NAME_PARSING; + static_assert(skip.size_at_begin + skip.size_at_end + skip.until_runtime.size() < sv.size(), + "====================> Boost.PFR: Field reflection parser configured in a wrong way. " + "It attempts to skip more chars than available. " + "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section " + "'Limitations and Configuration' for more information." + ); + constexpr auto fn = skip.apply(sv); + static_assert( + !fn.empty(), + "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. " + "It skipped all the input, leaving the field name empty. " + "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section " + "'Limitations and Configuration' for more information." + ); + auto res = std::array{}; + + auto* out = res.data(); + for (auto x: fn) { + *out = x; + ++out; + } + + return res; +} + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wundefined-var-template" + +// clang 16 and earlier don't support address of non-static member as template parameter +// but fortunately it's possible to use C++20 non-type template parameters in another way +// even in clang 16 and more older clangs +// all we need is to wrap pointer into 'clang_wrapper_t' and then pass it into template +template +struct clang_wrapper_t { + T v; +}; +template +clang_wrapper_t(T) -> clang_wrapper_t; + +template +constexpr auto make_clang_wrapper(const T& arg) noexcept { + return clang_wrapper_t{arg}; +} + +#else + +template +constexpr const T& make_clang_wrapper(const T& arg) noexcept { + // It's everything OK with address of non-static member as template parameter support on this compiler + // so we don't need a wrapper here, just pass the pointer into template + return arg; +} + +#endif + +template +consteval auto name_of_field() noexcept { + // Sanity check: known field name must match the deduced one + static_assert( + sizeof(MsvcWorkaround) // do not trigger if `name_of_field()` is not used + && std::string_view{ + detail::name_of_field_impl< + core_name_skip, detail::make_clang_wrapper(std::addressof( + fake_object.size_at_begin + )) + >().data() + } == "size_at_begin", + "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. " + "It does not return the proper field name. " + "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section " + "'Limitations and Configuration' for more information." + ); + + return detail::name_of_field_impl(); +} + +// Storing part of a string literal into an array minimizes the binary size. +// +// Without passing 'T' into 'name_of_field' different fields from different structures might have the same name! +// See https://developercommunity.visualstudio.com/t/__FUNCSIG__-outputs-wrong-value-with-C/10458554 for details +template +inline constexpr auto stored_name_of_field = detail::name_of_field( + detail::tie_as_tuple(detail::fake_object) + ))) +>(); + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +template +constexpr auto tie_as_names_tuple_impl(std::index_sequence) noexcept { + return detail::sequence_tuple::make_sequence_tuple(std::string_view{stored_name_of_field.data()}...); +} + +template +constexpr std::string_view get_name() noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + static_assert( + !std::is_array::value, + "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members" + ); + static_assert( + sizeof(T) && BOOST_PFR_USE_CPP17, + "====================> Boost.PFR: Extraction of field's names is allowed only when the BOOST_PFR_USE_CPP17 macro enabled." + ); + + return stored_name_of_field.data(); +} + +template +constexpr auto tie_as_names_tuple() noexcept { + static_assert( + !std::is_union::value, + "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info." + ); + static_assert( + !std::is_array::value, + "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members" + ); + static_assert( + sizeof(T) && BOOST_PFR_USE_CPP17, + "====================> Boost.PFR: Extraction of field's names is allowed only when the BOOST_PFR_USE_CPP17 macro enabled." + ); + + return detail::tie_as_names_tuple_impl(detail::make_index_sequence()>{}); +} + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP + diff --git a/3rd/pfr/include/boost/pfr/detail/detectors.hpp b/3rd/pfr/include/boost/pfr/detail/detectors.hpp new file mode 100644 index 0000000..cd02575 --- /dev/null +++ b/3rd/pfr/include/boost/pfr/detail/detectors.hpp @@ -0,0 +1,70 @@ +// Copyright (c) 2016-2023 Antony Polukhin +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PFR_DETAIL_DETECTORS_HPP +#define BOOST_PFR_DETAIL_DETECTORS_HPP +#pragma once + +#include + +#include +#include + +namespace boost { namespace pfr { namespace detail { +///////////////////// `value` is true if Detector does not compile (SFINAE) + struct can_not_apply{}; + + template