[ceph.git] / ceph / src / boost / boost / mp11 / detail / mp_with_index.hpp

#ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
#define BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED

//  Copyright 2017 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/integral.hpp>
#include <boost/mp11/detail/config.hpp>
#include <type_traits>
#include <utility>
#include <cassert>

#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
# define BOOST_MP11_CONSTEXPR14 constexpr
#else
# define BOOST_MP11_CONSTEXPR14
#endif

#if defined( __GNUC__ ) || defined( __clang__ )
# define BOOST_MP11_UNREACHABLE_DEFAULT default: __builtin_unreachable();
#elif defined( _MSC_VER )
# define BOOST_MP11_UNREACHABLE_DEFAULT default: __assume(false);
#else
# define BOOST_MP11_UNREACHABLE_DEFAULT
#endif

namespace boost
{
namespace mp11
{

namespace detail
{

template<std::size_t N> struct mp_with_index_impl_
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
        case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
        }

        return mp_with_index_impl_<N-16>::template call<K+16>( i-16, std::forward<F>(f) );
    }
};

template<> struct mp_with_index_impl_<0>
{
};

template<> struct mp_with_index_impl_<1>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t /*i*/, F && f )
    {
        return std::forward<F>(f)( mp_size_t<K+0>() );
    }
};

template<> struct mp_with_index_impl_<2>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        }
    }
};

template<> struct mp_with_index_impl_<3>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        }
    }
};

template<> struct mp_with_index_impl_<4>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        }
    }
};

template<> struct mp_with_index_impl_<5>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        }
    }
};

template<> struct mp_with_index_impl_<6>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        }
    }
};

template<> struct mp_with_index_impl_<7>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        }
    }
};

template<> struct mp_with_index_impl_<8>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        }
    }
};

template<> struct mp_with_index_impl_<9>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        }
    }
};

template<> struct mp_with_index_impl_<10>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        }
    }
};

template<> struct mp_with_index_impl_<11>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        }
    }
};

template<> struct mp_with_index_impl_<12>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        }
    }
};

template<> struct mp_with_index_impl_<13>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        }
    }
};

template<> struct mp_with_index_impl_<14>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        }
    }
};

template<> struct mp_with_index_impl_<15>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
        }
    }
};

template<> struct mp_with_index_impl_<16>
{
    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        BOOST_MP11_UNREACHABLE_DEFAULT
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
        case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
        }
    }
};

} // namespace detail

template<std::size_t N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
{
    assert( i < N );
    return detail::mp_with_index_impl_<N>::template call<0>( i, std::forward<F>(f) );
}

template<class N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
{
    return mp_with_index<std::size_t{N::value}>( i, std::forward<F>(f) );
}

#undef BOOST_MP11_CONSTEXPR14
#undef BOOST_MP11_UNREACHABLE_DEFAULT

} // namespace mp11
} // namespace boost

#endif // #ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
Commit	Line	Data
b32b8144 FG	1	#ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
	2	#define BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
	3
	4	// Copyright 2017 Peter Dimov.
	5	//
	6	// Distributed under the Boost Software License, Version 1.0.
	7	//
	8	// See accompanying file LICENSE_1_0.txt or copy at
	9	// http://www.boost.org/LICENSE_1_0.txt
	10
	11	#include <boost/mp11/integral.hpp>
92f5a8d4	12	#include <boost/mp11/detail/config.hpp>
b32b8144 FG	13	#include <type_traits>
	14	#include <utility>
	15	#include <cassert>
	16
92f5a8d4	17	#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
b32b8144 FG	18	# define BOOST_MP11_CONSTEXPR14 constexpr
	19	#else
	20	# define BOOST_MP11_CONSTEXPR14
	21	#endif
	22
f67539c2 TL	23	#if defined( __GNUC__ ) \|\| defined( __clang__ )
	24	# define BOOST_MP11_UNREACHABLE_DEFAULT default: __builtin_unreachable();
	25	#elif defined( _MSC_VER )
	26	# define BOOST_MP11_UNREACHABLE_DEFAULT default: __assume(false);
