FM / mp11

/usr/include/boost/mp11

Name	Size	Mode	Actions
detail/	-	0755	rm
algorithm.hpp	36683	0644	edit dl rm
bind.hpp	2857	0644	edit dl rm
function.hpp	5015	0644	edit dl rm
integer_sequence.hpp	2914	0644	edit dl rm
integral.hpp	959	0644	edit dl rm
list.hpp	9449	0644	edit dl rm
map.hpp	3300	0644	edit dl rm
mpl.hpp	389	0644	edit dl rm
mpl_list.hpp	605	0644	edit dl rm
mpl_tuple.hpp	622	0644	edit dl rm
set.hpp	4839	0644	edit dl rm
tuple.hpp	6303	0644	edit dl rm
utility.hpp	7490	0644	edit dl rm
version.hpp	437	0644	edit dl rm

Edit: /usr/include/boost/mp11/algorithm.hpp (36683B)

#ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
#define BOOST_MP11_ALGORITHM_HPP_INCLUDED

//  Copyright 2015-2019 Peter Dimov
//
//  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/list.hpp>
#include <boost/mp11/set.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/mp11/utility.hpp>
#include <boost/mp11/function.hpp>
#include <boost/mp11/detail/mp_count.hpp>
#include <boost/mp11/detail/mp_plus.hpp>
#include <boost/mp11/detail/mp_map_find.hpp>
#include <boost/mp11/detail/mp_with_index.hpp>
#include <boost/mp11/detail/mp_fold.hpp>
#include <boost/mp11/detail/mp_min_element.hpp>
#include <boost/mp11/detail/mp_copy_if.hpp>
#include <boost/mp11/detail/mp_remove_if.hpp>
#include <boost/mp11/detail/config.hpp>
#include <boost/mp11/integer_sequence.hpp>
#include <type_traits>
#include <utility>

namespace boost
{
namespace mp11
{

// mp_transform<F, L...>
namespace detail
{

template<template<class...> class F, class... L> struct mp_transform_impl
{
};

template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )

template<class... U> struct f { using type = F<U...>; };

using type = L<typename f<T>::type...>;

#else

using type = L<F<T>...>;

#endif
};

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )

template<class... U> struct f { using type = F<U...>; };

using type = L1<typename f<T1, T2>::type...>;

#else

using type = L1<F<T1,T2>...>;

#endif
};

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )

template<class... U> struct f { using type = F<U...>; };

using type = L1<typename f<T1, T2, T3>::type...>;

#else

using type = L1<F<T1,T2,T3>...>;

#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>...>;
template<class... L> struct mp_same_size_2: mp_defer<mp_same_size_1, L...> {};

#endif

struct list_size_mismatch
{
};

#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )

template<template<class...> class F, class... L> struct mp_transform_cuda_workaround
{
    using type = mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>;
};

#endif

} // namespace detail

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )

template<template<class...> class F, class... L> using mp_transform = typename mp_if<typename detail::mp_same_size_2<L...>::type, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;

#else

#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )

template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type;

#else

template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;

#endif

template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;

namespace detail
{

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
{
    using A1 = L1<mp_list<T1, T2, T3, T4>...>;

template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;

using A2 = mp_fold<mp_list<L...>, A1, _f>;

template<class T> using _g = mp_apply<F, T>;

using type = mp_transform<_g, A2>;
};

} // namespace detail

// mp_transform_if<P, F, L...>
namespace detail
{

template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
{
    // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"

using Qp = mp_quote<P>;
    using Qf = mp_quote<F>;

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )

template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
    template<class... U> using _f = typename _f_<U...>::type;

#else

template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;

#endif

using type = mp_transform<_f, L...>;
};

} // namespace detail

template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;

// mp_filter<P, L...>
namespace detail
{

template<template<class...> class P, class L1, class... L> struct mp_filter_impl
{
    using Qp = mp_quote<P>;

template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;

using _t1 = mp_transform<_f, L1, L...>;
    using _t2 = mp_apply<mp_append, _t1>;

using type = mp_assign<L1, _t2>;
};

} // namespace detail

template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;

// mp_fill<L, V>
namespace detail
{

template<class L, class V> struct mp_fill_impl;

template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )

template<class...> struct _f { using type = V; };
    using type = L<typename _f<T>::type...>;

#else

template<class...> using _f = V;
    using type = L<_f<T>...>;

#endif
};

} // namespace detail

template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;

// mp_contains<L, V>
template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;

// mp_repeat(_c)<L, N>
namespace detail
{

template<class L, std::size_t N> struct mp_repeat_c_impl
{
    using _l1 = typename mp_repeat_c_impl<L, N/2>::type;
    using _l2 = typename mp_repeat_c_impl<L, N%2>::type;

using type = mp_append<_l1, _l1, _l2>;
};

template<class L> struct mp_repeat_c_impl<L, 0>
{
    using type = mp_clear<L>;
};

template<class L> struct mp_repeat_c_impl<L, 1>
{
    using type = L;
};

} // namespace detail

template<class L, std::size_t N> using mp_repeat_c = typename detail::mp_repeat_c_impl<L, N>::type;
template<class L, class N> using mp_repeat = typename detail::mp_repeat_c_impl<L, std::size_t{ N::value }>::type;

