feedc0de/boost_mp11
1
0
Fork 0
forked from boostorg/mp11
Code Pull Requests Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Peter Dimov
2023-12-31 14:16:37 +02:00
parent 2e6800967a 20fff14a90
commit 863d8b8d2b
20 changed files with 1062 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
doc/mp11/algorithm.adoc
View File

@@ -19,6 +19,10 @@ http://www.boost.org/LICENSE_1_0.txt
`mp_transform<F, L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` applies `F` to each successive tuple of elements and returns `L1<F<T1, T2, ..., Tn>...>`.
Has limited support of value lists as `L...` under {cpp}17 (for one to three lists.)
In that case, elements are wrapped with `mp_value` before being passed to `F`, and
are unwrapped afterwards. The result is `L1<F<mp_value<T1>, mp_value<T2>, ...>::value...>`.
.Using mp_transform to produce a list of pointers from a list of pointees
```
template<class T> using add_pointer_t =
@@ -414,6 +418,28 @@ Supports a value list as `L` under {cpp}17.
Same as `mp_take_c`, but with a type argument `N`. `N::value` must be a nonnegative number.
## mp_slice_c<L, I, J>
template<class L, std::size_t I, std::size_t J> using mp_slice_c = mp_drop_c<mp_take_c<L, J>, I>;
`mp_slice_c<L, I, J>` returns a list of the same form as `L` containing the elements from index `I` (inclusive) to index `J` (exclusive).
Supports a value list as `L` under {cpp}17.
.mp_slice_c
[cols="<.^4m,8*^.^1m",width=85%]
|===
|*L1*|A~0~|...|A~i~|...|A~j-1~|A~j~|...|A~n-1~
9+|
|*mp_slice_c<L1, I, J>* 2+>||A~i~|...|A~j-1~ 3+|
|===
## mp_slice<L, I, J>
template<class L, class I, class J> using mp_slice = mp_drop<mp_take<L, J>, I>;
Same as `mp_slice_c`, but with type arguments `I` and `J`. `I::value` and `J::value` must be nonnegative numbers.
## mp_back<L>
template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
@@ -699,6 +725,8 @@ Like `mp_nth_element`, but takes a quoted metafunction.
It's equivalent to `mp_fold<mp_rest<L>, mp_first<L>, F>`, where `F<T, U>` returns `mp_if<P<T, U>, T, U>`.
Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.
## mp_min_element_q<L, Q>
template<class L, class Q> using mp_min_element_q = mp_min_element<L, Q::template fn>;
@@ -713,6 +741,8 @@ As `mp_min_element`, but takes a quoted metafunction.
It's equivalent to `mp_fold<mp_rest<L>, mp_first<L>, F>`, where `F<T, U>` returns `mp_if<P<U, T>, T, U>`.
Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.
## mp_max_element_q<L, Q>
template<class L, class Q> using mp_max_element_q = mp_max_element<L, Q::template fn>;
@@ -846,6 +876,39 @@ template<class L, template<class...> class P> using is_sorted =
mp_none_of<mp_pairwise_fold_q<L, mp_bind<P, _2, _1>>, mp_to_bool>;
----
## mp_sliding_fold<L, N, F>
template<class L, class N, template<class...> class F> using mp_sliding_fold = /*...*/;
`mp_sliding_fold<L, N, F>` returns a list of the same form as `L` whose elements are
the result of the application of the n-ary metafunction `F` to each n-tuple of adjacent
elements of `L`. That is, `mp_sliding_fold<L<T1, T2, T3, T4>, mp_size_t<3>, F>` is
`L<F<T1, T2, T3>, F<T2, T3, T4>>`.
The result has `N-1` fewer elements than the original.
If `L` has fewer than `N::value` elements, the result is an empty list.
.Using mp_sliding_fold
----
template<class L, class N> using local_maximum =
mp_sliding_fold<L, N, mp_max>;
----
## mp_sliding_fold_q<L, N, Q>
template<class L, class N, class Q> using mp_sliding_fold_q =
mp_sliding_fold<L, N, Q::template fn>;
As `mp_sliding_fold`, but takes a quoted metafunction.
.Using mp_sliding_fold_q
----
struct average { template<class... C> using fn = mp_int<mp_plus<C...>::value / sizeof...(C)>; };
template<class L, class N> using moving_average =
mp_sliding_fold_q<L, N, average>;
----
## mp_iterate<V, F, R>
template<class V, template<class...> class F, template<class...> class R>

9
doc/mp11/changelog.adoc
View File

@@ -1,5 +1,5 @@
////
Copyright 2019-2020 Peter Dimov
Copyright 2019-2023 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
@@ -10,6 +10,13 @@ http://www.boost.org/LICENSE_1_0.txt
[#changelog]
# Revision History
## Changes in 1.85.0
* Added `mp_sliding_fold`, a generalization of `mp_pairwise_fold` (contributed by Braden Ganetsky)
* Added `mp_slice` (thanks to Braden Ganetsky)
* Added value list support to `mp_min_element`, `mp_max_element`.
* Added limited value list support to `mp_transform`.
## Changes in 1.83.0
* Added an offset/from parameter to `mp_from_sequence`, `mp_iota`, `mp_iota_c`.

59
include/boost/mp11/algorithm.hpp
View File

@@ -26,6 +26,11 @@
#include <type_traits>
#include <utility>
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma push_macro( "I" )
# undef I
#endif
namespace boost
{
namespace mp11
@@ -84,6 +89,25 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
#endif
};
#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
template<template<class...> class F, template<auto...> class L, auto... A> struct mp_transform_impl<F, L<A...>>
{
using type = L< F< mp_value<A> >::value... >;
};
template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2> struct mp_transform_impl<F, L1<A1...>, L2<A2...>>
{
using type = L1< F< mp_value<A1>, mp_value<A2> >::value... >;
};
template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2, template<auto...> class L3, auto... A3> struct mp_transform_impl<F, L1<A1...>, L2<A2...>, L3<A3...>>
{
using type = L1< F< mp_value<A1>, mp_value<A2>, mp_value<A3> >::value... >;
};
#endif
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
@@ -473,6 +497,10 @@ struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typen
template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;
// mp_slice(_c)<L, I, J>
template<class L, std::size_t I, std::size_t J> using mp_slice_c = mp_drop_c< mp_take_c<L, J>, I >;
template<class L, class I, class J> using mp_slice = mp_drop< mp_take<L, J>, I >;
// mp_back<L>
template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
@@ -1261,6 +1289,33 @@ template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_po
template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
// mp_sliding_fold<L, N, F>
namespace detail
{
template<class C, class L, class Q, class S> struct mp_sliding_fold_impl;
template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_true, L, N, Q>
{
static const std::size_t M = mp_size<L>::value - N::value + 1;
template<class I> using F = mp_slice_c<L, I::value, I::value + M>;
using J = mp_transform<F, mp_iota<N>>;
using type = mp_apply<mp_transform_q, mp_push_front<J, Q>>;
};
template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_false, L, N, Q>
{
using type = mp_clear<L>;
};
} // namespace detail
template<class L, class N, class Q> using mp_sliding_fold_q = typename detail::mp_sliding_fold_impl<mp_bool<(mp_size<L>::value >= N::value)>, L, N, Q>::type;
template<class L, class N, template<class...> class F> using mp_sliding_fold = mp_sliding_fold_q<L, N, mp_quote<F>>;
// mp_intersperse<L, S>
namespace detail
{
@@ -1324,4 +1379,8 @@ template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L,
} // namespace mp11
} // namespace boost
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma pop_macro( "I" )
#endif
#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED

9
include/boost/mp11/bind.hpp
View File

@@ -12,6 +12,11 @@
#include <boost/mp11/utility.hpp>
#include <cstddef>
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma push_macro( "I" )
# undef I
#endif
namespace boost
{
namespace mp11
@@ -108,4 +113,8 @@ template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
} // namespace mp11
} // namespace boost
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma pop_macro( "I" )
#endif
#endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED

4
include/boost/mp11/detail/mp_fold.hpp
View File

@@ -10,6 +10,8 @@
#include <boost/mp11/detail/config.hpp>
#include <boost/mp11/detail/mp_defer.hpp>
#include <boost/mp11/detail/mp_rename.hpp>
#include <boost/mp11/detail/mp_list.hpp>
namespace boost
{
@@ -155,7 +157,7 @@ struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
} // namespace detail
template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<mp_rename<L, mp_list>, V, F>::type;
template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;
} // namespace mp11

9
include/boost/mp11/integer_sequence.hpp
View File

@@ -11,6 +11,11 @@
#include <boost/mp11/version.hpp>
#include <cstddef>
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma push_macro( "I" )
# undef I
#endif
#if defined(__has_builtin)
# if __has_builtin(__make_integer_seq)
# define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
@@ -109,4 +114,8 @@ template<class... T> using index_sequence_for = make_integer_sequence<std::size_
} // namespace mp11
} // namespace boost
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma pop_macro( "I" )
#endif
#endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED

9
include/boost/mp11/integral.hpp
View File

@@ -13,6 +13,11 @@
#include <type_traits>
#include <cstddef>
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma push_macro( "I" )
# undef I
#endif
namespace boost
{
namespace mp11
@@ -39,4 +44,8 @@ template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>
} // namespace mp11
} // namespace boost
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma pop_macro( "I" )
#endif
#endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED

9
include/boost/mp11/list.hpp
View File

@@ -19,6 +19,11 @@
#include <boost/mp11/detail/config.hpp>
#include <type_traits>
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma push_macro( "I" )
# undef I
#endif
namespace boost
{
namespace mp11
@@ -469,4 +474,8 @@ template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q:
} // namespace mp11
} // namespace boost
#if defined(_MSC_VER) || defined(__GNUC__)
# pragma pop_macro( "I" )
#endif
#endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED

11
test/Jamfile
View File

@@ -23,6 +23,7 @@ project
# include-only
compile mp11.cpp ;
compile complex_h.cpp ;
# list
run mp_size.cpp ;
@@ -73,7 +74,9 @@ run mp_is_value_list.cpp ;
# algorithm
run mp_transform.cpp ;
run mp_transform_2.cpp ;
run mp_transform_q.cpp ;
run mp_transform_q_2.cpp ;
run mp_transform_sf.cpp ;
run mp_transform_if.cpp ;
run mp_transform_if_q.cpp ;
@@ -99,6 +102,8 @@ run mp_at_2.cpp ;
run mp_at_sf.cpp : : : <toolset>gcc-4.7:<warnings>all ;
run mp_take.cpp ;
run mp_take_2.cpp ;
run mp_slice.cpp ;
run mp_slice_2.cpp ;
run mp_replace.cpp ;
run mp_replace_if.cpp ;
run mp_replace_if_q.cpp ;
@@ -141,9 +146,13 @@ run mp_with_index_cx.cpp ;
run mp_from_sequence.cpp ;
run mp_from_sequence_2.cpp ;
run mp_min_element.cpp ;
run mp_min_element_2.cpp ;
run mp_min_element_q.cpp ;
run mp_min_element_q_2.cpp ;
run mp_max_element.cpp ;
run mp_max_element_2.cpp ;
run mp_max_element_q.cpp ;
run mp_max_element_q_2.cpp ;
run mp_nth_element.cpp ;
run mp_nth_element_q.cpp ;
run mp_back.cpp ;
@@ -158,6 +167,8 @@ run mp_partial_sum.cpp ;
run mp_iterate.cpp ;
run mp_pairwise_fold.cpp ;
run mp_pairwise_fold_q.cpp ;
run mp_sliding_fold.cpp ;
run mp_sliding_fold_q.cpp ;
run mp_intersperse.cpp ;
run mp_split.cpp ;
run mp_join.cpp ;

12
test/complex_h.cpp Normal file
View File

@@ -0,0 +1,12 @@
// Copyright 2023 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
#include <complex.h>
#include <boost/mp11.hpp>
int main()
{
}

58
test/mp_max_element_2.cpp Normal file
View File

@@ -0,0 +1,58 @@
// Copyright 2017, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
#include <boost/core/lightweight_test_trait.hpp>
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_max_element;
using boost::mp11::mp_less;
using boost::mp11::mp_int;
{
using L1 = V1<1>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L1, mp_less>, mp_int<1>);
using L2 = V1<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L2, mp_less>, mp_int<4>);
using L3 = V1<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L3, mp_less>, mp_int<3>);
using L4 = V1<-1, 1u, -2, 2u>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L4, mp_less>, std::integral_constant<unsigned, 2>);
}
{
using L1 = V2<1>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L1, mp_less>, mp_int<1>);
using L2 = V2<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L2, mp_less>, mp_int<4>);
using L3 = V2<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L3, mp_less>, mp_int<3>);
using L4 = V2<-1, 1, -2, 2>;
BOOST_TEST_TRAIT_SAME(mp_max_element<L4, mp_less>, mp_int<2>);
}
return boost::report_errors();
}
#endif

61
test/mp_max_element_q_2.cpp Normal file
View File

@@ -0,0 +1,61 @@
// Copyright 2017, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
#include <boost/core/lightweight_test_trait.hpp>
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_max_element_q;
using boost::mp11::mp_less;
using boost::mp11::mp_int;
using boost::mp11::mp_quote;
using Q = mp_quote<mp_less>;
{
using L1 = V1<1>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L1, Q>, mp_int<1>);
using L2 = V1<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L2, Q>, mp_int<4>);
using L3 = V1<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L3, Q>, mp_int<3>);
using L4 = V1<-1, 1u, -2, 2u>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L4, Q>, std::integral_constant<unsigned, 2>);
}
{
using L1 = V2<1>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L1, Q>, mp_int<1>);
using L2 = V2<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L2, Q>, mp_int<4>);
using L3 = V2<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L3, Q>, mp_int<3>);
using L4 = V2<-1, 1, -2, 2>;
BOOST_TEST_TRAIT_SAME(mp_max_element_q<L4, Q>, mp_int<2>);
}
return boost::report_errors();
}
#endif

58
test/mp_min_element_2.cpp Normal file
View File

@@ -0,0 +1,58 @@
// Copyright 2017, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
#include <boost/core/lightweight_test_trait.hpp>
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_min_element;
using boost::mp11::mp_less;
using boost::mp11::mp_int;
{
using L1 = V1<1>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L1, mp_less>, mp_int<1>);
using L2 = V1<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L2, mp_less>, mp_int<1>);
using L3 = V1<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L3, mp_less>, mp_int<1>);
using L4 = V1<-1, 1u, -2, 2u>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L4, mp_less>, mp_int<-2>);
}
{
using L1 = V2<1>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L1, mp_less>, mp_int<1>);
using L2 = V2<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L2, mp_less>, mp_int<1>);
using L3 = V2<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L3, mp_less>, mp_int<1>);
using L4 = V2<-1, 1, -2, 2>;
BOOST_TEST_TRAIT_SAME(mp_min_element<L4, mp_less>, mp_int<-2>);
}
return boost::report_errors();
}
#endif

61
test/mp_min_element_q_2.cpp Normal file
View File

@@ -0,0 +1,61 @@
// Copyright 2017, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
#include <boost/core/lightweight_test_trait.hpp>
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_min_element_q;
using boost::mp11::mp_less;
using boost::mp11::mp_int;
using boost::mp11::mp_quote;
using Q = mp_quote<mp_less>;
{
using L1 = V1<1>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L1, Q>, mp_int<1>);
using L2 = V1<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L2, Q>, mp_int<1>);
using L3 = V1<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L3, Q>, mp_int<1>);
using L4 = V1<-1, 1u, -2, 2u>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L4, Q>, mp_int<-2>);
}
{
using L1 = V2<1>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L1, Q>, mp_int<1>);
using L2 = V2<2, 4, 3, 1>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L2, Q>, mp_int<1>);
using L3 = V2<2, 1, 2, 3>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L3, Q>, mp_int<1>);
using L4 = V2<-1, 1, -2, 2>;
BOOST_TEST_TRAIT_SAME(mp_min_element_q<L4, Q>, mp_int<-2>);
}
return boost::report_errors();
}
#endif

118
test/mp_slice.cpp Normal file
View File

@@ -0,0 +1,118 @@
// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
//
// 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
#include <boost/core/lightweight_test_trait.hpp>
#include <boost/mp11/algorithm.hpp>
#include <type_traits>
#include <tuple>
#include <utility>
int main()
{
using boost::mp11::mp_list;
using boost::mp11::mp_size_t;
using boost::mp11::mp_slice_c;
using boost::mp11::mp_slice;
{
using L1 = mp_list<int[], void, float&, char, bool*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 0>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 1>, mp_list<int[]>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 2>, mp_list<int[], void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 3>, mp_list<int[], void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 4>, mp_list<int[], void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 5>, mp_list<int[], void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 1>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 2>, mp_list<void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 3>, mp_list<void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 4>, mp_list<void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 5>, mp_list<void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 2>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 3>, mp_list<float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 4>, mp_list<float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 5>, mp_list<float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 3>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 4>, mp_list<char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 5>, mp_list<char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 4, 4>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 4, 5>, mp_list<bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 5, 5>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<1>>, mp_list<int[]>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<2>>, mp_list<int[], void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<3>>, mp_list<int[], void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<4>>, mp_list<int[], void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<5>>, mp_list<int[], void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<1>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<2>>, mp_list<void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<3>>, mp_list<void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<4>>, mp_list<void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<5>>, mp_list<void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<2>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<3>>, mp_list<float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<4>>, mp_list<float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<5>>, mp_list<float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<3>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<4>>, mp_list<char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<5>>, mp_list<char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<4>, mp_size_t<4>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<4>, mp_size_t<5>>, mp_list<bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<5>, mp_size_t<5>>, mp_list<>>));
}
{
using L2 = std::tuple<int[], void, float&, char, bool*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 0>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 1>, std::tuple<int[]>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 2>, std::tuple<int[], void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 3>, std::tuple<int[], void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 4>, std::tuple<int[], void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 5>, std::tuple<int[], void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 1>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 2>, std::tuple<void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 3>, std::tuple<void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 4>, std::tuple<void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 5>, std::tuple<void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 2>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 3>, std::tuple<float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 4>, std::tuple<float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 5>, std::tuple<float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 3>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 4>, std::tuple<char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 5>, std::tuple<char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 4, 4>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 4, 5>, std::tuple<bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 5, 5>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, std::tuple<int[]>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, std::tuple<int[], void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, std::tuple<int[], void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, std::tuple<int[], void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, std::tuple<int[], void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, std::tuple<void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, std::tuple<void, float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, std::tuple<void, float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, std::tuple<void, float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, std::tuple<float&>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, std::tuple<float&, char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, std::tuple<float&, char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, std::tuple<char>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, std::tuple<char, bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, std::tuple<bool*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, std::tuple<>>));
}
return boost::report_errors();
}

168
test/mp_slice_2.cpp Normal file
View File

@@ -0,0 +1,168 @@
// Copyright 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
#include <boost/core/lightweight_test_trait.hpp>
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_list;
using boost::mp11::mp_slice;
using boost::mp11::mp_slice_c;
using boost::mp11::mp_size_t;
{
using L1 = V1<>;
BOOST_TEST_TRAIT_SAME(mp_slice_c<L1, 0, 0>, L1);
BOOST_TEST_TRAIT_SAME(mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, L1);
using L2 = V1<false, 0, true, 1, std::size_t(2)>;
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 0>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 1>, V1<false>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 2>, V1<false, 0>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 3>, V1<false, 0, true>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 4>, V1<false, 0, true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 5>, V1<false, 0, true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 1>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 2>, V1<0>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 3>, V1<0, true>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 4>, V1<0, true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 5>, V1<0, true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 2>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 3>, V1<true>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 4>, V1<true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 5>, V1<true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 3>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 4>, V1<1>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 5>, V1<1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 4>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 5>, V1<std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 5, 5>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, V1<false>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, V1<false, 0>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, V1<false, 0, true>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, V1<false, 0, true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, V1<false, 0, true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, V1<0>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, V1<0, true>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, V1<0, true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, V1<0, true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, V1<true>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, V1<true, 1>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, V1<true, 1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, V1<1>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, V1<1, std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, V1<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, V1<std::size_t(2)>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, V1<>);
}
{
using L1 = V2<>;
BOOST_TEST_TRAIT_SAME(mp_slice_c<L1, 0, 0>, L1);
BOOST_TEST_TRAIT_SAME(mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, L1);
using L2 = V2<1, 2, 3, 4, 5>;
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 0>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 1>, V2<1>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 2>, V2<1, 2>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 3>, V2<1, 2, 3>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 4>, V2<1, 2, 3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 5>, V2<1, 2, 3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 1>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 2>, V2<2>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 3>, V2<2, 3>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 4>, V2<2, 3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 5>, V2<2, 3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 2>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 3>, V2<3>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 4>, V2<3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 5>, V2<3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 3>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 4>, V2<4>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 5>, V2<4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 4>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 5>, V2<5>);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 5, 5>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, V2<1>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, V2<1, 2>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, V2<1, 2, 3>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, V2<1, 2, 3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, V2<1, 2, 3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, V2<2>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, V2<2, 3>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, V2<2, 3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, V2<2, 3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, V2<3>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, V2<3, 4>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, V2<3, 4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, V2<4>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, V2<4, 5>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, V2<>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, V2<5>);
BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, V2<>);
}
using boost::mp11::mp_iota_c;
using boost::mp11::mp_rename_v;
{
using L1 = mp_rename_v<mp_iota_c<71>, V1>;
using L2 = mp_rename_v<mp_iota_c<72>, V1>;
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 72>, L2);
BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 71>, L1);
}
return boost::report_errors();
}
#endif

113
test/mp_sliding_fold.cpp Normal file
View File

@@ -0,0 +1,113 @@
// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
//
// 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
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/mp11/function.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <tuple>
#include <utility>
struct X1 {};
struct X2 {};
struct X3 {};
struct X4 {};
struct X5 {};
using boost::mp11::mp_plus;
using boost::mp11::mp_int;
#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
template<class... C> using average = mp_int<mp_plus<C...>::value / sizeof...(C)>;
#else
template<class... C> struct average_impl: mp_int<mp_plus<C...>::value / sizeof...(C)> {};
template<class... C> using average = typename average_impl<C...>::type;
#endif
int main()
{
using boost::mp11::mp_list;
using boost::mp11::mp_list_c;
using boost::mp11::mp_size_t;
using boost::mp11::mp_sliding_fold;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<1>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>, mp_list<X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<2>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<2>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>, mp_list<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<3>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<3>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<3>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>, mp_list<X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<4>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<4>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<4>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<4>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<4>, mp_list>, mp_list<mp_list<X1, X2, X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<4>, mp_list>, mp_list<mp_list<X1, X2, X3, X4>, mp_list<X2, X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<5>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<5>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<5>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<5>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<5>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<5>, mp_list>, mp_list<mp_list<X1, X2, X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<6>, mp_list>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<2>, std::pair>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<2>, std::pair>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<>, mp_size_t<2>, std::pair>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1>, mp_size_t<2>, std::pair>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3, X4>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3, X4, X5>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, mp_plus>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, mp_plus>, mp_list_c<int, 3, 5, 7, 9, 11>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, mp_plus>, mp_list_c<int, 6, 9, 12, 15>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, mp_plus>, mp_list_c<int, 10, 14, 18>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, mp_plus>, mp_list_c<int, 15, 20>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, mp_plus>, mp_list_c<int, 21>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, average>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, average>, mp_list_c<int, 1, 2, 3, 4, 5>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, average>, mp_list_c<int, 2, 3, 4, 5>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, average>, mp_list_c<int, 2, 3, 4>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, average>, mp_list_c<int, 3, 4>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, average>, mp_list_c<int, 3>>));
return boost::report_errors();
}

121
test/mp_sliding_fold_q.cpp Normal file
View File

@@ -0,0 +1,121 @@
// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
//
// 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
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/mp11/function.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <tuple>
#include <utility>
struct X1 {};
struct X2 {};
struct X3 {};
struct X4 {};
struct X5 {};
using boost::mp11::mp_plus;
using boost::mp11::mp_int;
#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
struct average
{
template<class... C> using fn = mp_int<mp_plus<C...>::value / sizeof...(C)>;
};
#else
template<class... C> struct average_impl: mp_int<mp_plus<C...>::value / sizeof...(C)> {};
struct average
{
template<class... C> using fn = typename average_impl<C...>::type;
};
#endif
int main()
{
using boost::mp11::mp_list;
using boost::mp11::mp_list_c;
using boost::mp11::mp_quote;
using boost::mp11::mp_size_t;
using boost::mp11::mp_sliding_fold_q;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>, mp_list<X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>, mp_list<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>, mp_list<X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4>, mp_list<X2, X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, mp_quote<mp_plus>>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, mp_quote<mp_plus>>, mp_list_c<int, 3, 5, 7, 9, 11>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, mp_quote<mp_plus>>, mp_list_c<int, 6, 9, 12, 15>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, mp_quote<mp_plus>>, mp_list_c<int, 10, 14, 18>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, mp_quote<mp_plus>>, mp_list_c<int, 15, 20>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, mp_quote<mp_plus>>, mp_list_c<int, 21>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, average>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, average>, mp_list_c<int, 1, 2, 3, 4, 5>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, average>, mp_list_c<int, 2, 3, 4, 5>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, average>, mp_list_c<int, 2, 3, 4>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, average>, mp_list_c<int, 3, 4>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, average>, mp_list_c<int, 3>>));
return boost::report_errors();
}

45
test/mp_transform_2.cpp Normal file
View File

@@ -0,0 +1,45 @@
// Copyright 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/function.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
int main() {}
#else
template<auto... A> struct V1 {};
template<int... I> struct V2 {};
int main()
{
using boost::mp11::mp_transform;
using boost::mp11::mp_identity_t;
using boost::mp11::mp_plus;
using L1 = V1<true, -2, 3U, -4L>;
using L2 = V2<1, -2, 3, -4>;
BOOST_TEST_TRAIT_SAME(mp_transform<mp_identity_t, L1>, L1);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1>, V1<1, -2, 3U, -4L>);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1, L2>, V1<2, -4, 6U, -8L>);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1, L2, L2>, V1<3, -6, 9U, -12L>);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_identity_t, L2>, L2);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2>, V2<1, -2, 3, -4>);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2, L1>, V2<2, -4, 6, -8>);
BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2, L1, L1>, V2<3, -6, 9, -12>);
//
return boost::report_errors();
}
#endif

67
test/mp_transform_q_2.cpp Normal file
View File

@@ -0,0 +1,67 @@
// Copyright 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/bind.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <utility>
struct X1 {};
struct X2 {};
struct Test
{
void operator()( boost::mp11::mp_size_t<0> )
{
}
template<class N> void operator()( N )
{
using boost::mp11::mp_repeat;
using boost::mp11::mp_list;
using boost::mp11::mp_apply_q;
using boost::mp11::mp_bind_front;
using boost::mp11::mp_transform_q;
using boost::mp11::mp_quote;
using L1 = mp_repeat< mp_list<std::pair<X1, X2>>, N >; // mp_list<pair<X1, X2>, pair<X1, X2>, ...>
using L2 = mp_apply_q< mp_bind_front<mp_transform_q, mp_quote<mp_list>>, L1>; // pair<mp_list<X1, X1, ...>, mp_list<X2, X2, ...>>
using R1 = mp_repeat<mp_list<X1>, N>; // mp_list<X1, X1, ...>
using R2 = mp_repeat<mp_list<X2>, N>; // mp_list<X2, X2, ...>
BOOST_TEST_TRAIT_SAME(L2, std::pair<R1, R2>);
}
};
int main()
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
using boost::mp11::mp_size_t;
Test()( mp_size_t<1>() );
Test()( mp_size_t<2>() );
Test()( mp_size_t<3>() );
Test()( mp_size_t<4>() );
Test()( mp_size_t<5>() );
Test()( mp_size_t<6>() );
Test()( mp_size_t<7>() );
Test()( mp_size_t<9>() );
Test()( mp_size_t<10>() );
Test()( mp_size_t<11>() );
#else
using boost::mp11::mp_for_each;
using boost::mp11::mp_iota_c;
mp_for_each< mp_iota_c<32> >( Test() );
#endif
return boost::report_errors();
}