92f5a8d4	27	#else
f67539c2	28	# define BOOST_MP11_UNREACHABLE_DEFAULT
92f5a8d4 TL	29	#endif
92f5a8d4 TL	30
b32b8144 FG	31	namespace boost
	32	{
	33	namespace mp11
	34	{
	35
	36	namespace detail
	37	{
	38
	39	template<std::size_t N> struct mp_with_index_impl_
	40	{
	41	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	42	{
	43	switch( i )
	44	{
	45	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	46	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	47	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	48	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	49	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	50	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	51	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	52	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	53	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	54	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	55	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
	56	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
	57	case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
	58	case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
	59	case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
	60	case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
	61	}
	62
	63	return mp_with_index_impl_<N-16>::template call<K+16>( i-16, std::forward<F>(f) );
	64	}
	65	};
	66
	67	template<> struct mp_with_index_impl_<0>
	68	{
	69	};
	70
	71	template<> struct mp_with_index_impl_<1>
	72	{
	73	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t /i/, F && f )
	74	{
	75	return std::forward<F>(f)( mp_size_t<K+0>() );
	76	}
	77	};
	78
	79	template<> struct mp_with_index_impl_<2>
	80	{
	81	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	82	{
	83	switch( i )
	84	{
f67539c2	85	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144	86	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
92f5a8d4	87	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
b32b8144 FG	88	}
	89	}
	90	};
	91
	92	template<> struct mp_with_index_impl_<3>
	93	{
	94	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	95	{
	96	switch( i )
	97	{
f67539c2	98	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	99	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
b32b8144 FG	100	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
92f5a8d4	101	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
b32b8144 FG	102	}
	103	}
	104	};
	105
	106	template<> struct mp_with_index_impl_<4>
	107	{
	108	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	109	{
	110	switch( i )
	111	{
f67539c2	112	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	113	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	114	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	115	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
92f5a8d4	116	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
b32b8144 FG	117	}
	118	}
	119	};
	120
	121	template<> struct mp_with_index_impl_<5>
	122	{
	123	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	124	{
	125	switch( i )
	126	{
f67539c2	127	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	128	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	129	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	130	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	131	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
92f5a8d4	132	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
b32b8144 FG	133	}
	134	}
	135	};
	136
	137	template<> struct mp_with_index_impl_<6>
	138	{
	139	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	140	{
	141	switch( i )
	142	{
f67539c2	143	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	144	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	145	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	146	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	147	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	148	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
92f5a8d4	149	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
b32b8144 FG	150	}
	151	}
	152	};
	153
	154	template<> struct mp_with_index_impl_<7>
	155	{
	156	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	157	{
	158	switch( i )
	159	{
f67539c2	160	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	161	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	162	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	163	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	164	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	165	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	166	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
92f5a8d4	167	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
b32b8144 FG	168	}
	169	}
	170	};
	171
	172	template<> struct mp_with_index_impl_<8>
	173	{
	174	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	175	{
	176	switch( i )
	177	{
f67539c2	178	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	179	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	180	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	181	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	182	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	183	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	184	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	185	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
92f5a8d4	186	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
b32b8144 FG	187	}
	188	}
	189	};
	190
	191	template<> struct mp_with_index_impl_<9>
	192	{
	193	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	194	{
	195	switch( i )
	196	{
f67539c2	197	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	198	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	199	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	200	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	201	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	202	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	203	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	204	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	205	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
92f5a8d4	206	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
b32b8144 FG	207	}
	208	}
	209	};
	210
	211	template<> struct mp_with_index_impl_<10>
	212	{
	213	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	214	{
	215	switch( i )
	216	{
f67539c2	217	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	218	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	219	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	220	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	221	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	222	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	223	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	224	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	225	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	226	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
92f5a8d4	227	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
b32b8144 FG	228	}
	229	}
	230	};
	231
	232	template<> struct mp_with_index_impl_<11>
	233	{
	234	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	235	{
	236	switch( i )
	237	{
f67539c2	238	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	239	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	240	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	241	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	242	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	243	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	244	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	245	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	246	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	247	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	248	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
92f5a8d4	249	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
b32b8144 FG	250	}
	251	}
	252	};
	253
	254	template<> struct mp_with_index_impl_<12>
	255	{
	256	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	257	{
	258	switch( i )
	259	{
f67539c2	260	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	261	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	262	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	263	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	264	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	265	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	266	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	267	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	268	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	269	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	270	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	271	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
92f5a8d4	272	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
b32b8144 FG	273	}
	274	}
	275	};
	276
	277	template<> struct mp_with_index_impl_<13>
	278	{
	279	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	280	{
	281	switch( i )
	282	{
f67539c2	283	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	284	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	285	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	286	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	287	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	288	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	289	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	290	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	291	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	292	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	293	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	294	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
	295	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
92f5a8d4	296	case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
b32b8144 FG	297	}
	298	}
	299	};
	300
	301	template<> struct mp_with_index_impl_<14>
	302	{
	303	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	304	{
	305	switch( i )
	306	{
f67539c2	307	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	308	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	309	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	310	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	311	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	312	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	313	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	314	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	315	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	316	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	317	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	318	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
	319	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
	320	case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
92f5a8d4	321	case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
b32b8144 FG	322	}
	323	}
	324	};
	325
	326	template<> struct mp_with_index_impl_<15>
	327	{
	328	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	329	{
	330	switch( i )
	331	{
f67539c2	332	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	333	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	334	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	335	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	336	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	337	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	338	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	339	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	340	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	341	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	342	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	343	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
	344	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
	345	case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
	346	case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
92f5a8d4	347	case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
b32b8144 FG	348	}
	349	}
	350	};
	351
	352	template<> struct mp_with_index_impl_<16>
	353	{
	354	template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
	355	{
	356	switch( i )
	357	{
f67539c2	358	BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	359	case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
	360	case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
	361	case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
	362	case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
	363	case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
	364	case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
	365	case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
	366	case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
	367	case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
	368	case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
	369	case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
	370	case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
	371	case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
	372	case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
	373	case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
92f5a8d4	374	case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
b32b8144 FG	375	}
	376	}
	377	};
	378
	379	} // namespace detail
	380
	381	template<std::size_t N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
	382	{
	383	assert( i < N );
	384	return detail::mp_with_index_impl_<N>::template call<0>( i, std::forward<F>(f) );
	385	}
	386
	387	template<class N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
	388	{
	389	return mp_with_index<std::size_t{N::value}>( i, std::forward<F>(f) );
	390	}
	391
	392	#undef BOOST_MP11_CONSTEXPR14
f67539c2	393	#undef BOOST_MP11_UNREACHABLE_DEFAULT
b32b8144 FG	394
	395	} // namespace mp11
	396	} // namespace boost
	397
	398	#endif // #ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED