boost/pfr
2
0
Fork 0
mirror of https://github.com/boostorg/pfr.git synced 2026-01-19 04:22:13 +00:00
Code Issues Projects Releases Wiki Activity

GCC related fixes and simplifications

Browse Source
This commit is contained in:
Antony Polukhin
2017-10-20 14:26:07 +03:00
parent 8031f575fe
commit 72b69d3288
14 changed files with 196 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/boost/pfr/detail/cast_to_layout_compatible.hpp
View File

@@ -11,7 +11,7 @@
#include <type_traits>
#include <utility> // metaprogramming stuff
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -62,8 +62,10 @@ MAY_ALIAS To& cast_to_layout_compatible(From& val) noexcept {
return *t;
}
#ifdef BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING
template <class To, class From>
MAY_ALIAS To&& cast_to_layout_compatible(rvalue_t<From> val) = delete;
To&& cast_to_layout_compatible(rvalue_t<From> val) noexcept = delete;
#endif
#undef MAY_ALIAS

20
include/boost/pfr/detail/core14_classic.hpp
View File

@@ -17,7 +17,7 @@
#include <boost/pfr/detail/fields_count.hpp>
#include <boost/pfr/detail/make_flat_tuple_of_references.hpp>
#include <boost/pfr/detail/size_array.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
#ifdef __clang__
# pragma clang diagnostic push
@@ -536,7 +536,7 @@ constexpr bool is_flat_refelectable(std::index_sequence<I...>) noexcept {
}
template <class T>
auto tie_as_flat_tuple(lvalue_t<T> lvalue) noexcept {
auto tie_as_flat_tuple(T& lvalue) noexcept {
using type = std::remove_cv_t<T>;
using tuple_type = internal_tuple_with_same_alignment_t<type>;
@@ -547,7 +547,7 @@ auto tie_as_flat_tuple(lvalue_t<T> lvalue) noexcept {
#if !BOOST_PFR_USE_CPP17
template <class T>
auto tie_as_tuple(lvalue_t<T> val) noexcept {
auto tie_as_tuple(T& val) noexcept {
typedef T type;
static_assert(
boost::pfr::detail::is_flat_refelectable<type>( std::make_index_sequence<fields_count<type>()>{} ),
@@ -590,10 +590,10 @@ struct is_constexpr_aggregate_initializable { // TODO: try to fix it
template <class T, class F, std::size_t I0, std::size_t... I, class... Fields>
void for_each_field_in_depth(lvalue_t<T> t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...);
void for_each_field_in_depth(T& t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...);
template <class T, class F, class... Fields>
void for_each_field_in_depth(lvalue_t<T> t, F&& f, std::index_sequence<>, identity<Fields>...);
void for_each_field_in_depth(T& t, F&& f, std::index_sequence<>, identity<Fields>...);
template <class T, class F, class IndexSeq, class... Fields>
struct next_step {
@@ -615,7 +615,7 @@ struct next_step {
};
template <class T, class F, std::size_t I0, std::size_t... I, class... Fields>
void for_each_field_in_depth(lvalue_t<T> t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...) {
void for_each_field_in_depth(T& t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...) {
(void)std::add_const_t<std::remove_reference_t<T>>{
Fields{}...,
next_step<T, F, std::index_sequence<I...>, Fields...>{t, f},
@@ -624,7 +624,7 @@ void for_each_field_in_depth(lvalue_t<T> t, F&& f, std::index_sequence<I0, I...>
}
template <class T, class F, class... Fields>
void for_each_field_in_depth(lvalue_t<T> lvalue, F&& f, std::index_sequence<>, identity<Fields>...) {
void for_each_field_in_depth(T& lvalue, F&& f, std::index_sequence<>, identity<Fields>...) {
using tuple_type = sequence_tuple::tuple<Fields...>;
offset_based_getter<std::remove_cv_t<std::remove_reference_t<T>>, tuple_type> getter;
@@ -634,7 +634,7 @@ void for_each_field_in_depth(lvalue_t<T> lvalue, F&& f, std::index_sequence<>, i
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher_1(lvalue_t<T> t, F&& f, std::index_sequence<I...>, std::true_type /*is_flat_refelectable*/) {
void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence<I...>, std::true_type /*is_flat_refelectable*/) {
std::forward<F>(f)(
boost::pfr::detail::tie_as_flat_tuple(t)
);
@@ -642,7 +642,7 @@ void for_each_field_dispatcher_1(lvalue_t<T> t, F&& f, std::index_sequence<I...>
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher_1(lvalue_t<T> t, F&& f, std::index_sequence<I...>, std::false_type /*is_flat_refelectable*/) {
void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence<I...>, std::false_type /*is_flat_refelectable*/) {
boost::pfr::detail::for_each_field_in_depth(
t,
std::forward<F>(f),
@@ -651,7 +651,7 @@ void for_each_field_dispatcher_1(lvalue_t<T> t, F&& f, std::index_sequence<I...>
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(lvalue_t<T> t, F&& f, std::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
/// 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.
///

20
include/boost/pfr/detail/core14_loophole.hpp
View File

@@ -30,7 +30,7 @@
#include <boost/pfr/detail/fields_count.hpp>
#include <boost/pfr/detail/make_flat_tuple_of_references.hpp>
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
#ifdef __clang__
@@ -102,7 +102,7 @@ struct loophole_type_list< T, std::index_sequence<I...> >
template <class T>
auto tie_as_tuple_loophole_impl(lvalue_t<T> lvalue) noexcept {
auto tie_as_tuple_loophole_impl(T& lvalue) noexcept {
using type = std::remove_cv_t<std::remove_reference_t<T>>;
using indexes = std::make_index_sequence<fields_count<type>()>;
using tuple_type = typename loophole_type_list<type, indexes>::type;
@@ -119,14 +119,14 @@ auto tie_as_tuple_loophole_impl(lvalue_t<T> lvalue) noexcept {
template <class T> auto tie_as_tuple_recursively(rvalue_t<T> val) noexcept;
template <class T>
auto tie_or_value(lvalue_t<T> val, std::enable_if_t<std::is_class< std::remove_reference_t<T> >::value>* = 0) noexcept {
auto tie_or_value(T& val, std::enable_if_t<std::is_class< std::remove_reference_t<T> >::value>* = 0) noexcept {
return boost::pfr::detail::tie_as_tuple_recursively(
boost::pfr::detail::tie_as_tuple_loophole_impl(val)
);
}
template <class T>
decltype(auto) tie_or_value(lvalue_t<T> val, std::enable_if_t<std::is_enum<std::remove_reference_t<T>>::value>* = 0) noexcept {
decltype(auto) tie_or_value(T& val, std::enable_if_t<std::is_enum<std::remove_reference_t<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<std::remove_reference_t<T> >
@@ -139,15 +139,15 @@ decltype(auto) tie_or_value(lvalue_t<T> val, std::enable_if_t<std::is_enum<std::
}
template <class T>
decltype(auto) tie_or_value(lvalue_t<T> val, std::enable_if_t<!std::is_class< std::remove_reference_t<T> >::value && !std::is_enum< std::remove_reference_t<T> >::value>* = 0) noexcept {
decltype(auto) tie_or_value(T& val, std::enable_if_t<!std::is_class< std::remove_reference_t<T> >::value && !std::is_enum< std::remove_reference_t<T> >::value>* = 0) noexcept {
return val;
}
template <class T, std::size_t... I>
auto tie_as_tuple_recursively_impl(lvalue_t<T> tup, std::index_sequence<I...> ) noexcept
auto tie_as_tuple_recursively_impl(T& tup, std::index_sequence<I...> ) noexcept
-> sequence_tuple::tuple<
decltype(boost::pfr::detail::tie_or_value(
sequence_tuple::get<I>(std::forward<T>(tup))
sequence_tuple::get<I>(tup)
))...
>
{
@@ -165,7 +165,7 @@ auto tie_as_tuple_recursively(rvalue_t<T> tup) noexcept {
}
template <class T>
auto tie_as_flat_tuple(lvalue_t<T> t) {
auto tie_as_flat_tuple(T& t) {
auto rec_tuples = boost::pfr::detail::tie_as_tuple_recursively(
boost::pfr::detail::tie_as_tuple_loophole_impl(t)
);
@@ -178,14 +178,14 @@ auto tie_as_flat_tuple(lvalue_t<T> t) {
#if !BOOST_PFR_USE_CPP17
template <class T>
auto tie_as_tuple(lvalue_t<T> val) noexcept {
auto tie_as_tuple(T& val) noexcept {
return boost::pfr::detail::tie_as_tuple_loophole_impl(
val
);
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(lvalue_t<T> t, F&& f, std::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
std::forward<F>(f)(
boost::pfr::detail::tie_as_tuple_loophole_impl(t)
);

7
include/boost/pfr/detail/core17.hpp
View File

@@ -9,7 +9,7 @@
#include <boost/pfr/detail/core17_generated.hpp>
#include <boost/pfr/detail/for_each_field_impl.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -21,7 +21,8 @@ struct do_not_define_std_tuple_size_for_me {
template <class T>
constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
const auto& [a] = T{}; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
T val{};
const auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
/****************************************************************************
*
@@ -46,7 +47,7 @@ static_assert(
#endif // #ifndef _MSC_VER
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(lvalue_t<T> t, F&& f, std::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
std::forward<F>(f)(
detail::tie_as_tuple(t)
);

207
include/boost/pfr/detail/core17_generated.hpp
View File

@@ -20,7 +20,6 @@
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/fields_count.hpp>
#include <boost/pfr/detail/lr_value.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -30,301 +29,301 @@ constexpr auto make_tuple_of_references(Args&&... args) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& /*val*/, size_t_<0>) noexcept {
constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
return sequence_tuple::tuple<>{};
}
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
auto& [a] = val;
return ::boost::pfr::detail::make_tuple_of_references(a);
}
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
return ::boost::pfr::detail::make_tuple_of_references( val );
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<2>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<2>) noexcept {
auto& [a,b] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<3>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<3>) noexcept {
auto& [a,b,c] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<4>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<4>) noexcept {
auto& [a,b,c,d] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<5>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<5>) noexcept {
auto& [a,b,c,d,e] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<6>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<6>) noexcept {
auto& [a,b,c,d,e,f] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<7>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<7>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<8>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<8>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<9>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<9>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<10>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<10>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<11>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<11>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<12>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<12>) noexcept {
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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<13>) noexcept {
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] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<14>) noexcept {
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] = val;
return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<15>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<16>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<17>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<18>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<19>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<20>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<21>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<22>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<23>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<24>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<25>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<26>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<27>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<28>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<29>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<30>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<31>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<32>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<33>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<34>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<35>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<36>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<37>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<38>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<39>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<40>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<41>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<42>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<43>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<44>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<45>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<46>) noexcept {
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] = 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 <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<47>) noexcept {
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] = 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);
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<48>) noexcept {
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
@@ -337,7 +336,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<48>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<49>) noexcept {
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
@@ -350,7 +349,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<49>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<50>) noexcept {
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
@@ -363,7 +362,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<50>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<51>) noexcept {
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
@@ -376,7 +375,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<51>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<52>) noexcept {
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
@@ -389,7 +388,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<52>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<53>) noexcept {
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
@@ -402,7 +401,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<53>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<54>) noexcept {
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
@@ -415,7 +414,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<54>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<55>) noexcept {
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
@@ -428,7 +427,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<55>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<56>) noexcept {
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
@@ -441,7 +440,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<56>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<57>) noexcept {
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
@@ -454,7 +453,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<57>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<58>) noexcept {
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
@@ -467,7 +466,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<58>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<59>) noexcept {
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
@@ -480,7 +479,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<59>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<60>) noexcept {
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
@@ -493,7 +492,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<60>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<61>) noexcept {
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
@@ -506,7 +505,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<61>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<62>) noexcept {
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
@@ -519,7 +518,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<62>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<63>) noexcept {
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
@@ -532,7 +531,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<63>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<64>) noexcept {
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
@@ -545,7 +544,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<64>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<65>) noexcept {
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
@@ -558,7 +557,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<65>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<66>) noexcept {
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
@@ -571,7 +570,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<66>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<67>) noexcept {
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
@@ -584,7 +583,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<67>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<68>) noexcept {
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
@@ -597,7 +596,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<68>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<69>) noexcept {
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
@@ -610,7 +609,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<69>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<70>) noexcept {
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
@@ -623,7 +622,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<70>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<71>) noexcept {
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
@@ -636,7 +635,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<71>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<72>) noexcept {
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
@@ -649,7 +648,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<72>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<73>) noexcept {
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
@@ -662,7 +661,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<73>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<74>) noexcept {
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
@@ -675,7 +674,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<74>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<75>) noexcept {
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
@@ -688,7 +687,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<75>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<76>) noexcept {
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
@@ -701,7 +700,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<76>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<77>) noexcept {
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
@@ -714,7 +713,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<77>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<78>) noexcept {
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
@@ -727,7 +726,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<78>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<79>) noexcept {
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
@@ -740,7 +739,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<79>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<80>) noexcept {
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
@@ -753,7 +752,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<80>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<81>) noexcept {
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
@@ -766,7 +765,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<81>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<82>) noexcept {
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
@@ -779,7 +778,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<82>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<83>) noexcept {
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
@@ -792,7 +791,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<83>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<84>) noexcept {
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
@@ -805,7 +804,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<84>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<85>) noexcept {
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
@@ -818,7 +817,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<85>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<86>) noexcept {
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
@@ -831,7 +830,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<86>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<87>) noexcept {
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
@@ -844,7 +843,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<87>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<88>) noexcept {
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
@@ -857,7 +856,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<88>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<89>) noexcept {
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
@@ -870,7 +869,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<89>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<90>) noexcept {
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
@@ -883,7 +882,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<90>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<91>) noexcept {
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
@@ -896,7 +895,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<91>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<92>) noexcept {
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
@@ -909,7 +908,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<92>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<93>) noexcept {
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
@@ -922,7 +921,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<93>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<94>) noexcept {
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
@@ -935,7 +934,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<94>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<95>) noexcept {
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,
@@ -950,7 +949,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<95>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<96>) noexcept {
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,
@@ -965,7 +964,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<96>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<97>) noexcept {
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,
@@ -980,7 +979,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<97>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<98>) noexcept {
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,
@@ -995,7 +994,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<98>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<99>) noexcept {
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,
@@ -1010,7 +1009,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<99>) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& val, size_t_<100>) noexcept {
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,
@@ -1028,7 +1027,7 @@ constexpr auto tie_as_tuple(T&& val, size_t_<100>) noexcept {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val) noexcept {
constexpr auto tie_as_tuple(T& val) noexcept {
typedef size_t_<fields_count<T>()> fields_count_tag;
return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{});
}

6
include/boost/pfr/detail/for_each_field_impl.hpp
View File

@@ -12,7 +12,7 @@
#include <utility> // metaprogramming stuff
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -30,7 +30,7 @@ void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
}
template <class T, class F, std::size_t... I>
void for_each_field_impl(lvalue_t<T> t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
const int v[] = {(
for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
0
@@ -40,7 +40,7 @@ void for_each_field_impl(lvalue_t<T> t, F&& f, std::index_sequence<I...>, std::f
template <class T, class F, std::size_t... I>
void for_each_field_impl(lvalue_t<T> t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
const int v[] = {(
for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
0

7
include/boost/pfr/detail/io.hpp
View File

@@ -46,13 +46,6 @@ struct print_impl {
out << quoted_helper(boost::pfr::detail::sequence_tuple::get<I>(value));
print_impl<I + 1, N>::print(out, value);
}
template <class Stream, class T>
static void print (Stream& out, const std::string& value) {
if (!!I) out << ", ";
out << std::quoted( boost::pfr::detail::sequence_tuple::get<I>(value) );
print_impl<I + 1, N>::print(out, value);
}
};
template <std::size_t I>

28
include/boost/pfr/detail/lr_value.hpp
View File

@@ -1,28 +0,0 @@
// 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 <class T> void foo(lvalue_t<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<T> is much better than T&& or T&&+SFINAE
namespace boost { namespace pfr { namespace detail {
/// Binds to rvalues
template <class T> using rvalue_t = T&&;
/// Binds to const and non-const lvalues
template <class T> using lvalue_t = T&;
}}} // namespace boost::pfr::detail
#endif // BOOST_PFR_DETAIL_CONFIG_HPP

32
include/boost/pfr/detail/make_flat_tuple_of_references.hpp
View File

@@ -11,7 +11,7 @@
#include <utility> // metaprogramming stuff
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -22,24 +22,24 @@ using size_t_ = std::integral_constant<std::size_t, Index >;
// Helper: Make a "getter" object corresponding to built-in tuple::get
// For user-defined structures, the getter should be "offset_based_getter"
struct sequence_tuple_getter {
template <std::size_t idx, typename T>
decltype(auto) get(lvalue_t<T> t, size_t_<idx>) const noexcept {
template <std::size_t idx, typename TupleOfReferences>
decltype(auto) get(const TupleOfReferences& t, size_t_<idx>) const noexcept {
return sequence_tuple::get<idx>(t);
};
};
template <class Tuple, class Getter, std::size_t Begin, std::size_t Size>
constexpr auto make_flat_tuple_of_references(lvalue_t<Tuple>, const Getter&, size_t_<Begin>, size_t_<Size>) noexcept;
template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<Size>) noexcept;
template <class Tuple, class Getter, std::size_t Begin>
constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(lvalue_t<Tuple>, const Getter&, size_t_<Begin>, size_t_<0>) noexcept;
template <class TupleOrUserType, class Getter, std::size_t Begin>
constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept;
template <class Tuple, class Getter, std::size_t Begin>
constexpr auto make_flat_tuple_of_references(lvalue_t<Tuple>, const Getter&, size_t_<Begin>, size_t_<1>) noexcept;
template <class TupleOrUserType, class Getter, std::size_t Begin>
constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<1>) noexcept;
template <class... T>
constexpr auto tie_as_tuple_with_references(lvalue_t<T>... args) noexcept {
constexpr auto tie_as_tuple_with_references(T&... args) noexcept {
return sequence_tuple::tuple<T&...>{ args... };
}
@@ -69,8 +69,8 @@ constexpr auto my_tuple_cat(const Tuple1& t1, const Tuple2& t2) noexcept {
);
}
template <class Tuple, class Getter, std::size_t Begin, std::size_t Size>
constexpr auto make_flat_tuple_of_references(lvalue_t<Tuple> t, const Getter& g, size_t_<Begin>, size_t_<Size>) noexcept {
template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<Size>) noexcept {
constexpr std::size_t next_size = Size / 2;
return my_tuple_cat(
make_flat_tuple_of_references(t, g, size_t_<Begin>{}, size_t_<next_size>{}),
@@ -78,13 +78,13 @@ constexpr auto make_flat_tuple_of_references(lvalue_t<Tuple> t, const Getter& g,
);
}
template <class Tuple, class Getter, std::size_t Begin>
constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(lvalue_t<Tuple>, const Getter&, size_t_<Begin>, size_t_<0>) noexcept {
template <class TupleOrUserType, class Getter, std::size_t Begin>
constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept {
return {};
}
template <class Tuple, class Getter, std::size_t Begin>
constexpr auto make_flat_tuple_of_references(lvalue_t<Tuple> t, const Getter& g, size_t_<Begin>, size_t_<1>) noexcept {
template <class TupleOrUserType, class Getter, std::size_t Begin>
constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<1>) noexcept {
return tie_as_tuple_with_references(
g.get(t, size_t_<Begin>{})
);

2
include/boost/pfr/detail/offset_based_getter.hpp
View File

@@ -12,7 +12,7 @@
#include <type_traits>
#include <utility>
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/lr_value.hpp>
#include <boost/pfr/detail/rvalue_t.hpp>
namespace boost { namespace pfr { namespace detail {

35
include/boost/pfr/detail/rvalue_t.hpp Normal file
View File

@@ -0,0 +1,35 @@
// 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_RVALUE_T_HPP
#define BOOST_PFR_DETAIL_RVALUE_T_HPP
#pragma once
#include <type_traits>
#include <utility> // std::enable_if_t
// This header provides aliases rvalue_t and lvalue_t.
//
// Usage: template <class T> void foo(rvalue<T> rvalue);
//
// Those are useful for
// * better type safety - you can validate at compile time that only rvalue reference is passed into the function
// * documentation and readability - rvalue_t<T> is much better than T&&+SFINAE
namespace boost { namespace pfr { namespace detail {
/// Binds to rvalues only, no copying allowed.
template <class T
#ifdef BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING
, class = std::enable_if_t<std::is_rvalue_reference<T&&>::value>
#endif
>
using rvalue_t = T&&;
/// Binds to mutable lvalues only
}}} // namespace boost::pfr::detail
#endif // BOOST_PFR_DETAIL_RVALUE_T_HPP

3
include/boost/pfr/detail/sequence_tuple.hpp
View File

@@ -115,9 +115,6 @@ constexpr decltype(auto) get(tuple<T...>&& t) noexcept {
return get_impl<N>(std::move(t));
}
// TODO: Shouldn't this be std::remove_reference_t ??
// Or better, implemented using variadic templates to extract I'th parameter
// exactly?
template <std::size_t I, class T>
using tuple_element = std::remove_reference< decltype(
::boost::pfr::detail::sequence_tuple::get<I>( std::declval<T>() )

4
include/boost/pfr/flat/io.hpp
View File

@@ -59,7 +59,9 @@ void flat_read(std::basic_istream<Char, Traits>& in, T& value) {
char parenthis = {};
in >> parenthis;
if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
detail::read_impl<0, flat_tuple_size_v<T> >::read(in, detail::tie_as_flat_tuple(value));
auto tuple = detail::tie_as_flat_tuple(value);
detail::read_impl<0, flat_tuple_size_v<T> >::read(in, tuple);
in >> parenthis;
if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);

15
misc/generate_cpp17.py
View File

@@ -35,7 +35,6 @@ PROLOGUE = """// Copyright (c) 2016-2017 Antony Polukhin
#include <boost/pfr/detail/sequence_tuple.hpp>
#include <boost/pfr/detail/fields_count.hpp>
#include <boost/pfr/detail/lr_value.hpp>
namespace boost { namespace pfr { namespace detail {
@@ -45,19 +44,19 @@ constexpr auto make_tuple_of_references(Args&&... args) noexcept {
}
template <class T>
constexpr auto tie_as_tuple(T&& /*val*/, size_t_<0>) noexcept {
constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
return sequence_tuple::tuple<>{};
}
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
auto& [a] = val;
return ::boost::pfr::detail::make_tuple_of_references(a);
}
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
return ::boost::pfr::detail::make_tuple_of_references( val );
}
@@ -68,7 +67,7 @@ EPILOGUE = """
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T>
constexpr auto tie_as_tuple(lvalue_t<T> val) noexcept {
constexpr auto tie_as_tuple(T& val) noexcept {
typedef size_t_<fields_count<T>()> fields_count_tag;
return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{});
}
@@ -85,7 +84,7 @@ generate_sfinae_attempts = False
if generate_sfinae_attempts:
print """
template <class T, std::size_t I>
constexpr auto tie_as_tuple(lvalue_t<T> val, size_t_<I>) noexcept {
constexpr auto tie_as_tuple(T& val, size_t_<I>) noexcept {
return tie_as_tuple(val, size_t_<I - 1>{});
}
"""
@@ -106,7 +105,7 @@ for i in xrange(1, funcs_count):
indexes += ascii_letters[i % max_args_on_a_line]
print "template <class T>"
print "constexpr auto tie_as_tuple(T&& val, size_t_<" + str(i + 1) + ">) noexcept {"
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() + "] = val;"
print " return ::boost::pfr::detail::make_tuple_of_references(" + indexes.strip() + ");"
@@ -123,7 +122,7 @@ for i in xrange(1, funcs_count):
if generate_sfinae_attempts:
print "template <class T>"
print "constexpr auto tie_as_tuple(T&& val, size_t_<" + str(i + 1) + "> v) noexcept"
print "constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + "> v) noexcept"
print " ->decltype( ::boost::pfr::detail::tie_as_tuple0(std::forward<T>(val), v) )"
print "{ return ::boost::pfr::detail::tie_as_tuple0(std::forward<T>(val), v); }\n"