FM / variant2

/usr/include/boost/variant2

Name	Size	Mode	Actions
variant.hpp	75211	0644	edit dl rm

Edit: /usr/include/boost/variant2/variant.hpp (75211B)

#ifndef BOOST_VARIANT2_VARIANT_HPP_INCLUDED
#define BOOST_VARIANT2_VARIANT_HPP_INCLUDED

// Copyright 2017-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

#if defined(_MSC_VER) && _MSC_VER < 1910
# pragma warning( push )
# pragma warning( disable: 4521 4522 ) // multiple copy operators
#endif

#ifndef BOOST_MP11_HPP_INCLUDED
#include <boost/mp11.hpp>
#endif
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/cstdint.hpp>
#include <cstddef>
#include <type_traits>
#include <exception>
#include <cassert>
#include <initializer_list>
#include <utility>
#include <functional> // std::hash

namespace boost
{

#ifdef BOOST_NO_EXCEPTIONS

BOOST_NORETURN void throw_exception( std::exception const & e ); // user defined

#endif

namespace variant2
{

// bad_variant_access

class bad_variant_access: public std::exception
{
public:

bad_variant_access() noexcept
    {
    }

char const * what() const noexcept
    {
        return "bad_variant_access";
    }
};

namespace detail
{

BOOST_NORETURN inline void throw_bad_variant_access()
{
#ifdef BOOST_NO_EXCEPTIONS

boost::throw_exception( bad_variant_access() );

#else

throw bad_variant_access();

#endif
}

} // namespace detail

// monostate

struct monostate
{
};

constexpr bool operator<(monostate, monostate) noexcept { return false; }
constexpr bool operator>(monostate, monostate) noexcept { return false; }
constexpr bool operator<=(monostate, monostate) noexcept { return true; }
constexpr bool operator>=(monostate, monostate) noexcept { return true; }
constexpr bool operator==(monostate, monostate) noexcept { return true; }
constexpr bool operator!=(monostate, monostate) noexcept { return false; }

// variant forward declaration

template<class... T> class variant;

// variant_size

template<class T> struct variant_size
{
};

template<class T> struct variant_size<T const>: variant_size<T>
{
};

template<class T> struct variant_size<T volatile>: variant_size<T>
{
};

template<class T> struct variant_size<T const volatile>: variant_size<T>
{
};

template<class T> struct variant_size<T&>: variant_size<T>
{
};

template<class T> struct variant_size<T&&>: variant_size<T>
{
};

#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)

template <class T> /*inline*/ constexpr std::size_t variant_size_v = variant_size<T>::value;

#endif

template <class... T> struct variant_size<variant<T...>>: mp11::mp_size<variant<T...>>
{
};

// variant_alternative

template<std::size_t I, class T> struct variant_alternative;

template<std::size_t I, class T> using variant_alternative_t = typename variant_alternative<I, T>::type;

#if BOOST_WORKAROUND(BOOST_GCC, < 40900)

namespace detail
{

template<std::size_t I, class T, bool E> struct variant_alternative_impl
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...>, true>
{
 using type = mp11::mp_at_c<variant<T...>, I>;
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const, true>: std::add_const< mp11::mp_at_c<variant<T...>, I> >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> volatile, true>: std::add_volatile< mp11::mp_at_c<variant<T...>, I> >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const volatile, true>: std::add_cv< mp11::mp_at_c<variant<T...>, I> >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...>&, true>: std::add_lvalue_reference< mp11::mp_at_c<variant<T...>, I> >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const&, true>: std::add_lvalue_reference< mp11::mp_at_c<variant<T...>, I> const >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> volatile&, true>: std::add_lvalue_reference< mp11::mp_at_c<variant<T...>, I> volatile >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const volatile&, true>: std::add_lvalue_reference< mp11::mp_at_c<variant<T...>, I> const volatile >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...>&&, true>: std::add_rvalue_reference< mp11::mp_at_c<variant<T...>, I> >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const&&, true>: std::add_rvalue_reference< mp11::mp_at_c<variant<T...>, I> const >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> volatile&&, true>: std::add_rvalue_reference< mp11::mp_at_c<variant<T...>, I> volatile >
{
};

template<std::size_t I, class... T> struct variant_alternative_impl<I, variant<T...> const volatile&&, true>: std::add_rvalue_reference< mp11::mp_at_c<variant<T...>, I> const volatile >
{
};

} // namespace detail

template<std::size_t I, class T> struct variant_alternative
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...>>: public detail::variant_alternative_impl<I, variant<T...>, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const>: public detail::variant_alternative_impl<I, variant<T...> const, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> volatile>: public detail::variant_alternative_impl<I, variant<T...> volatile, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const volatile>: public detail::variant_alternative_impl<I, variant<T...> const volatile, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...>&>: public detail::variant_alternative_impl<I, variant<T...>&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const&>: public detail::variant_alternative_impl<I, variant<T...> const&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> volatile&>: public detail::variant_alternative_impl<I, variant<T...> volatile&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const volatile&>: public detail::variant_alternative_impl<I, variant<T...> const volatile&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...>&&>: public detail::variant_alternative_impl<I, variant<T...>&&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const&&>: public detail::variant_alternative_impl<I, variant<T...> const&&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> volatile&&>: public detail::variant_alternative_impl<I, variant<T...> volatile&&, (I < sizeof...(T))>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...> const volatile&&>: public detail::variant_alternative_impl<I, variant<T...> const volatile&&, (I < sizeof...(T))>
{
};

#else

namespace detail
{

#if defined( BOOST_MP11_VERSION ) && BOOST_MP11_VERSION >= 107000

template<class I, class T, class Q> using var_alt_impl = mp11::mp_invoke_q<Q, variant_alternative_t<I::value, T>>;

#else

template<class I, class T, class Q> using var_alt_impl = mp11::mp_invoke<Q, variant_alternative_t<I::value, T>>;

#endif

} // namespace detail

template<std::size_t I, class T> struct variant_alternative
{
};

template<std::size_t I, class T> struct variant_alternative<I, T const>: mp11::mp_defer<detail::var_alt_impl, mp11::mp_size_t, T, mp11::mp_quote_trait<std::add_const>>
{
};

template<std::size_t I, class T> struct variant_alternative<I, T volatile>: mp11::mp_defer<detail::var_alt_impl, mp11::mp_size_t, T, mp11::mp_quote_trait<std::add_volatile>>
{
};

template<std::size_t I, class T> struct variant_alternative<I, T const volatile>: mp11::mp_defer<detail::var_alt_impl, mp11::mp_size_t, T, mp11::mp_quote_trait<std::add_cv>>
{
};

template<std::size_t I, class T> struct variant_alternative<I, T&>: mp11::mp_defer<detail::var_alt_impl, mp11::mp_size_t, T, mp11::mp_quote_trait<std::add_lvalue_reference>>
{
};

template<std::size_t I, class T> struct variant_alternative<I, T&&>: mp11::mp_defer<detail::var_alt_impl, mp11::mp_size_t, T, mp11::mp_quote_trait<std::add_rvalue_reference>>
{
};

template<std::size_t I, class... T> struct variant_alternative<I, variant<T...>>: mp11::mp_defer<mp11::mp_at, variant<T...>, mp11::mp_size_t>
{
};

#endif

// variant_npos

constexpr std::size_t variant_npos = ~static_cast<std::size_t>( 0 );

// holds_alternative

template<class U, class... T> constexpr bool holds_alternative( variant<T...> const& v ) noexcept
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
 return v.index() == mp11::mp_find<variant<T...>, U>::value;
}

// get (index)

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>& get(variant<T...>& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return ( v.index() != I? detail::throw_bad_variant_access(): (void)0 ), v._get_impl( mp11::mp_size_t() );
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>&& get(variant<T...>&& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );

#if !BOOST_WORKAROUND(BOOST_MSVC, < 1930)

return ( v.index() != I? detail::throw_bad_variant_access(): (void)0 ), std::move( v._get_impl( mp11::mp_size_t() ) );

#else

if( v.index() != I ) detail::throw_bad_variant_access();
 return std::move( v._get_impl( mp11::mp_size_t() ) );

#endif
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const& get(variant<T...> const& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return ( v.index() != I? detail::throw_bad_variant_access(): (void)0 ), v._get_impl( mp11::mp_size_t() );
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const&& get(variant<T...> const&& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );

#if !BOOST_WORKAROUND(BOOST_MSVC, < 1930)

return ( v.index() != I? detail::throw_bad_variant_access(): (void)0 ), std::move( v._get_impl( mp11::mp_size_t() ) );

#else

if( v.index() != I ) detail::throw_bad_variant_access();
 return std::move( v._get_impl( mp11::mp_size_t() ) );

#endif
}

// detail::unsafe_get (for visit)

namespace detail
{

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>& unsafe_get(variant<T...>& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return v._get_impl( mp11::mp_size_t() );
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>&& unsafe_get(variant<T...>&& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return std::move( v._get_impl( mp11::mp_size_t() ) );
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const& unsafe_get(variant<T...> const& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return v._get_impl( mp11::mp_size_t() );
}

template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const&& unsafe_get(variant<T...> const&& v)
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return std::move( v._get_impl( mp11::mp_size_t() ) );
}

} // namespace detail

// get (type)

template<class U, class... T> constexpr U& get(variant<T...>& v)
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

return ( v.index() != I::value? detail::throw_bad_variant_access(): (void)0 ), v._get_impl( I() );
}

template<class U, class... T> constexpr U&& get(variant<T...>&& v)
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

#if !BOOST_WORKAROUND(BOOST_MSVC, < 1930)

return ( v.index() != I::value? detail::throw_bad_variant_access(): (void)0 ), std::move( v._get_impl( I() ) );

#else

if( v.index() != I::value ) detail::throw_bad_variant_access();
    return std::move( v._get_impl( I() ) );

#endif
}

template<class U, class... T> constexpr U const& get(variant<T...> const& v)
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

return ( v.index() != I::value? detail::throw_bad_variant_access(): (void)0 ), v._get_impl( I() );
}

template<class U, class... T> constexpr U const&& get(variant<T...> const&& v)
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

#if !BOOST_WORKAROUND(BOOST_MSVC, < 1930)

return ( v.index() != I::value? detail::throw_bad_variant_access(): (void)0 ), std::move( v._get_impl( I() ) );

#else

if( v.index() != I::value ) detail::throw_bad_variant_access();
    return std::move( v._get_impl( I() ) );

#endif
}