// mp_product<F, L...>
namespace detail
{

template<template<class...> class F, class P, class... L> struct mp_product_impl_2
{
};

template<template<class...> class F, class P> struct mp_product_impl_2<F, P>
{
    using type = mp_list<mp_rename<P, F>>;
};

template<template<class...> class F, class P, template<class...> class L1, class... T1, class... L> struct mp_product_impl_2<F, P, L1<T1...>, L...>
{
    using type = mp_append<typename mp_product_impl_2<F, mp_push_back<P, T1>, L...>::type...>;
};

template<template<class...> class F, class... L> struct mp_product_impl
{
};

template<template<class...> class F> struct mp_product_impl<F>
{
    using type = mp_list< F<> >;
};

template<template<class...> class F, class L1, class... L> struct mp_product_impl<F, L1, L...>
{
    using type = mp_assign<L1, typename mp_product_impl_2<F, mp_list<>, L1, L...>::type>;
};

} // namespace detail

template<template<class...> class F, class... L> using mp_product = typename detail::mp_product_impl<F, L...>::type;
template<class Q, class... L> using mp_product_q = typename detail::mp_product_impl<Q::template fn, L...>::type;

// mp_drop(_c)<L, N>
namespace detail
{

template<class L, class L2> struct mp_drop_impl;

template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>>
{
    template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );

using R = decltype( f( (mp_identity<T>*)0 ... ) );

using type = typename R::type;
};

} // namespace detail

template<class L, std::size_t N> using mp_drop_c = typename detail::mp_drop_impl<L, mp_repeat_c<mp_list<void>, N>>::type;

template<class L, class N> using mp_drop = typename detail::mp_drop_impl<L, mp_repeat<mp_list<void>, N>>::type;

// mp_from_sequence<S>
namespace detail
{

template<class S> struct mp_from_sequence_impl;

template<template<class T, T... I> class S, class U, U... J> struct mp_from_sequence_impl<S<U, J...>>
{
    using type = mp_list<std::integral_constant<U, J>...>;
};

} // namespace detail

template<class S> using mp_from_sequence = typename detail::mp_from_sequence_impl<S>::type;

// mp_iota(_c)<N>
template<std::size_t N> using mp_iota_c = mp_from_sequence<make_index_sequence<N>>;
template<class N> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>>;

// mp_at(_c)<L, I>
namespace detail
{

template<class L, std::size_t I> struct mp_at_c_impl;

#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT)

template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
{
    using type = __type_pack_element<I, T...>;
};

#else

template<class L, std::size_t I> struct mp_at_c_impl
{
    using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, L>;
    using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
};

#endif

#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )

template<class L, std::size_t I> struct mp_at_c_cuda_workaround
{
    using type = mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>;
};

#endif

} // namespace detail

#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )

template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type;

#else

template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;

#endif

template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;

// mp_take(_c)<L, N>
namespace detail
{

template<std::size_t N, class L, class E = void> struct mp_take_c_impl
{
};

template<template<class...> class L, class... T>
struct mp_take_c_impl<0, L<T...>>
{
    using type = L<>;
};

template<template<class...> class L, class T1, class... T>
struct mp_take_c_impl<1, L<T1, T...>>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class T2, class... T>
struct mp_take_c_impl<2, L<T1, T2, T...>>
{
    using type = L<T1, T2>;
};

template<template<class...> class L, class T1, class T2, class T3, class... T>
struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
{
    using type = L<T1, T2, T3>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
{
    using type = L<T1, T2, T3, T4>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
{
    using type = L<T1, T2, T3, T4, T5>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
{
    using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
};

} // namespace detail

template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<N, L>::type;
template<class L, class N> using mp_take = typename detail::mp_take_c_impl<std::size_t{ N::value }, L>::type;

// mp_back<L>
template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;

// mp_pop_back<L>
template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;

// mp_replace<L, V, W>
namespace detail
{

template<class L, class V, class W> struct mp_replace_impl;

template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
    template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
    using type = L<typename _f<T>::type...>;
#else
    template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
    using type = L<_f<T>...>;
#endif
};

} // namespace detail

template<class L, class V, class W> using mp_replace = typename detail::mp_replace_impl<L, V, W>::type;

// mp_replace_if<L, P, W>
namespace detail
{

template<class L, template<class...> class P, class W> struct mp_replace_if_impl;

template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
    template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
    using type = L<typename _f<T>::type...>;
#else
    template<class U> using _f = mp_if<P<U>, W, U>;
    using type = L<_f<T>...>;
#endif
};

} // namespace detail

template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;

// mp_copy_if<L, P>
//   in detail/mp_copy_if.hpp

// mp_remove<L, V>
namespace detail
{

template<class L, class V> struct mp_remove_impl;

template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
    template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
    using type = mp_append<L<>, typename _f<T>::type...>;
#else
    template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
    using type = mp_append<L<>, _f<T>...>;
#endif
};

} // namespace detail

template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;

// mp_remove_if<L, P>
//   in detail/mp_remove_if.hpp

// mp_flatten<L, L2 = mp_clear<L>>
namespace detail
{

template<class L2> struct mp_flatten_impl
{
    template<class T> using fn = mp_if<mp_similar<L2, T>, T, mp_list<T>>;
};

} // namespace detail

template<class L, class L2 = mp_clear<L>> using mp_flatten = mp_apply<mp_append, mp_push_front<mp_transform_q<detail::mp_flatten_impl<L2>, L>, mp_clear<L>>>;

// mp_partition<L, P>
namespace detail
{

template<class L, template<class...> class P> struct mp_partition_impl;

template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
{
    using type = L<mp_copy_if<L<T...>, P>, mp_remove_if<L<T...>, P>>;
};

} // namespace detail

template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;

// mp_sort<L, P>
namespace detail
{

template<class L, template<class...> class P> struct mp_sort_impl;

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = L<>;
};

#else

