From 8031f575fe6cee6c0272ed64319a0934711a79fb Mon Sep 17 00:00:00 2001 From: Antony Polukhin Date: Wed, 18 Oct 2017 22:40:54 +0300 Subject: [PATCH] Ironed out the lvalues and rvalues in detail namespace. Less template instantiations must happen now --- .../pfr/detail/cast_to_layout_compatible.hpp | 9 +- include/boost/pfr/detail/core14_classic.hpp | 48 ++-- include/boost/pfr/detail/core14_loophole.hpp | 37 +-- include/boost/pfr/detail/core17.hpp | 5 +- include/boost/pfr/detail/core17_generated.hpp | 217 +++++++++--------- .../boost/pfr/detail/for_each_field_impl.hpp | 19 +- include/boost/pfr/detail/lr_value.hpp | 28 +++ .../detail/make_flat_tuple_of_references.hpp | 27 +-- .../boost/pfr/detail/offset_based_getter.hpp | 10 +- include/boost/pfr/flat/core.hpp | 6 +- include/boost/pfr/precise/core.hpp | 7 +- misc/generate_cpp17.py | 27 +-- 12 files changed, 228 insertions(+), 212 deletions(-) create mode 100644 include/boost/pfr/detail/lr_value.hpp diff --git a/include/boost/pfr/detail/cast_to_layout_compatible.hpp b/include/boost/pfr/detail/cast_to_layout_compatible.hpp index 4e26f03..710f2ba 100644 --- a/include/boost/pfr/detail/cast_to_layout_compatible.hpp +++ b/include/boost/pfr/detail/cast_to_layout_compatible.hpp @@ -11,6 +11,7 @@ #include #include // metaprogramming stuff +#include namespace boost { namespace pfr { namespace detail { @@ -60,13 +61,9 @@ MAY_ALIAS To& cast_to_layout_compatible(From& val) noexcept { static_assert_layout_compatible(); return *t; } -/* + template -MAY_ALIAS std::enable_if_t::value, To&&> cast_to_layout_compatible(From&& val) noexcept { - MAY_ALIAS To* const t = reinterpret_cast( std::addressof(val) ); - static_assert_layout_compatible(); - return std::move(*t); -}*/ +MAY_ALIAS To&& cast_to_layout_compatible(rvalue_t val) = delete; #undef MAY_ALIAS diff --git a/include/boost/pfr/detail/core14_classic.hpp b/include/boost/pfr/detail/core14_classic.hpp index 7be7647..d16df59 100644 --- a/include/boost/pfr/detail/core14_classic.hpp +++ b/include/boost/pfr/detail/core14_classic.hpp @@ -17,6 +17,7 @@ #include #include #include +#include #ifdef __clang__ # pragma clang diagnostic push @@ -535,8 +536,8 @@ constexpr bool is_flat_refelectable(std::index_sequence) noexcept { } template -auto tie_as_flat_tuple(T&& lvalue) noexcept { - using type = std::remove_cv_t>; +auto tie_as_flat_tuple(lvalue_t lvalue) noexcept { + using type = std::remove_cv_t; using tuple_type = internal_tuple_with_same_alignment_t; offset_based_getter getter; @@ -546,18 +547,7 @@ auto tie_as_flat_tuple(T&& lvalue) noexcept { #if !BOOST_PFR_USE_CPP17 template -auto tie_as_tuple(T& val) noexcept { - typedef T type; - static_assert( - boost::pfr::detail::is_flat_refelectable( std::make_index_sequence()>{} ), - "Not possible in C++14 to represent that type without loosing information. Use boost::pfr::flat_ version, or change type definition, or enable C++17" - ); - return boost::pfr::detail::tie_as_flat_tuple(val); -} - - -template -auto tie_as_tuple(const T& val) noexcept { +auto tie_as_tuple(lvalue_t val) noexcept { typedef T type; static_assert( boost::pfr::detail::is_flat_refelectable( std::make_index_sequence()>{} ), @@ -600,10 +590,10 @@ struct is_constexpr_aggregate_initializable { // TODO: try to fix it template -void for_each_field_in_depth(T&& t, F&& f, std::index_sequence, identity...); +void for_each_field_in_depth(lvalue_t t, F&& f, std::index_sequence, identity...); template -void for_each_field_in_depth(T&& t, F&& f, std::index_sequence<>, identity...); +void for_each_field_in_depth(lvalue_t t, F&& f, std::index_sequence<>, identity...); template struct next_step { @@ -613,7 +603,7 @@ struct next_step { template operator Field() const { boost::pfr::detail::for_each_field_in_depth( - std::forward(t), + t, std::forward(f), IndexSeq{}, identity{}..., @@ -625,7 +615,7 @@ struct next_step { }; template -void for_each_field_in_depth(T&& t, F&& f, std::index_sequence, identity...) { +void for_each_field_in_depth(lvalue_t t, F&& f, std::index_sequence, identity...) { (void)std::add_const_t>{ Fields{}..., next_step, Fields...>{t, f}, @@ -634,7 +624,7 @@ void for_each_field_in_depth(T&& t, F&& f, std::index_sequence, identi } template -void for_each_field_in_depth(T&& lvalue, F&& f, std::index_sequence<>, identity...) { +void for_each_field_in_depth(lvalue_t lvalue, F&& f, std::index_sequence<>, identity...) { using tuple_type = sequence_tuple::tuple; offset_based_getter>, tuple_type> getter; @@ -644,39 +634,37 @@ void for_each_field_in_depth(T&& lvalue, F&& f, std::index_sequence<>, identity< } template -void for_each_field_dispatcher_1(T&& t, F&& f, std::index_sequence, std::true_type /*is_flat_refelectable*/) { +void for_each_field_dispatcher_1(lvalue_t t, F&& f, std::index_sequence, std::true_type /*is_flat_refelectable*/) { std::forward(f)( - boost::pfr::detail::tie_as_flat_tuple(std::forward(t)) + 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*/) { +void for_each_field_dispatcher_1(lvalue_t t, F&& f, std::index_sequence, std::false_type /*is_flat_refelectable*/) { boost::pfr::detail::for_each_field_in_depth( - std::forward(t), + t, std::forward(f), std::index_sequence{} ); } template -void for_each_field_dispatcher(T&& t, F&& f, std::index_sequence) { - typedef std::remove_reference_t type; - +void for_each_field_dispatcher(lvalue_t t, F&& f, std::index_sequence) { /// Compile time error at this point means that you have called `for_each_field` or some other non-flat function or operator for a /// type that is not constexpr aggregate initializable. /// /// Make sure that all the fields of your type have constexpr default construtors and trivial destructors. /// Or compile in C++17 mode. - constexpr type tmp{ ubiq_constructor_constexpr_copy{I}... }; + constexpr T tmp{ ubiq_constructor_constexpr_copy{I}... }; (void)tmp; - //static_assert(is_constexpr_aggregate_initializable::value, "T must be a constexpr initializable type"); + //static_assert(is_constexpr_aggregate_initializable::value, "T must be a constexpr initializable type"); - constexpr bool is_flat_refelectable_val = is_flat_refelectable( std::index_sequence{} ); + constexpr bool is_flat_refelectable_val = is_flat_refelectable( std::index_sequence{} ); for_each_field_dispatcher_1( - std::forward(t), + t, std::forward(f), std::index_sequence{}, std::integral_constant{} diff --git a/include/boost/pfr/detail/core14_loophole.hpp b/include/boost/pfr/detail/core14_loophole.hpp index 125ff16..bd09c65 100644 --- a/include/boost/pfr/detail/core14_loophole.hpp +++ b/include/boost/pfr/detail/core14_loophole.hpp @@ -30,6 +30,7 @@ #include #include #include +#include #ifdef __clang__ @@ -101,7 +102,7 @@ struct loophole_type_list< T, std::index_sequence > template -auto tie_as_tuple_loophole_impl(T&& lvalue) noexcept { +auto tie_as_tuple_loophole_impl(lvalue_t lvalue) noexcept { using type = std::remove_cv_t>; using indexes = std::make_index_sequence()>; using tuple_type = typename loophole_type_list::type; @@ -115,21 +116,21 @@ auto tie_as_tuple_loophole_impl(T&& lvalue) noexcept { } // Forward declarations: -template auto tie_as_tuple_recursively(T&& val) noexcept; +template auto tie_as_tuple_recursively(rvalue_t val) noexcept; template -auto tie_or_value(T&& val, std::enable_if_t >::value>* = 0) noexcept { +auto tie_or_value(lvalue_t val, std::enable_if_t >::value>* = 0) noexcept { return boost::pfr::detail::tie_as_tuple_recursively( - boost::pfr::detail::tie_as_tuple_loophole_impl(std::forward(val)) + boost::pfr::detail::tie_as_tuple_loophole_impl(val) ); } template -decltype(auto) tie_or_value(T&& lvalue, std::enable_if_t>::value>* = 0) noexcept { +decltype(auto) tie_or_value(lvalue_t val, std::enable_if_t>::value>* = 0) noexcept { // This is compatible with the pre-loophole implementation, and tests, but IIUC it violates strict aliasing unfortunately return cast_to_layout_compatible< std::underlying_type_t > - >(lvalue); + >(val); #if 0 // This "works", in that it's usable and it doesn't violate strict aliasing. // But it means we break compatibility and don't convert enum to underlying type. @@ -138,12 +139,12 @@ decltype(auto) tie_or_value(T&& lvalue, std::enable_if_t -decltype(auto) tie_or_value(T&& val, std::enable_if_t >::value && !std::is_enum< std::remove_reference_t >::value>* = 0) noexcept { - return std::forward(val); +decltype(auto) tie_or_value(lvalue_t val, std::enable_if_t >::value && !std::is_enum< std::remove_reference_t >::value>* = 0) noexcept { + return val; } template -auto tie_as_tuple_recursively_impl(T&& tup, std::index_sequence ) noexcept +auto tie_as_tuple_recursively_impl(lvalue_t tup, std::index_sequence ) noexcept -> sequence_tuple::tuple< decltype(boost::pfr::detail::tie_or_value( sequence_tuple::get(std::forward(tup)) @@ -152,21 +153,21 @@ auto tie_as_tuple_recursively_impl(T&& tup, std::index_sequence ) noexcept { return { boost::pfr::detail::tie_or_value( - sequence_tuple::get(std::forward(tup)) + sequence_tuple::get(tup) )... }; } template -auto tie_as_tuple_recursively(T&& tup) noexcept { +auto tie_as_tuple_recursively(rvalue_t tup) noexcept { using indexes = std::make_index_sequence; - return boost::pfr::detail::tie_as_tuple_recursively_impl(std::forward(tup), indexes{}); + return boost::pfr::detail::tie_as_tuple_recursively_impl(tup, indexes{}); } template -auto tie_as_flat_tuple(T&& t) { +auto tie_as_flat_tuple(lvalue_t t) { auto rec_tuples = boost::pfr::detail::tie_as_tuple_recursively( - boost::pfr::detail::tie_as_tuple_loophole_impl(std::forward(t)) + boost::pfr::detail::tie_as_tuple_loophole_impl(t) ); return boost::pfr::detail::make_flat_tuple_of_references( @@ -177,16 +178,16 @@ auto tie_as_flat_tuple(T&& t) { #if !BOOST_PFR_USE_CPP17 template -auto tie_as_tuple(T&& val) noexcept { +auto tie_as_tuple(lvalue_t val) noexcept { return boost::pfr::detail::tie_as_tuple_loophole_impl( - std::forward(val) + val ); } template -void for_each_field_dispatcher(T&& t, F&& f, std::index_sequence) { +void for_each_field_dispatcher(lvalue_t t, F&& f, std::index_sequence) { std::forward(f)( - boost::pfr::detail::tie_as_tuple_loophole_impl(std::forward(t)) + boost::pfr::detail::tie_as_tuple_loophole_impl(t) ); } diff --git a/include/boost/pfr/detail/core17.hpp b/include/boost/pfr/detail/core17.hpp index b81dff6..148f78c 100644 --- a/include/boost/pfr/detail/core17.hpp +++ b/include/boost/pfr/detail/core17.hpp @@ -9,6 +9,7 @@ #include #include +#include namespace boost { namespace pfr { namespace detail { @@ -45,9 +46,9 @@ static_assert( #endif // #ifndef _MSC_VER template -void for_each_field_dispatcher(T&& t, F&& f, std::index_sequence) { +void for_each_field_dispatcher(lvalue_t t, F&& f, std::index_sequence) { std::forward(f)( - detail::tie_as_tuple(std::forward(t)) + detail::tie_as_tuple(t) ); } diff --git a/include/boost/pfr/detail/core17_generated.hpp b/include/boost/pfr/detail/core17_generated.hpp index 3136dbc..c51af7e 100644 --- a/include/boost/pfr/detail/core17_generated.hpp +++ b/include/boost/pfr/detail/core17_generated.hpp @@ -20,12 +20,13 @@ #include #include +#include namespace boost { namespace pfr { namespace detail { template constexpr auto make_tuple_of_references(Args&&... args) noexcept { - return sequence_tuple::tuple{ std::forward(args)... }; + return sequence_tuple::tuple{ args... }; } template @@ -34,291 +35,291 @@ constexpr auto tie_as_tuple(T&& /*val*/, size_t_<0>) noexcept { } template -constexpr auto tie_as_tuple(T&& val, size_t_<1>, std::enable_if_t> >::value>* = 0) noexcept { - auto& [a] = std::forward(val); +constexpr auto tie_as_tuple(lvalue_t val, size_t_<1>, std::enable_if_t >::value>* = 0) noexcept { + auto& [a] = val; return ::boost::pfr::detail::make_tuple_of_references(a); } template -constexpr auto tie_as_tuple(T&& val, size_t_<1>, std::enable_if_t> >::value>* = 0) noexcept { - return ::boost::pfr::detail::make_tuple_of_references( std::forward(val) ); +constexpr auto tie_as_tuple(lvalue_t val, size_t_<1>, std::enable_if_t >::value>* = 0) 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] = std::forward(val); + auto& [a,b] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b); } template constexpr auto tie_as_tuple(T&& val, size_t_<3>) noexcept { - auto& [a,b,c] = std::forward(val); + auto& [a,b,c] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c); } template constexpr auto tie_as_tuple(T&& val, size_t_<4>) noexcept { - auto& [a,b,c,d] = std::forward(val); + auto& [a,b,c,d] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d); } template constexpr auto tie_as_tuple(T&& val, size_t_<5>) noexcept { - auto& [a,b,c,d,e] = std::forward(val); + auto& [a,b,c,d,e] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e); } template constexpr auto tie_as_tuple(T&& val, size_t_<6>) noexcept { - auto& [a,b,c,d,e,f] = std::forward(val); + auto& [a,b,c,d,e,f] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f); } template constexpr auto tie_as_tuple(T&& val, size_t_<7>) noexcept { - auto& [a,b,c,d,e,f,g] = std::forward(val); + auto& [a,b,c,d,e,f,g] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g); } template constexpr auto tie_as_tuple(T&& val, size_t_<8>) noexcept { - auto& [a,b,c,d,e,f,g,h] = std::forward(val); + auto& [a,b,c,d,e,f,g,h] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h); } template constexpr auto tie_as_tuple(T&& val, size_t_<9>) noexcept { - auto& [a,b,c,d,e,f,g,h,j] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j); } template constexpr auto tie_as_tuple(T&& val, size_t_<10>) noexcept { - auto& [a,b,c,d,e,f,g,h,j,k] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,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] = std::forward(val); + auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } 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] = std::forward(val); + 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] = val; return ::boost::pfr::detail::make_tuple_of_references(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); } @@ -327,7 +328,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -340,7 +341,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -353,7 +354,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -366,7 +367,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -379,7 +380,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -392,7 +393,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -405,7 +406,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -418,7 +419,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -431,7 +432,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -444,7 +445,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -457,7 +458,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -470,7 +471,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -483,7 +484,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -496,7 +497,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -509,7 +510,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -522,7 +523,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -535,7 +536,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -548,7 +549,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -561,7 +562,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -574,7 +575,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -587,7 +588,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -600,7 +601,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -613,7 +614,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -626,7 +627,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -639,7 +640,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -652,7 +653,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -665,7 +666,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -678,7 +679,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -691,7 +692,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -704,7 +705,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -717,7 +718,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -730,7 +731,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -743,7 +744,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -756,7 +757,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -769,7 +770,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -782,7 +783,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -795,7 +796,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -808,7 +809,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -821,7 +822,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -834,7 +835,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -847,7 +848,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -860,7 +861,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -873,7 +874,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -886,7 +887,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -899,7 +900,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -912,7 +913,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -925,7 +926,7 @@ 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -939,7 +940,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<95>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -954,7 +955,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<96>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -969,7 +970,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<97>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -984,7 +985,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<98>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -999,7 +1000,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<99>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -1014,7 +1015,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<100>) noexcept { 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 - ] = std::forward(val); + ] = val; return ::boost::pfr::detail::make_tuple_of_references( 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, @@ -1027,13 +1028,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<100>) noexcept { //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template -constexpr auto tie_as_tuple(const T& val) noexcept { - typedef size_t_()> fields_count_tag; - return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{}); -} - -template -constexpr auto tie_as_tuple(T& val) noexcept { +constexpr auto tie_as_tuple(lvalue_t val) noexcept { typedef size_t_()> fields_count_tag; return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{}); } diff --git a/include/boost/pfr/detail/for_each_field_impl.hpp b/include/boost/pfr/detail/for_each_field_impl.hpp index fe5e998..6dd2829 100644 --- a/include/boost/pfr/detail/for_each_field_impl.hpp +++ b/include/boost/pfr/detail/for_each_field_impl.hpp @@ -12,6 +12,7 @@ #include // metaprogramming stuff #include +#include namespace boost { namespace pfr { namespace detail { @@ -19,19 +20,29 @@ template using size_t_ = std::integral_constant; template ()(std::declval(), I{}))> -void for_each_field_impl(T&& v, F&& f, I i, long) { +void for_each_field_impl_apply(T&& v, F&& f, I i, long) { std::forward(f)(std::forward(v), i); } template -void for_each_field_impl(T&& v, F&& f, I /*i*/, int) { +void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) { std::forward(f)(std::forward(v)); } template -void for_each_field_impl(T&& t, F&& f, std::index_sequence) { +void for_each_field_impl(lvalue_t t, F&& f, std::index_sequence, std::false_type /*move_values*/) { const int v[] = {( - for_each_field_impl(sequence_tuple::get(t), std::forward(f), size_t_{}, 1L), + for_each_field_impl_apply(sequence_tuple::get(t), std::forward(f), size_t_{}, 1L), + 0 + )...}; + (void)v; +} + + +template +void for_each_field_impl(lvalue_t t, F&& f, std::index_sequence, std::true_type /*move_values*/) { + const int v[] = {( + for_each_field_impl_apply(sequence_tuple::get(std::move(t)), std::forward(f), size_t_{}, 1L), 0 )...}; (void)v; diff --git a/include/boost/pfr/detail/lr_value.hpp b/include/boost/pfr/detail/lr_value.hpp new file mode 100644 index 0000000..b535f67 --- /dev/null +++ b/include/boost/pfr/detail/lr_value.hpp @@ -0,0 +1,28 @@ +// Copyright (c) 2016-2017 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_LR_VALUE_HPP +#define BOOST_PFR_DETAIL_LR_VALUE_HPP +#pragma once + +// This header provides aliases rvalue_t and lvalue_t. +// +// Usage: template void foo(lvalue_t lvalue_possible_cv_qualified); +// +// Those are useful for +// * better type safety - you can validate at compile time that only l/rvalue reference is passed into the function +// * documentation and readability - lvalue_t is much better than T&& or T&&+SFINAE + +namespace boost { namespace pfr { namespace detail { + +/// Binds to rvalues +template using rvalue_t = T&&; + +/// Binds to const and non-const lvalues +template using lvalue_t = T&; + +}}} // namespace boost::pfr::detail + +#endif // BOOST_PFR_DETAIL_CONFIG_HPP diff --git a/include/boost/pfr/detail/make_flat_tuple_of_references.hpp b/include/boost/pfr/detail/make_flat_tuple_of_references.hpp index d0dbe3a..e2874b3 100644 --- a/include/boost/pfr/detail/make_flat_tuple_of_references.hpp +++ b/include/boost/pfr/detail/make_flat_tuple_of_references.hpp @@ -11,6 +11,7 @@ #include // metaprogramming stuff #include +#include namespace boost { namespace pfr { namespace detail { @@ -22,24 +23,24 @@ using size_t_ = std::integral_constant; // For user-defined structures, the getter should be "offset_based_getter" struct sequence_tuple_getter { template - decltype(auto) get(T && t, size_t_) const { - return sequence_tuple::get(std::forward(t)); + decltype(auto) get(lvalue_t t, size_t_) const noexcept { + return sequence_tuple::get(t); }; }; template -constexpr auto make_flat_tuple_of_references(Tuple&&, Getter&&, size_t_, size_t_) noexcept; +constexpr auto make_flat_tuple_of_references(lvalue_t, const Getter&, size_t_, size_t_) noexcept; template -constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(Tuple&&, Getter&&, size_t_, size_t_<0>) noexcept; +constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(lvalue_t, const Getter&, size_t_, size_t_<0>) noexcept; template -constexpr auto make_flat_tuple_of_references(Tuple&&, Getter&&, size_t_, size_t_<1>) noexcept; +constexpr auto make_flat_tuple_of_references(lvalue_t, const Getter&, size_t_, size_t_<1>) noexcept; template -constexpr auto tie_as_tuple_with_references(T&&... args) noexcept { - return sequence_tuple::tuple{ std::forward(args)... }; +constexpr auto tie_as_tuple_with_references(lvalue_t... args) noexcept { + return sequence_tuple::tuple{ args... }; } template @@ -69,23 +70,23 @@ constexpr auto my_tuple_cat(const Tuple1& t1, const Tuple2& t2) noexcept { } template -constexpr auto make_flat_tuple_of_references(Tuple&& t, Getter&& g, size_t_, size_t_) noexcept { +constexpr auto make_flat_tuple_of_references(lvalue_t t, const Getter& g, size_t_, size_t_) noexcept { constexpr std::size_t next_size = Size / 2; return my_tuple_cat( - make_flat_tuple_of_references(std::forward(t), std::forward(g), size_t_{}, size_t_{}), - make_flat_tuple_of_references(std::forward(t), std::forward(g), size_t_{}, size_t_{}) + make_flat_tuple_of_references(t, g, size_t_{}, size_t_{}), + make_flat_tuple_of_references(t, g, size_t_{}, size_t_{}) ); } template -constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(Tuple&&, Getter&&, size_t_, size_t_<0>) noexcept { +constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(lvalue_t, const Getter&, size_t_, size_t_<0>) noexcept { return {}; } template -constexpr auto make_flat_tuple_of_references(Tuple&& t, Getter&& g, size_t_, size_t_<1>) noexcept { +constexpr auto make_flat_tuple_of_references(lvalue_t t, const Getter& g, size_t_, size_t_<1>) noexcept { return tie_as_tuple_with_references( - std::forward(g).get(std::forward(t), size_t_{}) + g.get(t, size_t_{}) ); } diff --git a/include/boost/pfr/detail/offset_based_getter.hpp b/include/boost/pfr/detail/offset_based_getter.hpp index 4a1cbf6..185ea7d 100644 --- a/include/boost/pfr/detail/offset_based_getter.hpp +++ b/include/boost/pfr/detail/offset_based_getter.hpp @@ -12,6 +12,7 @@ #include #include #include +#include namespace boost { namespace pfr { namespace detail { @@ -121,14 +122,9 @@ public: return *this_t::get_pointer(std::addressof(u)); } - /* - This overload was similarly commented out in cast_to_layout_compatible - + // rvalues must no be used here, to avoid template instantiation bloats. template - index_t && get(U && u, size_t_) const noexcept { - return std::move(*this_t::get_pointer(std::addressof(u))); - } - */ + index_t && get(rvalue_t u, size_t_) const = delete; }; diff --git a/include/boost/pfr/flat/core.hpp b/include/boost/pfr/flat/core.hpp index 31f23f4..a3a1868 100644 --- a/include/boost/pfr/flat/core.hpp +++ b/include/boost/pfr/flat/core.hpp @@ -127,10 +127,12 @@ auto flat_structure_tie(T& val /* @cond */, std::enable_if_t< std::is_trivially_ /// \endcode template void flat_for_each_field(T&& value, F&& func) { + auto tup = detail::tie_as_flat_tuple(value); ::boost::pfr::detail::for_each_field_impl( - detail::tie_as_flat_tuple(std::forward(value)), + tup, std::forward(func), - std::make_index_sequence< flat_tuple_size_v >{} + std::make_index_sequence< flat_tuple_size_v >{}, + std::is_rvalue_reference{} ); } diff --git a/include/boost/pfr/precise/core.hpp b/include/boost/pfr/precise/core.hpp index 7234d2e..ef95e93 100644 --- a/include/boost/pfr/precise/core.hpp +++ b/include/boost/pfr/precise/core.hpp @@ -143,16 +143,17 @@ 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( - std::forward(value), + value, [f = std::forward(func)](auto&& t) mutable { // MSVC related workaround. It's 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( - std::forward(t), + t, std::forward(f), - std::make_index_sequence{} + std::make_index_sequence{}, + std::is_rvalue_reference{} ); }, std::make_index_sequence{} diff --git a/misc/generate_cpp17.py b/misc/generate_cpp17.py index 5795ca0..10d9369 100644 --- a/misc/generate_cpp17.py +++ b/misc/generate_cpp17.py @@ -35,12 +35,13 @@ PROLOGUE = """// Copyright (c) 2016-2017 Antony Polukhin #include #include +#include namespace boost { namespace pfr { namespace detail { template constexpr auto make_tuple_of_references(Args&&... args) noexcept { - return sequence_tuple::tuple{ std::forward(args)... }; + return sequence_tuple::tuple{ args... }; } template @@ -49,15 +50,15 @@ constexpr auto tie_as_tuple(T&& /*val*/, size_t_<0>) noexcept { } template -constexpr auto tie_as_tuple(T&& val, size_t_<1>, std::enable_if_t> >::value>* = 0) noexcept { - auto& [a] = std::forward(val); +constexpr auto tie_as_tuple(lvalue_t val, size_t_<1>, std::enable_if_t >::value>* = 0) noexcept { + auto& [a] = val; return ::boost::pfr::detail::make_tuple_of_references(a); } template -constexpr auto tie_as_tuple(T&& val, size_t_<1>, std::enable_if_t> >::value>* = 0) noexcept { - return ::boost::pfr::detail::make_tuple_of_references( std::forward(val) ); +constexpr auto tie_as_tuple(lvalue_t val, size_t_<1>, std::enable_if_t >::value>* = 0) noexcept { + return ::boost::pfr::detail::make_tuple_of_references( val ); } """ @@ -67,13 +68,7 @@ EPILOGUE = """ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template -constexpr auto tie_as_tuple(const T& val) noexcept { - typedef size_t_()> fields_count_tag; - return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{}); -} - -template -constexpr auto tie_as_tuple(T& val) noexcept { +constexpr auto tie_as_tuple(lvalue_t val) noexcept { typedef size_t_()> fields_count_tag; return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{}); } @@ -90,8 +85,8 @@ generate_sfinae_attempts = False if generate_sfinae_attempts: print """ template - constexpr auto tie_as_tuple(T&& val, size_t_) noexcept { - return tie_as_tuple( std::forward(val), size_t_{}); + constexpr auto tie_as_tuple(lvalue_t val, size_t_) noexcept { + return tie_as_tuple(val, size_t_{}); } """ @@ -113,12 +108,12 @@ for i in xrange(1, funcs_count): print "template " print "constexpr auto tie_as_tuple(T&& val, size_t_<" + str(i + 1) + ">) noexcept {" if i < max_args_on_a_line: - print " auto& [" + indexes.strip() + "] = std::forward(val);" + print " auto& [" + indexes.strip() + "] = val;" print " return ::boost::pfr::detail::make_tuple_of_references(" + indexes.strip() + ");" else: print " auto& [" print indexes - print " ] = std::forward(val);" + print " ] = val;" print "" print " return ::boost::pfr::detail::make_tuple_of_references(" print indexes