// get_if

template<std::size_t I, class... T> constexpr typename std::add_pointer<variant_alternative_t<I, variant<T...>>>::type get_if(variant<T...>* v) noexcept
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return v && v->index() == I? &v->_get_impl( mp11::mp_size_t() ): 0;
}

template<std::size_t I, class... T> constexpr typename std::add_pointer<const variant_alternative_t<I, variant<T...>>>::type get_if(variant<T...> const * v) noexcept
{
 static_assert( I < sizeof...(T), "Index out of bounds" );
 return v && v->index() == I? &v->_get_impl( mp11::mp_size_t() ): 0;
}

template<class U, class... T> constexpr typename std::add_pointer::type get_if(variant<T...>* v) noexcept
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

return v && v->index() == I::value? &v->_get_impl( I() ): 0;
}

template<class U, class... T> constexpr typename std::add_pointer::type get_if(variant<T...> const * v) noexcept
{
 static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );

using I = mp11::mp_find<variant<T...>, U>;

return v && v->index() == I::value? &v->_get_impl( I() ): 0;
}

namespace detail
{

// trivially_*

#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000

template<class T> struct is_trivially_copy_constructible: mp11::mp_bool<std::is_copy_constructible<T>::value && std::has_trivial_copy_constructor<T>::value>
{
};

template<class T> struct is_trivially_copy_assignable: mp11::mp_bool<std::is_copy_assignable<T>::value && std::has_trivial_copy_assign<T>::value>
{
};

template<class T> struct is_trivially_move_constructible: mp11::mp_bool<std::is_move_constructible<T>::value && std::is_trivial<T>::value>
{
};

template<class T> struct is_trivially_move_assignable: mp11::mp_bool<std::is_move_assignable<T>::value && std::is_trivial<T>::value>
{
};

#else

using std::is_trivially_copy_constructible;
using std::is_trivially_copy_assignable;
using std::is_trivially_move_constructible;
using std::is_trivially_move_assignable;

#endif

// variant_storage

template<class D, class... T> union variant_storage_impl;

template<class... T> using variant_storage = variant_storage_impl<mp11::mp_all<std::is_trivially_destructible<T>...>, T...>;

template<class D> union variant_storage_impl<D>
{
};

// not all trivially destructible
template<class T1, class... T> union variant_storage_impl<mp11::mp_false, T1, T...>
{
 T1 first_;
 variant_storage<T...> rest_;

template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
 {
 }

template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t, A&&... a ): rest_( mp11::mp_size_t<I-1>(), std::forward<A>(a)... )
 {
 }

~variant_storage_impl()
    {
    }

template<class... A> void emplace( mp11::mp_size_t<0>, A&&... a )
 {
 ::new( &first_ ) T1( std::forward<A>(a)... );
 }

template<std::size_t I, class... A> void emplace( mp11::mp_size_t, A&&... a )
 {
 rest_.emplace( mp11::mp_size_t<I-1>(), std::forward<A>(a)... );
 }

BOOST_CXX14_CONSTEXPR T1& get( mp11::mp_size_t<0> ) noexcept { return first_; }
 constexpr T1 const& get( mp11::mp_size_t<0> ) const noexcept { return first_; }

template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<mp11::mp_list<T...>, I-1>& get( mp11::mp_size_t ) noexcept { return rest_.get( mp11::mp_size_t<I-1>() ); }
 template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-1> const& get( mp11::mp_size_t ) const noexcept { return rest_.get( mp11::mp_size_t<I-1>() ); }
};

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T> union variant_storage_impl<mp11::mp_false, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>
{
 T0 t0_;
 T1 t1_;
 T2 t2_;
 T3 t3_;
 T4 t4_;
 T5 t5_;
 T6 t6_;
 T7 t7_;
 T8 t8_;
 T9 t9_;

variant_storage<T...> rest_;

template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): t0_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<1>, A&&... a ): t1_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<2>, A&&... a ): t2_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<3>, A&&... a ): t3_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<4>, A&&... a ): t4_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<5>, A&&... a ): t5_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<6>, A&&... a ): t6_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<7>, A&&... a ): t7_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<8>, A&&... a ): t8_( std::forward<A>(a)... ) {}
 template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<9>, A&&... a ): t9_( std::forward<A>(a)... ) {}

template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t, A&&... a ): rest_( mp11::mp_size_t<I-10>(), std::forward<A>(a)... ) {}

~variant_storage_impl()
    {
    }

template<class... A> void emplace( mp11::mp_size_t<0>, A&&... a ) { ::new( &t0_ ) T0( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<1>, A&&... a ) { ::new( &t1_ ) T1( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<2>, A&&... a ) { ::new( &t2_ ) T2( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<3>, A&&... a ) { ::new( &t3_ ) T3( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<4>, A&&... a ) { ::new( &t4_ ) T4( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<5>, A&&... a ) { ::new( &t5_ ) T5( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<6>, A&&... a ) { ::new( &t6_ ) T6( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<7>, A&&... a ) { ::new( &t7_ ) T7( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<8>, A&&... a ) { ::new( &t8_ ) T8( std::forward<A>(a)... ); }
 template<class... A> void emplace( mp11::mp_size_t<9>, A&&... a ) { ::new( &t9_ ) T9( std::forward<A>(a)... ); }

template<std::size_t I, class... A> void emplace( mp11::mp_size_t, A&&... a )
 {
 rest_.emplace( mp11::mp_size_t<I-10>(), std::forward<A>(a)... );
 }

BOOST_CXX14_CONSTEXPR T0& get( mp11::mp_size_t<0> ) noexcept { return t0_; }
 constexpr T0 const& get( mp11::mp_size_t<0> ) const noexcept { return t0_; }

BOOST_CXX14_CONSTEXPR T1& get( mp11::mp_size_t<1> ) noexcept { return t1_; }
 constexpr T1 const& get( mp11::mp_size_t<1> ) const noexcept { return t1_; }

BOOST_CXX14_CONSTEXPR T2& get( mp11::mp_size_t<2> ) noexcept { return t2_; }
 constexpr T2 const& get( mp11::mp_size_t<2> ) const noexcept { return t2_; }

BOOST_CXX14_CONSTEXPR T3& get( mp11::mp_size_t<3> ) noexcept { return t3_; }
 constexpr T3 const& get( mp11::mp_size_t<3> ) const noexcept { return t3_; }

BOOST_CXX14_CONSTEXPR T4& get( mp11::mp_size_t<4> ) noexcept { return t4_; }
 constexpr T4 const& get( mp11::mp_size_t<4> ) const noexcept { return t4_; }

BOOST_CXX14_CONSTEXPR T5& get( mp11::mp_size_t<5> ) noexcept { return t5_; }
 constexpr T5 const& get( mp11::mp_size_t<5> ) const noexcept { return t5_; }

BOOST_CXX14_CONSTEXPR T6& get( mp11::mp_size_t<6> ) noexcept { return t6_; }
 constexpr T6 const& get( mp11::mp_size_t<6> ) const noexcept { return t6_; }

BOOST_CXX14_CONSTEXPR T7& get( mp11::mp_size_t<7> ) noexcept { return t7_; }
 constexpr T7 const& get( mp11::mp_size_t<7> ) const noexcept { return t7_; }

BOOST_CXX14_CONSTEXPR T8& get( mp11::mp_size_t<8> ) noexcept { return t8_; }
 constexpr T8 const& get( mp11::mp_size_t<8> ) const noexcept { return t8_; }

BOOST_CXX14_CONSTEXPR T9& get( mp11::mp_size_t<9> ) noexcept { return t9_; }
 constexpr T9 const& get( mp11::mp_size_t<9> ) const noexcept { return t9_; }

template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<mp11::mp_list<T...>, I-10>& get( mp11::mp_size_t ) noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
 template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-10> const& get( mp11::mp_size_t ) const noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
};

// all trivially destructible
template<class T1, class... T> union variant_storage_impl<mp11::mp_true, T1, T...>
{
 T1 first_;
 variant_storage<T...> rest_;

template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
 {
 }

template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t, A&&... a ): rest_( mp11::mp_size_t<I-1>(), std::forward<A>(a)... )
 {
 }

template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<0>, A&&... a )
 {
 ::new( &first_ ) T1( std::forward<A>(a)... );
 }

template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_false, mp11::mp_size_t, A&&... a )
 {
 rest_.emplace( mp11::mp_size_t<I-1>(), std::forward<A>(a)... );
 }

template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_true, mp11::mp_size_t, A&&... a )
 {
 *this = variant_storage_impl( mp11::mp_size_t(), std::forward<A>(a)... );
 }

BOOST_CXX14_CONSTEXPR T1& get( mp11::mp_size_t<0> ) noexcept { return first_; }
 constexpr T1 const& get( mp11::mp_size_t<0> ) const noexcept { return first_; }

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T> union variant_storage_impl<mp11::mp_true, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>
{
 T0 t0_;
 T1 t1_;
 T2 t2_;
 T3 t3_;
 T4 t4_;
 T5 t5_;
 T6 t6_;
 T7 t7_;
 T8 t8_;
 T9 t9_;

variant_storage<T...> rest_;

template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t, A&&... a ): rest_( mp11::mp_size_t<I-10>(), std::forward<A>(a)... ) {}

template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<0>, A&&... a ) { ::new( &t0_ ) T0( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<1>, A&&... a ) { ::new( &t1_ ) T1( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<2>, A&&... a ) { ::new( &t2_ ) T2( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<3>, A&&... a ) { ::new( &t3_ ) T3( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<4>, A&&... a ) { ::new( &t4_ ) T4( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<5>, A&&... a ) { ::new( &t5_ ) T5( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<6>, A&&... a ) { ::new( &t6_ ) T6( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<7>, A&&... a ) { ::new( &t7_ ) T7( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<8>, A&&... a ) { ::new( &t8_ ) T8( std::forward<A>(a)... ); }
 template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<9>, A&&... a ) { ::new( &t9_ ) T9( std::forward<A>(a)... ); }

template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_false, mp11::mp_size_t, A&&... a )
 {
 rest_.emplace( mp11::mp_size_t<I-10>(), std::forward<A>(a)... );
 }

template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace( mp11::mp_size_t, A&&... a )
 {
 this->emplace_impl( mp11::mp_all<
 detail::is_trivially_move_assignable<T0>,
 detail::is_trivially_move_assignable<T1>,
 detail::is_trivially_move_assignable<T2>,
 detail::is_trivially_move_assignable<T3>,
 detail::is_trivially_move_assignable<T4>,
 detail::is_trivially_move_assignable<T5>,
 detail::is_trivially_move_assignable<T6>,
 detail::is_trivially_move_assignable<T7>,
 detail::is_trivially_move_assignable<T8>,
 detail::is_trivially_move_assignable<T9>,
 detail::is_trivially_move_assignable<T>...>(), mp11::mp_size_t(), std::forward<A>(a)... );
 }