template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
{
    using type = L<>;
};

#endif

template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
{
    template<class U> using F = P<U, T1>;

using part = mp_partition<L<T...>, F>;

using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
    using S2 = typename mp_sort_impl<mp_second<part>, P>::type;

using type = mp_append<mp_push_back<S1, T1>, S2>;
};

} // namespace detail

template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;

// mp_nth_element(_c)<L, I, P>
namespace detail
{

template<class L, std::size_t I, template<class...> class P> struct mp_nth_element_impl;

template<template<class...> class L, class T1, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1>, I, P>
{
    static_assert( I == 0, "mp_nth_element index out of range" );
    using type = T1;
};

template<template<class...> class L, class T1, class... T, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1, T...>, I, P>
{
    static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );

template<class U> using F = P<U, T1>;

using part = mp_partition<L<T...>, F>;

using L1 = mp_first<part>;
    static std::size_t const N1 = mp_size<L1>::value;

using L2 = mp_second<part>;

#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )

struct detail
    {
        struct mp_nth_element_impl_cuda_workaround
        {
            using type = mp_cond<

mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
                mp_bool<(I == N1)>, mp_identity<T1>,
                mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>

>;
        };
    };

using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type;

#else

using type = typename mp_cond<

mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
        mp_bool<(I == N1)>, mp_identity<T1>,
        mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>

>::type;

#endif
};

} // namespace detail

template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c = typename detail::mp_nth_element_impl<L, I, P>::type;
template<class L, class I, template<class...> class P> using mp_nth_element = typename detail::mp_nth_element_impl<L, std::size_t{ I::value }, P>::type;
template<class L, class I, class Q> using mp_nth_element_q = mp_nth_element<L, I, Q::template fn>;

// mp_find<L, V>
namespace detail
{

template<class L, class V> struct mp_find_impl;

#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )

struct mp_index_holder
{
    std::size_t i_;
    bool f_;
};

constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
{
    if( v.f_ )
    {
        return v;
    }
    else if( f )
    {
        return { v.i_, true };
    }
    else
    {
        return { v.i_ + 1, false };
    }
}

template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
{
    static constexpr mp_index_holder _v{ 0, false };
    using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
};

#elif !defined( BOOST_MP11_NO_CONSTEXPR )

template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
{
    using type = mp_size_t<0>;
};

#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )

constexpr std::size_t cx_find_index( bool const * first, bool const * last )
{
    std::size_t m = 0;

while( first != last && !*first )
    {
        ++m;
        ++first;
    }

return m;
}

#else

constexpr std::size_t cx_find_index( bool const * first, bool const * last )
{
    return first == last || *first? 0: 1 + cx_find_index( first + 1, last );
}

#endif

template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
{
    static constexpr bool _v[] = { std::is_same<T, V>::value... };
    using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
};

#else

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = mp_size_t<0>;
};

#else

template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
{
    using type = mp_size_t<0>;
};

#endif

template<template<class...> class L, class... T, class V> struct mp_find_impl<L<V, T...>, V>
{
    using type = mp_size_t<0>;
};

template<template<class...> class L, class T1, class... T, class V> struct mp_find_impl<L<T1, T...>, V>
{
    using _r = typename mp_find_impl<mp_list<T...>, V>::type;
    using type = mp_size_t<1 + _r::value>;
};

#endif

} // namespace detail

template<class L, class V> using mp_find = typename detail::mp_find_impl<L, V>::type;

// mp_find_if<L, P>
namespace detail
{

template<class L, template<class...> class P> struct mp_find_if_impl;

#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )

template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
{
    static constexpr mp_index_holder _v{ 0, false };
    using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
};

#elif !defined( BOOST_MP11_NO_CONSTEXPR )

template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
{
    using type = mp_size_t<0>;
};

template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
{
    static constexpr bool _v[] = { P<T>::value... };
    using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
};

#else

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = mp_size_t<0>;
};

#else

template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
{
    using type = mp_size_t<0>;
};

#endif

template<class L, template<class...> class P> struct mp_find_if_impl_2
{
    using _r = typename mp_find_if_impl<L, P>::type;
    using type = mp_size_t<1 + _r::value>;
};

template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_find_if_impl<L<T1, T...>, P>
{
    using type = typename mp_if<P<T1>, mp_identity<mp_size_t<0>>, mp_find_if_impl_2<mp_list<T...>, P>>::type;
};

#endif

} // namespace detail

template<class L, template<class...> class P> using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;

// mp_reverse<L>
namespace detail
{

template<class L> struct mp_reverse_impl;

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T> struct mp_reverse_impl<L<T...>>
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = L<>;
};

#else

template<template<class...> class L> struct mp_reverse_impl<L<>>
{
    using type = L<>;
};

#endif

template<template<class...> class L, class T1> struct mp_reverse_impl<L<T1>>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class T2> struct mp_reverse_impl<L<T1, T2>>
{
    using type = L<T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3> struct mp_reverse_impl<L<T1, T2, T3>>
{
    using type = L<T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl<L<T1, T2, T3, T4>>
{
    using type = L<T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl<L<T1, T2, T3, T4, T5>>
{
    using type = L<T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6>>
{
    using type = L<T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7>>
{
    using type = L<T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>>
{
    using type = L<T8, T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>>
{
    using type = L<T9, T8, T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>>
{
    using type = mp_push_back<typename mp_reverse_impl<L<T...>>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>;
};

} // namespace detail

template<class L> using mp_reverse = typename detail::mp_reverse_impl<L>::type;

// mp_fold<L, V, F>
//   in detail/mp_fold.hpp

// mp_reverse_fold<L, V, F>
namespace detail
{

template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T...>, V, F>
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = V;
};

#else

template<template<class...> class L, class V, template<class...> class F> struct mp_reverse_fold_impl<L<>, V, F>
{
    using type = V;
};

#endif

template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T...>, V, F>
{
    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
    using type = F<T1, rest>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
{
    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
    using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
};

} // namespace detail

template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;

// mp_unique<L>
namespace detail
{

template<class L> struct mp_unique_impl;

template<template<class...> class L, class... T> struct mp_unique_impl<L<T...>>
{
    using type = mp_set_push_back<L<>, T...>;
};

} // namespace detail

template<class L> using mp_unique = typename detail::mp_unique_impl<L>::type;

// mp_unique_if<L, P>
namespace detail
{

template<template<class...> class P> struct mp_unique_if_push_back
{
    template<class...> struct impl
    {
    };

template<template<class...> class L, class... Ts, class T>
    struct impl<L<Ts...>, T>
    {
        using type = mp_if<mp_any<P<Ts, T>...>, L<Ts...>, L<Ts..., T>>;
    };

template<class... T> using fn = typename impl<T...>::type;
};

} // namespace detail

template<class L, template<class...> class P>
using mp_unique_if = mp_fold_q<L, mp_clear<L>, detail::mp_unique_if_push_back<P>>;

template<class L, class Q> using mp_unique_if_q = mp_unique_if<L, Q::template fn>;

// mp_all_of<L, P>
template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;

// mp_none_of<L, P>
template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;

// mp_any_of<L, P>
template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;
template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;

// mp_replace_at_c<L, I, W>
namespace detail
{

template<class L, class I, class W> struct mp_replace_at_impl
{
    static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );

template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
    template<class T1, class T2> using _f = W;

using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
};

} // namespace detail

template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;

//mp_for_each<L>(f)
namespace detail
{

template<class... T, class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
{
    using A = int[sizeof...(T)];
    return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
}

template<class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
{
    return std::forward<F>(f);
}

} // namespace detail

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 )

// msvc has a limit of 1024

template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each( F && f )
{
    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
}

template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each( F && f )
{
    using L2 = mp_rename<L, mp_list>;

using L3 = mp_take_c<L2, 1024>;
    using L4 = mp_drop_c<L2, 1024>;

return mp_for_each<L4>( mp_for_each<L3>( std::forward<F>(f) ) );
}

#else

template<class L, class F> BOOST_MP11_CONSTEXPR F mp_for_each( F && f )
{
    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
}

#endif

// mp_insert<L, I, T...>
template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;

// mp_insert_c<L, I, T...>
template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;

// mp_erase<L, I, J>
template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;

// mp_erase_c<L, I, J>
template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;

// mp_starts_with<L1, L2>
// contributed by Glen Joseph Fernandes (glenjofe@gmail.com)
namespace detail {

template<class L1, class L2>
struct mp_starts_with_impl { };

template<template<class...> class L1, class... T1, template<class...> class L2,
    class... T2>
struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
    template<class L>
    static mp_false check(L);

template<class... T>
    static mp_true check(mp_list<T2..., T...>);

using type = decltype(check(mp_list<T1...>()));
};

} // namespace detail

template<class L1, class L2>
using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;

// mp_rotate_left(_c)<L, N>
namespace detail
{

// limit divisor to 1 to avoid division by 0 and give a rotation of 0 for lists containing 0 or 1 elements
template<std::size_t Ln, std::size_t N> using canonical_left_rotation = mp_size_t<N % (Ln == 0? 1: Ln)>;

// perform right rotation as a left rotation by inverting the number of elements to rotate
template<std::size_t Ln, std::size_t N> using canonical_right_rotation = mp_size_t<Ln - N % (Ln == 0? 1: Ln)>;

// avoid errors when rotating fixed-sized lists by using mp_list for the transformation
template<class L, class N, class L2 = mp_rename<L, mp_list>> using mp_rotate_impl = mp_assign<L, mp_append< mp_drop<L2, N>, mp_take<L2, N> >>;

} // namespace detail

template<class L, std::size_t N> using mp_rotate_left_c = detail::mp_rotate_impl<L, detail::canonical_left_rotation<mp_size<L>::value, N>>;
template<class L, class N> using mp_rotate_left = mp_rotate_left_c<L, std::size_t{ N::value }>;

// mp_rotate_right(_c)<L, N>
template<class L, std::size_t N> using mp_rotate_right_c = mp_rotate_left<L, detail::canonical_right_rotation<mp_size<L>::value, N>>;
template<class L, class N> using mp_rotate_right = mp_rotate_right_c<L, std::size_t{ N::value }>;

// mp_min_element<L, P>
// mp_max_element<L, P>
//   in detail/mp_min_element.hpp

// mp_power_set<L>
namespace detail
{

template<class L> struct mp_power_set_impl;

} // namespace detail

template<class L> using mp_power_set = typename detail::mp_power_set_impl<L>::type;

namespace detail
{

#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )

template<template<class...> class L, class... T> struct mp_power_set_impl< L<T...> >
{
    static_assert( sizeof...(T) == 0, "T... must be empty" );
    using type = L< L<> >;
};

#else

template<template<class...> class L> struct mp_power_set_impl< L<> >
{
    using type = L< L<> >;
};

#endif

template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
{
    using S1 = mp_power_set< L<T...> >;

template<class L2> using _f = mp_push_front<L2, T1>;

using S2 = mp_transform<_f, S1>;

using type = mp_append< S1, S2 >;
};

} // namespace detail

// mp_partial_sum<L, V, F>
namespace detail
{

template<template<class...> class F> struct mp_partial_sum_impl_f
{
#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )

template<class V, class T> using fn = mp_list<F<mp_first<V>, T>, mp_push_back<mp_second<V>, F<mp_first<V>, T>> >;

#else

template<class V, class T, class N = F<mp_first<V>, T>> using fn = mp_list<N, mp_push_back<mp_second<V>, N>>;

#endif
};

} // namespace detail

template<class L, class V, template<class...> class F> using mp_partial_sum = mp_second<mp_fold_q<L, mp_list<V, mp_clear<L>>, detail::mp_partial_sum_impl_f<F>> >;
template<class L, class V, class Q> using mp_partial_sum_q = mp_partial_sum<L, V, Q::template fn>;

// mp_iterate<V, F, R>
namespace detail
{

template<class V, template<class...> class F, template<class...> class R, class N> struct mp_iterate_impl;

} // namespace detail

template<class V, template<class...> class F, template<class...> class R> using mp_iterate = typename detail::mp_iterate_impl<V, F, R, mp_valid<R, V>>::type;

namespace detail
{

template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_false>
{
    template<class X> using _f = mp_list<F<X>>;
    using type = mp_eval_or<mp_list<>, _f, V>;
};

template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_true>
{
    using type = mp_push_front<mp_iterate<R<V>, F, R>, F<V>>;
};

} // namespace detail

template<class V, class Qf, class Qr> using mp_iterate_q = mp_iterate<V, Qf::template fn, Qr::template fn>;

} // namespace mp11
} // namespace boost

#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED

#ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED #define BOOST_MP11_ALGORITHM_HPP_INCLUDED // Copyright 2015-2019 Peter Dimov // // 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mp11 { // mp_transform namespace detail { template class F, class... L> struct mp_transform_impl { }; template class F, template class L, class... T> struct mp_transform_impl> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct f { using type = F; }; using type = L::type...>; #else using type = L...>; #endif }; template class F, template class L1, class... T1, template class L2, class... T2> struct mp_transform_impl, L2> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct f { using type = F; }; using type = L1::type...>; #else using type = L1...>; #endif }; template class F, template class L1, class... T1, template class L2, class... T2, template class L3, class... T3> struct mp_transform_impl, L2, L3> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct f { using type = F; }; using type = L1::type...>; #else using type = L1...>; #endif }; #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 ) template using mp_same_size_1 = mp_same...>; template struct mp_same_size_2: mp_defer {}; #endif struct list_size_mismatch { }; #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) template class F, class... L> struct mp_transform_cuda_workaround { using type = mp_if...>, detail::mp_transform_impl, detail::list_size_mismatch>; }; #endif } // namespace detail #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 ) template class F, class... L> using mp_transform = typename mp_if::type, detail::mp_transform_impl, detail::list_size_mismatch>::type; #else #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) template class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type; #else template class F, class... L> using mp_transform = typename mp_if...>, detail::mp_transform_impl, detail::list_size_mismatch>::type; #endif #endif template using mp_transform_q = mp_transform; namespace detail { template class F, template class L1, class... T1, template class L2, class... T2, template class L3, class... T3, template class L4, class... T4, class... L> struct mp_transform_impl, L2, L3, L4, L...> { using A1 = L1...>; template using _f = mp_transform; using A2 = mp_fold, A1, _f>; template using _g = mp_apply; using type = mp_transform<_g, A2>; }; } // namespace detail // mp_transform_if namespace detail { template class P, template class F, class... L> struct mp_transform_if_impl { // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template" using Qp = mp_quote

; using Qf = mp_quote; #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct _f_ { using type = mp_eval_if_q>, mp_first>, Qf, U...>; }; template using _f = typename _f_::type; #else template using _f = mp_eval_if_q>, mp_first>, Qf, U...>; #endif using type = mp_transform<_f, L...>; }; } // namespace detail template class P, template class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl::type; template using mp_transform_if_q = typename detail::mp_transform_if_impl::type; // mp_filter namespace detail { template class P, class L1, class... L> struct mp_filter_impl { using Qp = mp_quote

; template using _f = mp_if< mp_invoke_q, mp_list, mp_list<> >; using _t1 = mp_transform<_f, L1, L...>; using _t2 = mp_apply; using type = mp_assign; }; } // namespace detail template class P, class... L> using mp_filter = typename detail::mp_filter_impl::type; template using mp_filter_q = typename detail::mp_filter_impl::type; // mp_fill namespace detail { template struct mp_fill_impl; template class L, class... T, class V> struct mp_fill_impl, V> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 ) template struct _f { using type = V; }; using type = L::type...>; #else template using _f = V; using type = L<_f...>; #endif }; } // namespace detail template using mp_fill = typename detail::mp_fill_impl::type; // mp_contains template using mp_contains = mp_to_bool>; // mp_repeat(_c) namespace detail { template struct mp_repeat_c_impl { using _l1 = typename mp_repeat_c_impl::type; using _l2 = typename mp_repeat_c_impl::type; using type = mp_append<_l1, _l1, _l2>; }; template struct mp_repeat_c_impl { using type = mp_clear; }; template struct mp_repeat_c_impl { using type = L; }; } // namespace detail template using mp_repeat_c = typename detail::mp_repeat_c_impl::type; template using mp_repeat = typename detail::mp_repeat_c_impl::type; // mp_product namespace detail { template class F, class P, class... L> struct mp_product_impl_2 { }; template class F, class P> struct mp_product_impl_2 { using type = mp_list>; }; template class F, class P, template class L1, class... T1, class... L> struct mp_product_impl_2, L...> { using type = mp_append, L...>::type...>; }; template class F, class... L> struct mp_product_impl { }; template class F> struct mp_product_impl { using type = mp_list< F<> >; }; template class F, class L1, class... L> struct mp_product_impl { using type = mp_assign, L1, L...>::type>; }; } // namespace detail template class F, class... L> using mp_product = typename detail::mp_product_impl::type; template using mp_product_q = typename detail::mp_product_impl::type; // mp_drop(_c) namespace detail { template struct mp_drop_impl; template class L, class... T, template class L2, class... U> struct mp_drop_impl, L2> { template static mp_identity> f( U*..., mp_identity*... ); using R = decltype( f( (mp_identity*)0 ... ) ); using type = typename R::type; }; } // namespace detail template using mp_drop_c = typename detail::mp_drop_impl, N>>::type; template using mp_drop = typename detail::mp_drop_impl, N>>::type; // mp_from_sequence namespace detail { template struct mp_from_sequence_impl; template class S, class U, U... J> struct mp_from_sequence_impl> { using type = mp_list...>; }; } // namespace detail template using mp_from_sequence = typename detail::mp_from_sequence_impl::type; // mp_iota(_c) template using mp_iota_c = mp_from_sequence>; template using mp_iota = mp_from_sequence::type, N::value>>; // mp_at(_c) namespace detail { template struct mp_at_c_impl; #if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT) template class L, class... T, std::size_t I> struct mp_at_c_impl, I> { using type = __type_pack_element; }; #else template struct mp_at_c_impl { using _map = mp_transform >, L>; using type = mp_second > >; }; #endif #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) template struct mp_at_c_cuda_workaround { using type = mp_if_c<(I < mp_size::value), detail::mp_at_c_impl, void>; }; #endif } // namespace detail #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) template using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type; #else template using mp_at_c = typename mp_if_c<(I < mp_size::value), detail::mp_at_c_impl, void>::type; #endif template using mp_at = mp_at_c; // mp_take(_c) namespace detail { template struct mp_take_c_impl { }; template class L, class... T> struct mp_take_c_impl<0, L> { using type = L<>; }; template class L, class T1, class... T> struct mp_take_c_impl<1, L> { using type = L; }; template class L, class T1, class T2, class... T> struct mp_take_c_impl<2, L> { using type = L; }; template class L, class T1, class T2, class T3, class... T> struct mp_take_c_impl<3, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class... T> struct mp_take_c_impl<4, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class... T> struct mp_take_c_impl<5, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T> struct mp_take_c_impl<6, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T> struct mp_take_c_impl<7, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T> struct mp_take_c_impl<8, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T> struct mp_take_c_impl<9, L> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N> struct mp_take_c_impl, typename std::enable_if= 10>::type> { using type = mp_append, typename mp_take_c_impl>::type>; }; } // namespace detail template using mp_take_c = typename detail::mp_take_c_impl::type; template using mp_take = typename detail::mp_take_c_impl::type; // mp_back template using mp_back = mp_at_c::value - 1>; // mp_pop_back template using mp_pop_back = mp_take_c::value - 1>; // mp_replace namespace detail { template struct mp_replace_impl; template class L, class... T, class V, class W> struct mp_replace_impl, V, W> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template struct _f { using type = mp_if, W, A>; }; using type = L::type...>; #else template using _f = mp_if, W, A>; using type = L<_f...>; #endif }; } // namespace detail template using mp_replace = typename detail::mp_replace_impl::type; // mp_replace_if namespace detail { template class P, class W> struct mp_replace_if_impl; template class L, class... T, template class P, class W> struct mp_replace_if_impl, P, W> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct _f { using type = mp_if, W, U>; }; using type = L::type...>; #else template using _f = mp_if, W, U>; using type = L<_f...>; #endif }; } // namespace detail template class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl::type; template using mp_replace_if_q = mp_replace_if; // mp_copy_if // in detail/mp_copy_if.hpp // mp_remove namespace detail { template struct mp_remove_impl; template class L, class... T, class V> struct mp_remove_impl, V> { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) template struct _f { using type = mp_if, mp_list<>, mp_list>; }; using type = mp_append, typename _f::type...>; #else template using _f = mp_if, mp_list<>, mp_list>; using type = mp_append, _f...>; #endif }; } // namespace detail template using mp_remove = typename detail::mp_remove_impl::type; // mp_remove_if // in detail/mp_remove_if.hpp // mp_flatten> namespace detail { template struct mp_flatten_impl { template using fn = mp_if, T, mp_list>; }; } // namespace detail template> using mp_flatten = mp_apply, L>, mp_clear>>; // mp_partition namespace detail { template class P> struct mp_partition_impl; template class L, class... T, template class P> struct mp_partition_impl, P> { using type = L, P>, mp_remove_if, P>>; }; } // namespace detail template class P> using mp_partition = typename detail::mp_partition_impl::type; template using mp_partition_q = mp_partition; // mp_sort namespace detail { template class P> struct mp_sort_impl; #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T, template class P> struct mp_sort_impl, P> { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = L<>; }; #else template class L, template class P> struct mp_sort_impl, P> { using type = L<>; }; #endif template class L, class T1, template class P> struct mp_sort_impl, P> { using type = L; }; template class L, class T1, class... T, template class P> struct mp_sort_impl, P> { template using F = P; using part = mp_partition, F>; using S1 = typename mp_sort_impl, P>::type; using S2 = typename mp_sort_impl, P>::type; using type = mp_append, S2>; }; } // namespace detail template class P> using mp_sort = typename detail::mp_sort_impl::type; template using mp_sort_q = mp_sort; // mp_nth_element(_c) namespace detail { template class P> struct mp_nth_element_impl; template class L, class T1, std::size_t I, template class P> struct mp_nth_element_impl, I, P> { static_assert( I == 0, "mp_nth_element index out of range" ); using type = T1; }; template class L, class T1, class... T, std::size_t I, template class P> struct mp_nth_element_impl, I, P> { static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" ); template using F = P; using part = mp_partition, F>; using L1 = mp_first; static std::size_t const N1 = mp_size::value; using L2 = mp_second; #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) struct detail { struct mp_nth_element_impl_cuda_workaround { using type = mp_cond< mp_bool<(I < N1)>, mp_nth_element_impl, mp_bool<(I == N1)>, mp_identity, mp_true, mp_nth_element_impl >; }; }; using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type; #else using type = typename mp_cond< mp_bool<(I < N1)>, mp_nth_element_impl, mp_bool<(I == N1)>, mp_identity, mp_true, mp_nth_element_impl >::type; #endif }; } // namespace detail template class P> using mp_nth_element_c = typename detail::mp_nth_element_impl::type; template class P> using mp_nth_element = typename detail::mp_nth_element_impl::type; template using mp_nth_element_q = mp_nth_element; // mp_find namespace detail { template struct mp_find_impl; #if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) struct mp_index_holder { std::size_t i_; bool f_; }; constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f ) { if( v.f_ ) { return v; } else if( f ) { return { v.i_, true }; } else { return { v.i_ + 1, false }; } } template class L, class... T, class V> struct mp_find_impl, V> { static constexpr mp_index_holder _v{ 0, false }; using type = mp_size_t< (_v + ... + std::is_same::value).i_ >; }; #elif !defined( BOOST_MP11_NO_CONSTEXPR ) template class L, class V> struct mp_find_impl, V> { using type = mp_size_t<0>; }; #if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR ) constexpr std::size_t cx_find_index( bool const * first, bool const * last ) { std::size_t m = 0; while( first != last && !*first ) { ++m; ++first; } return m; } #else constexpr std::size_t cx_find_index( bool const * first, bool const * last ) { return first == last || *first? 0: 1 + cx_find_index( first + 1, last ); } #endif template class L, class... T, class V> struct mp_find_impl, V> { static constexpr bool _v[] = { std::is_same::value... }; using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >; }; #else #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T, class V> struct mp_find_impl, V> { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = mp_size_t<0>; }; #else template class L, class V> struct mp_find_impl, V> { using type = mp_size_t<0>; }; #endif template class L, class... T, class V> struct mp_find_impl, V> { using type = mp_size_t<0>; }; template class L, class T1, class... T, class V> struct mp_find_impl, V> { using _r = typename mp_find_impl, V>::type; using type = mp_size_t<1 + _r::value>; }; #endif } // namespace detail template using mp_find = typename detail::mp_find_impl::type; // mp_find_if namespace detail { template class P> struct mp_find_if_impl; #if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) template class L, class... T, template class P> struct mp_find_if_impl, P> { static constexpr mp_index_holder _v{ 0, false }; using type = mp_size_t< (_v + ... + P::value).i_ >; }; #elif !defined( BOOST_MP11_NO_CONSTEXPR ) template class L, template class P> struct mp_find_if_impl, P> { using type = mp_size_t<0>; }; template class L, class... T, template class P> struct mp_find_if_impl, P> { static constexpr bool _v[] = { P::value... }; using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >; }; #else #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T, template class P> struct mp_find_if_impl, P> { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = mp_size_t<0>; }; #else template class L, template class P> struct mp_find_if_impl, P> { using type = mp_size_t<0>; }; #endif template class P> struct mp_find_if_impl_2 { using _r = typename mp_find_if_impl::type; using type = mp_size_t<1 + _r::value>; }; template class L, class T1, class... T, template class P> struct mp_find_if_impl, P> { using type = typename mp_if, mp_identity>, mp_find_if_impl_2, P>>::type; }; #endif } // namespace detail template class P> using mp_find_if = typename detail::mp_find_if_impl::type; template using mp_find_if_q = mp_find_if; // mp_reverse namespace detail { template struct mp_reverse_impl; #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T> struct mp_reverse_impl> { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = L<>; }; #else template class L> struct mp_reverse_impl> { using type = L<>; }; #endif template class L, class T1> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl> { using type = L; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl> { using type = mp_push_back>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>; }; } // namespace detail template using mp_reverse = typename detail::mp_reverse_impl::type; // mp_fold // in detail/mp_fold.hpp // mp_reverse_fold namespace detail { template class F> struct mp_reverse_fold_impl; #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T, class V, template class F> struct mp_reverse_fold_impl, V, F> { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = V; }; #else template class L, class V, template class F> struct mp_reverse_fold_impl, V, F> { using type = V; }; #endif template class L, class T1, class... T, class V, template class F> struct mp_reverse_fold_impl, V, F> { using rest = typename mp_reverse_fold_impl, V, F>::type; using type = F; }; template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template class F> struct mp_reverse_fold_impl, V, F> { using rest = typename mp_reverse_fold_impl, V, F>::type; using type = F > > > > > > > > >; }; } // namespace detail template class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl::type; template using mp_reverse_fold_q = mp_reverse_fold; // mp_unique namespace detail { template struct mp_unique_impl; template class L, class... T> struct mp_unique_impl> { using type = mp_set_push_back, T...>; }; } // namespace detail template using mp_unique = typename detail::mp_unique_impl::type; // mp_unique_if namespace detail { template class P> struct mp_unique_if_push_back { template struct impl { }; template class L, class... Ts, class T> struct impl, T> { using type = mp_if...>, L, L>; }; template using fn = typename impl::type; }; } // namespace detail template class P> using mp_unique_if = mp_fold_q, detail::mp_unique_if_push_back

