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

Revert "use our own index_sequence"

Browse Source 
This reverts commit 5365521f8f.
This commit is contained in:
Antony Polukhin
2018-11-23 23:20:42 +03:00
parent 5365521f8f
commit 5bcbfa810d
9 changed files with 38 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -350,7 +350,7 @@ constexpr size_array<N> get_type_offsets() noexcept {
///////////////////// Returns array of typeids and zeros if construtor of a type accepts sizeof...(I) parameters
template <class T, std::size_t N, std::size_t... I>
constexpr void* flat_type_to_array_of_type_ids(std::size_t* types, detail::index_sequence<I...>) noexcept
constexpr void* flat_type_to_array_of_type_ids(std::size_t* types, std::index_sequence<I...>) noexcept
{
static_assert(
N <= sizeof(T),
@@ -394,16 +394,16 @@ constexpr auto flat_array_of_type_ids() noexcept {
///////////////////// Convert array of typeids into sequence_tuple::tuple
template <class T, std::size_t First, std::size_t... I>
constexpr auto as_flat_tuple_impl(detail::index_sequence<First, I...>) noexcept;
constexpr auto as_flat_tuple_impl(std::index_sequence<First, I...>) noexcept;
template <class T>
constexpr sequence_tuple::tuple<> as_flat_tuple_impl(detail::index_sequence<>) noexcept {
constexpr sequence_tuple::tuple<> as_flat_tuple_impl(std::index_sequence<>) noexcept {
return sequence_tuple::tuple<>{};
}
template <std::size_t Increment, std::size_t... I>
constexpr auto increment_index_sequence(detail::index_sequence<I...>) noexcept {
return detail::index_sequence<I + Increment...>{};
constexpr auto increment_index_sequence(std::index_sequence<I...>) noexcept {
return std::index_sequence<I + Increment...>{};
}
template <class T, std::size_t V, std::size_t I, std::size_t SubtupleLength>
@@ -455,7 +455,7 @@ constexpr size_array<N> resize_dropping_zeros_and_decrementing(size_t_<N>, const
}
template <class T, std::size_t First, std::size_t... I, std::size_t... INew>
constexpr auto as_flat_tuple_impl_drop_helpers(detail::index_sequence<First, I...>, detail::index_sequence<INew...>) noexcept {
constexpr auto as_flat_tuple_impl_drop_helpers(std::index_sequence<First, I...>, std::index_sequence<INew...>) noexcept {
constexpr auto a = detail::flat_array_of_type_ids<T>();
constexpr size_array<sizeof...(I) + 1> subtuples_length {{
@@ -494,12 +494,12 @@ constexpr std::size_t count_skips_in_array(std::size_t begin_index, std::size_t
}
template <class T, std::size_t First, std::size_t... I>
constexpr auto as_flat_tuple_impl(detail::index_sequence<First, I...>) noexcept {
constexpr auto as_flat_tuple_impl(std::index_sequence<First, I...>) noexcept {
constexpr auto a = detail::flat_array_of_type_ids<T>();
constexpr std::size_t count_of_I = sizeof...(I);
return detail::as_flat_tuple_impl_drop_helpers<T>(
detail::index_sequence<First, I...>{},
std::index_sequence<First, I...>{},
detail::make_index_sequence< 1 + count_of_I - count_skips_in_array(First, First + count_of_I, a) >{}
);
}
@@ -533,7 +533,7 @@ struct ubiq_is_flat_refelectable {
};
template <class T, std::size_t... I>
constexpr bool is_flat_refelectable(detail::index_sequence<I...>) noexcept {
constexpr bool is_flat_refelectable(std::index_sequence<I...>) noexcept {
constexpr std::size_t fields = sizeof...(I);
bool result[fields] = {static_cast<bool>(I)...};
const T v{ ubiq_is_flat_refelectable{result[I]}... };
@@ -610,10 +610,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(T& t, F&& f, detail::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(T& t, F&& f, detail::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 {
@@ -635,16 +635,16 @@ struct next_step {
};
template <class T, class F, std::size_t I0, std::size_t... I, class... Fields>
void for_each_field_in_depth(T& t, F&& f, detail::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, detail::index_sequence<I...>, Fields...>{t, f},
next_step<T, F, std::index_sequence<I...>, Fields...>{t, f},
ubiq_constructor_constexpr_copy{I}...
};
}
template <class T, class F, class... Fields>
void for_each_field_in_depth(T& lvalue, F&& f, detail::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;
@@ -654,7 +654,7 @@ void for_each_field_in_depth(T& lvalue, F&& f, detail::index_sequence<>, identit
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher_1(T& t, F&& f, detail::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)
);
@@ -662,16 +662,16 @@ void for_each_field_dispatcher_1(T& t, F&& f, detail::index_sequence<I...>, std:
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher_1(T& t, F&& f, detail::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),
detail::index_sequence<I...>{}
std::index_sequence<I...>{}
);
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(T& t, F&& f, detail::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
static_assert(
!std::is_union<T>::value,
"====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
@@ -687,11 +687,11 @@ void for_each_field_dispatcher(T& t, F&& f, detail::index_sequence<I...>) {
//static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");
constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable<T>( detail::index_sequence<I...>{} );
constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable<T>( std::index_sequence<I...>{} );
detail::for_each_field_dispatcher_1(
t,
std::forward<F>(f),
detail::index_sequence<I...>{},
std::index_sequence<I...>{},
std::integral_constant<bool, is_flat_refelectable_val>{}
);
}

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

@@ -94,7 +94,7 @@ template <class T, class U>
struct loophole_type_list;
template <typename T, std::size_t... I>
struct loophole_type_list< T, detail::index_sequence<I...> >
struct loophole_type_list< T, std::index_sequence<I...> >
// Instantiating loopholes:
: sequence_tuple::tuple< decltype(T{ loophole_ubiq<T, I>{}... }, 0) >
{
@@ -154,7 +154,7 @@ decltype(auto) tie_or_value(T& val, std::enable_if_t<!std::is_class< std::remove
}
template <class T, std::size_t... I>
auto tie_as_tuple_recursively_impl(T& tup, detail::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>(tup)
@@ -203,7 +203,7 @@ auto tie_as_tuple(T& val) noexcept {
}
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(T& t, F&& f, detail::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
static_assert(
!std::is_union<T>::value,
"====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."

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

@@ -45,7 +45,7 @@ static_assert(
#endif // #ifndef _MSC_VER
template <class T, class F, std::size_t... I>
void for_each_field_dispatcher(T& t, F&& f, detail::index_sequence<I...>) {
void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
static_assert(
!std::is_union<T>::value,
"====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."

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

@@ -66,7 +66,7 @@ template <class T> struct is_single_field_and_aggregate_initializable<1, T>: std
template <class T, std::size_t N>
struct is_aggregate_initializable_n {
template <std::size_t ...I>
static constexpr bool is_not_constructible_n(detail::index_sequence<I...>) noexcept {
static constexpr bool is_not_constructible_n(std::index_sequence<I...>) noexcept {
return (!std::is_constructible<T, decltype(ubiq_lref_constructor{I})...>::value && !std::is_constructible<T, decltype(ubiq_rref_constructor{I})...>::value)
|| is_single_field_and_aggregate_initializable<N, T>::value
;
@@ -82,11 +82,11 @@ struct is_aggregate_initializable_n {
///////////////////// Helper for SFINAE on fields count
template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
constexpr auto enable_if_constructible_helper(detail::index_sequence<I...>) noexcept
constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
-> typename std::add_pointer<decltype(T{ ubiq_lref_constructor{I}... })>::type;
template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<!std::is_copy_constructible<T>::value>::type>
constexpr auto enable_if_constructible_helper(detail::index_sequence<I...>) noexcept
constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
-> typename std::add_pointer<decltype(T{ ubiq_rref_constructor{I}... })>::type;
template <class T, std::size_t N, class /*Enable*/ = decltype( enable_if_constructible_helper<T>(detail::make_index_sequence<N>()) ) >

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

@@ -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(T& t, F&& f, detail::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[] = {(
detail::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(T& t, F&& f, detail::index_sequence<I...>, std::false_t
template <class T, class F, std::size_t... I>
void for_each_field_impl(T& t, F&& f, detail::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[] = {(
detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
0

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

@@ -55,7 +55,7 @@ constexpr decltype(auto) tie_as_tuple_with_references(const detail::sequence_tup
}
template <class Tuple1, std::size_t... I1, class Tuple2, std::size_t... I2>
constexpr auto my_tuple_cat_impl(const Tuple1& t1, detail::index_sequence<I1...>, const Tuple2& t2, detail::index_sequence<I2...>) noexcept {
constexpr auto my_tuple_cat_impl(const Tuple1& t1, std::index_sequence<I1...>, const Tuple2& t2, std::index_sequence<I2...>) noexcept {
return detail::tie_as_tuple_with_references(
sequence_tuple::get<I1>(t1)...,
sequence_tuple::get<I2>(t2)...

13
include/boost/pfr/detail/make_integer_sequence.hpp
View File

@@ -45,8 +45,8 @@ template <typename T, typename U>
struct join_sequences;
template <typename T, T... A, T... B>
struct join_sequences<integer_sequence<T, A...>, integer_sequence<T, B...>> {
using type = integer_sequence<T, A..., B...>;
struct join_sequences<std::integer_sequence<T, A...>, std::integer_sequence<T, B...>> {
using type = std::integer_sequence<T, A..., B...>;
};
template <typename T, T Min, T Max>
@@ -61,7 +61,7 @@ struct build_sequence_impl {
template <typename T, T V>
struct build_sequence_impl<T, V, V> {
using type = integer_sequence<T, V>;
using type = std::integer_sequence<T, V>;
};
template <typename T, std::size_t N>
@@ -69,7 +69,7 @@ struct make_integer_sequence_impl : build_sequence_impl<T, 0, N - 1> {};
template <typename T>
struct make_integer_sequence_impl<T, 0> {
using type = integer_sequence<T>;
using type = std::integer_sequence<T>;
};
template <typename T, T N>
@@ -78,16 +78,11 @@ using make_integer_sequence = typename make_integer_sequence_impl<T, N>::type;
#endif // !defined BOOST_PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
#else // BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
using std::integer_sequence;
template <typename T, T N>
using make_integer_sequence = std::make_integer_sequence<T, N>;
#endif // BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
template <std::size_t... I>
using index_sequnece = integer_sequence<std::size_t, I...>;
template <std::size_t N>
using make_index_sequence = make_integer_sequence<std::size_t, N>;

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

@@ -27,7 +27,7 @@ struct tuple_base;
template <std::size_t... I, class ...Tail>
struct tuple_base< detail::index_sequence<I...>, Tail... >
struct tuple_base< std::index_sequence<I...>, Tail... >
: base_from_member<I , Tail>...
{
static constexpr std::size_t size_v = sizeof...(I);
@@ -44,7 +44,7 @@ struct tuple_base< detail::index_sequence<I...>, Tail... >
};
template <>
struct tuple_base<detail::index_sequence<> > {
struct tuple_base<std::index_sequence<> > {
static constexpr std::size_t size_v = 0;
};

4
include/boost/pfr/detail/stdtuple.hpp
View File

@@ -17,14 +17,14 @@
namespace boost { namespace pfr { namespace detail {
template <class T, std::size_t... I>
constexpr auto make_stdtuple_from_tietuple(const T& t, detail::index_sequence<I...>) noexcept {
constexpr auto make_stdtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
return std::make_tuple(
boost::pfr::detail::sequence_tuple::get<I>(t)...
);
}
template <class T, std::size_t... I>
constexpr auto make_stdtiedtuple_from_tietuple(const T& t, detail::index_sequence<I...>) noexcept {
constexpr auto make_stdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
return std::tie(
boost::pfr::detail::sequence_tuple::get<I>(t)...
);