>; template using mp_unique_if_q = mp_unique_if; // mp_all_of template class P> using mp_all_of = mp_bool< mp_count_if::value == mp_size::value >; template using mp_all_of_q = mp_all_of; // mp_none_of template class P> using mp_none_of = mp_bool< mp_count_if::value == 0 >; template using mp_none_of_q = mp_none_of; // mp_any_of template class P> using mp_any_of = mp_bool< mp_count_if::value != 0 >; template using mp_any_of_q = mp_any_of; // mp_replace_at_c namespace detail { template struct mp_replace_at_impl { static_assert( I::value >= 0, "mp_replace_at: I must not be negative" ); template using _p = std::is_same>; template using _f = W; using type = mp_transform_if<_p, _f, L, mp_iota > >; }; } // namespace detail template using mp_replace_at = typename detail::mp_replace_at_impl::type; template using mp_replace_at_c = typename detail::mp_replace_at_impl, W>::type; //mp_for_each(f) namespace detail { template BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list, F && f ) { using A = int[sizeof...(T)]; return (void)A{ ((void)f(T()), 0)... }, std::forward(f); } template BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f ) { return std::forward(f); } } // namespace detail #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 ) // msvc has a limit of 1024 template BOOST_MP11_CONSTEXPR mp_if_c::value <= 1024, F> mp_for_each( F && f ) { return detail::mp_for_each_impl( mp_rename(), std::forward(f) ); } template BOOST_MP11_CONSTEXPR mp_if_c::value >= 1025, F> mp_for_each( F && f ) { using L2 = mp_rename; using L3 = mp_take_c; using L4 = mp_drop_c; return mp_for_each( mp_for_each( std::forward(f) ) ); } #else template BOOST_MP11_CONSTEXPR F mp_for_each( F && f ) { return detail::mp_for_each_impl( mp_rename(), std::forward(f) ); } #endif // mp_insert template using mp_insert = mp_append, mp_push_front, T...>>; // mp_insert_c template using mp_insert_c = mp_append, mp_push_front, T...>>; // mp_erase template using mp_erase = mp_append, mp_drop>; // mp_erase_c template using mp_erase_c = mp_append, mp_drop_c>; // mp_starts_with // contributed by Glen Joseph Fernandes (glenjofe@gmail.com) namespace detail { template struct mp_starts_with_impl { }; template class L1, class... T1, template class L2, class... T2> struct mp_starts_with_impl, L2 > { template static mp_false check(L); template static mp_true check(mp_list); using type = decltype(check(mp_list())); }; } // namespace detail template using mp_starts_with = typename detail::mp_starts_with_impl::type; // mp_rotate_left(_c) namespace detail { // limit divisor to 1 to avoid division by 0 and give a rotation of 0 for lists containing 0 or 1 elements template using canonical_left_rotation = mp_size_t; // perform right rotation as a left rotation by inverting the number of elements to rotate template using canonical_right_rotation = mp_size_t; // avoid errors when rotating fixed-sized lists by using mp_list for the transformation template> using mp_rotate_impl = mp_assign, mp_take >>; } // namespace detail template using mp_rotate_left_c = detail::mp_rotate_impl::value, N>>; template using mp_rotate_left = mp_rotate_left_c; // mp_rotate_right(_c) template using mp_rotate_right_c = mp_rotate_left::value, N>>; template using mp_rotate_right = mp_rotate_right_c; // mp_min_element // mp_max_element // in detail/mp_min_element.hpp // mp_power_set namespace detail { template struct mp_power_set_impl; } // namespace detail template using mp_power_set = typename detail::mp_power_set_impl::type; namespace detail { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) template class L, class... T> struct mp_power_set_impl< L > { static_assert( sizeof...(T) == 0, "T... must be empty" ); using type = L< L<> >; }; #else template class L> struct mp_power_set_impl< L<> > { using type = L< L<> >; }; #endif template class L, class T1, class... T> struct mp_power_set_impl< L > { using S1 = mp_power_set< L >; template using _f = mp_push_front; using S2 = mp_transform<_f, S1>; using type = mp_append< S1, S2 >; }; } // namespace detail // mp_partial_sum namespace detail { template class F> struct mp_partial_sum_impl_f { #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 ) template using fn = mp_list, T>, mp_push_back, F, T>> >; #else template, T>> using fn = mp_list, N>>; #endif }; } // namespace detail template class F> using mp_partial_sum = mp_second>, detail::mp_partial_sum_impl_f> >; template using mp_partial_sum_q = mp_partial_sum; // mp_iterate namespace detail { template class F, template class R, class N> struct mp_iterate_impl; } // namespace detail template class F, template class R> using mp_iterate = typename detail::mp_iterate_impl>::type; namespace detail { template class F, template class R> struct mp_iterate_impl { template using _f = mp_list>; using type = mp_eval_or, _f, V>; }; template class F, template class R> struct mp_iterate_impl { using type = mp_push_front, F, R>, F>; }; } // namespace detail template using mp_iterate_q = mp_iterate; } // namespace mp11 } // namespace boost #endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED