10#ifndef NONSTD_VARIANT_LITE_HPP
11#define NONSTD_VARIANT_LITE_HPP
13#define variant_lite_MAJOR 2
14#define variant_lite_MINOR 0
15#define variant_lite_PATCH 0
17#define variant_lite_VERSION variant_STRINGIFY(variant_lite_MAJOR) "." variant_STRINGIFY(variant_lite_MINOR) "." variant_STRINGIFY(variant_lite_PATCH)
19#define variant_STRINGIFY( x ) variant_STRINGIFY_( x )
20#define variant_STRINGIFY_( x ) #x
24#define variant_VARIANT_DEFAULT 0
25#define variant_VARIANT_NONSTD 1
26#define variant_VARIANT_STD 2
31# if __has_include(<nonstd/variant.tweak.hpp>)
32# include <nonstd/variant.tweak.hpp>
34#define variant_HAVE_TWEAK_HEADER 1
36#define variant_HAVE_TWEAK_HEADER 0
42#ifndef variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO
43# define variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO 0
46#ifndef variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO
47# define variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO 0
52#ifndef variant_CONFIG_NO_EXCEPTIONS
56# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
57# define variant_CONFIG_NO_EXCEPTIONS 0
59# define variant_CONFIG_NO_EXCEPTIONS 1
66#ifndef variant_CPLUSPLUS
67# if defined(_MSVC_LANG ) && !defined(__clang__)
68# define variant_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
70# define variant_CPLUSPLUS __cplusplus
74#define variant_CPP98_OR_GREATER ( variant_CPLUSPLUS >= 199711L )
75#define variant_CPP11_OR_GREATER ( variant_CPLUSPLUS >= 201103L )
76#define variant_CPP11_OR_GREATER_ ( variant_CPLUSPLUS >= 201103L )
77#define variant_CPP14_OR_GREATER ( variant_CPLUSPLUS >= 201402L )
78#define variant_CPP17_OR_GREATER ( variant_CPLUSPLUS >= 201703L )
79#define variant_CPP20_OR_GREATER ( variant_CPLUSPLUS >= 202000L )
83#if variant_CPP17_OR_GREATER && defined(__has_include )
84# if __has_include( <variant> )
85# define variant_HAVE_STD_VARIANT 1
87# define variant_HAVE_STD_VARIANT 0
90# define variant_HAVE_STD_VARIANT 0
93#if !defined( variant_CONFIG_SELECT_VARIANT )
94# define variant_CONFIG_SELECT_VARIANT ( variant_HAVE_STD_VARIANT ? variant_VARIANT_STD : variant_VARIANT_NONSTD )
97#define variant_USES_STD_VARIANT ( (variant_CONFIG_SELECT_VARIANT == variant_VARIANT_STD) || ((variant_CONFIG_SELECT_VARIANT == variant_VARIANT_DEFAULT) && variant_HAVE_STD_VARIANT) )
103#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
104#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
108#if variant_CPP17_OR_GREATER
115using std::in_place_type;
116using std::in_place_index;
117using std::in_place_t;
118using std::in_place_type_t;
119using std::in_place_index_t;
121#define nonstd_lite_in_place_t( T) std::in_place_t
122#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
123#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
125#define nonstd_lite_in_place( T) std::in_place_t{}
126#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
127#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
139struct in_place_type_tag {};
141template< std::
size_t K >
142struct in_place_index_tag {};
149inline in_place_t
in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
154template< std::
size_t K >
155inline in_place_t
in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
161inline in_place_t
in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
166template< std::
size_t K >
167inline in_place_t
in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
174#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
175#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
176#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
178#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
179#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
180#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
193template< std::
size_t K >
196template< std::
size_t K >
199#define variant_index_tag_t(K) void(&)( nonstd::variants::detail::index_tag_t<K> )
200#define variant_index_tag(K) nonstd::variants::detail::index_tag<K>
210#if variant_USES_STD_VARIANT
215#if ! variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO
216# define variant_size_V(T) nonstd::variant_size<T>::value
219#if ! variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO
220# define variant_alternative_T(K,T) typename nonstd::variant_alternative<K,T >::type
226 using std::monostate;
227 using std::bad_variant_access;
228 using std::variant_size;
229 using std::variant_size_v;
230 using std::variant_alternative;
231 using std::variant_alternative_t;
235 using std::holds_alternative;
238 using std::operator==;
239 using std::operator!=;
240 using std::operator<;
241 using std::operator<=;
242 using std::operator>;
243 using std::operator>=;
246 constexpr auto variant_npos = std::variant_npos;
256#if variant_CONFIG_NO_EXCEPTIONS
264#define variant_CONFIG_MAX_TYPE_COUNT 16
265#define variant_CONFIG_MAX_VISITOR_ARG_COUNT 5
269#ifndef variant_CONFIG_MAX_ALIGN_HACK
270# define variant_CONFIG_MAX_ALIGN_HACK 0
273#ifndef variant_CONFIG_ALIGN_AS
277#ifndef variant_CONFIG_ALIGN_AS_FALLBACK
278# define variant_CONFIG_ALIGN_AS_FALLBACK double
282#define variant_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
298#if defined(_MSC_VER ) && !defined(__clang__)
299# define variant_COMPILER_MSVC_VER (_MSC_VER )
300# define variant_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
302# define variant_COMPILER_MSVC_VER 0
303# define variant_COMPILER_MSVC_VERSION 0
306#define variant_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
308#if defined(__clang__)
309# define variant_COMPILER_CLANG_VERSION variant_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
311# define variant_COMPILER_CLANG_VERSION 0
314#if defined(__GNUC__) && !defined(__clang__)
315# define variant_COMPILER_GNUC_VERSION variant_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
317# define variant_COMPILER_GNUC_VERSION 0
320#if variant_BETWEEN( variant_COMPILER_MSVC_VER, 1300, 1900 )
321# pragma warning( push )
322# pragma warning( disable: 4345 )
327#define variant_HAVE( feature ) ( variant_HAVE_##feature )
330# define variant_HAS_CPP0X _HAS_CPP0X
332# define variant_HAS_CPP0X 0
337#if variant_COMPILER_MSVC_VER >= 1900
338# undef variant_CPP11_OR_GREATER
339# define variant_CPP11_OR_GREATER 1
342#define variant_CPP11_90 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1500)
343#define variant_CPP11_100 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1600)
344#define variant_CPP11_110 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1700)
345#define variant_CPP11_120 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1800)
346#define variant_CPP11_140 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1900)
347#define variant_CPP11_141 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1910)
349#define variant_CPP14_000 (variant_CPP14_OR_GREATER)
350#define variant_CPP17_000 (variant_CPP17_OR_GREATER)
354#define variant_HAVE_CONSTEXPR_11 variant_CPP11_140
355#define variant_HAVE_INITIALIZER_LIST variant_CPP11_120
356#define variant_HAVE_NOEXCEPT variant_CPP11_140
357#define variant_HAVE_NULLPTR variant_CPP11_100
358#define variant_HAVE_OVERRIDE variant_CPP11_140
362#define variant_HAVE_CONSTEXPR_14 variant_CPP14_000
370#define variant_HAVE_CONDITIONAL variant_CPP11_120
371#define variant_HAVE_REMOVE_CV variant_CPP11_120
372#define variant_HAVE_STD_ADD_POINTER variant_CPP11_100
373#define variant_HAVE_TYPE_TRAITS variant_CPP11_90
374#define variant_HAVE_ENABLE_IF variant_CPP11_100
375#define variant_HAVE_IS_SAME variant_CPP11_100
377#define variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )
378#define variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION || variant_CPP11_90)
382#if variant_HAVE_CONSTEXPR_11
383# define variant_constexpr constexpr
385# define variant_constexpr
388#if variant_HAVE_CONSTEXPR_14
389# define variant_constexpr14 constexpr
391# define variant_constexpr14
394#if variant_HAVE_NOEXCEPT
395# define variant_noexcept noexcept
397# define variant_noexcept
400#if variant_HAVE_NULLPTR
401# define variant_nullptr nullptr
403# define variant_nullptr NULL
406#if variant_HAVE_OVERRIDE
407# define variant_override override
409# define variant_override
414#if variant_CPP11_OR_GREATER
415# include <functional>
418#if variant_HAVE_INITIALIZER_LIST
419# include <initializer_list>
422#if variant_HAVE_TYPE_TRAITS
423# include <type_traits>
424#elif variant_HAVE_TR1_TYPE_TRAITS
425# include <tr1/type_traits>
432namespace nonstd {
namespace variants {
438#if variant_HAVE_STD_ADD_POINTER
440using std::add_pointer;
442#elif variant_HAVE_TR1_ADD_POINTER
444using std::tr1::add_pointer;
458#if variant_HAVE_REMOVE_CV
478#if variant_HAVE_CONDITIONAL
480using std::conditional;
484template<
bool Cond,
class Then,
class Else >
487template<
class Then,
class Else >
490template<
class Then,
class Else >
495#if variant_HAVE_ENABLE_IF
501template<
bool B,
class T =
void >
509#if variant_HAVE_IS_SAME
515template<
class T,
class U >
531#if variant_CPP11_OR_GREATER
533#define variant_REQUIRES_T(...) \
534 , typename std::enable_if< (__VA_ARGS__), int >::type = 0
536#define variant_REQUIRES_R(R, ...) \
537 typename std::enable_if< (__VA_ARGS__), R>::type
539#define variant_REQUIRES_A(...) \
540 , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
544#define variant_REQUIRES_0(...) \
545 template< bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0 >
547#define variant_REQUIRES_B(...) \
548 , bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0
554#if variant_CPP17_OR_GREATER
556using std::is_swappable;
557using std::is_nothrow_swappable;
559#elif variant_CPP11_OR_GREATER
567 template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
568 static std::true_type test(
int );
571 static std::false_type test(...);
574struct is_nothrow_swappable
578 template<
typename T >
579 static constexpr bool test()
581 return noexcept( swap( std::declval<T&>(), std::declval<T&>() ) );
584 template<
typename T >
585 static auto test(
int ) -> std::integral_constant<bool, test<T>()>{}
588 static std::false_type test(...);
595template<
typename T >
596struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
598template<
typename T >
599struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
611#define variant_TL1( T1 ) detail::typelist< T1, detail::nulltype >
612#define variant_TL2( T1, T2) detail::typelist< T1, variant_TL1( T2) >
613#define variant_TL3( T1, T2, T3) detail::typelist< T1, variant_TL2( T2, T3) >
614#define variant_TL4( T1, T2, T3, T4) detail::typelist< T1, variant_TL3( T2, T3, T4) >
615#define variant_TL5( T1, T2, T3, T4, T5) detail::typelist< T1, variant_TL4( T2, T3, T4, T5) >
616#define variant_TL6( T1, T2, T3, T4, T5, T6) detail::typelist< T1, variant_TL5( T2, T3, T4, T5, T6) >
617#define variant_TL7( T1, T2, T3, T4, T5, T6, T7) detail::typelist< T1, variant_TL6( T2, T3, T4, T5, T6, T7) >
618#define variant_TL8( T1, T2, T3, T4, T5, T6, T7, T8) detail::typelist< T1, variant_TL7( T2, T3, T4, T5, T6, T7, T8) >
619#define variant_TL9( T1, T2, T3, T4, T5, T6, T7, T8, T9) detail::typelist< T1, variant_TL8( T2, T3, T4, T5, T6, T7, T8, T9) >
620#define variant_TL10( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) detail::typelist< T1, variant_TL9( T2, T3, T4, T5, T6, T7, T8, T9, T10) >
621#define variant_TL11( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) detail::typelist< T1, variant_TL10( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
622#define variant_TL12( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) detail::typelist< T1, variant_TL11( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) >
623#define variant_TL13( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) detail::typelist< T1, variant_TL12( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) >
624#define variant_TL14( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) detail::typelist< T1, variant_TL13( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) >
625#define variant_TL15( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) detail::typelist< T1, variant_TL14( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) >
626#define variant_TL16( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) detail::typelist< T1, variant_TL15( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) >
649 template<
class U >
inline TX<T> operator<<( U
const & )
const {
return TX<T>(); }
653 inline bool operator< ( T
const & )
const {
return false; }
683template<
class Head,
class Tail >
692template<
class List >
698 enum V { value = 0 } ;
702template<
class Head,
class Tail >
711 enum V { value = (
sizeof( Head ) > tail_value) ?
sizeof( Head ) : std::size_t( tail_value ) } ;
716#if variant_CPP11_OR_GREATER
720template<
class List >
721struct typelist_max_alignof;
724struct typelist_max_alignof<
nulltype >
726 enum V { value = 0 } ;
729template<
class Head,
class Tail >
730struct typelist_max_alignof< typelist<Head, Tail> >
733 enum TV { tail_value = size_t( typelist_max_alignof<Tail>::value ) };
736 enum V { value = (
alignof( Head ) > tail_value) ?
alignof( Head ) : std::size_t( tail_value ) };
743template<
class List >
769template<
class Head,
class Tail >
777template<
class List,
class T >
783 enum V { value = -1 };
786template<
class Tail,
class T >
789 enum V { value = 0 };
792template<
class Head,
class Tail,
class T >
799 enum V { value = nextVal == -1 ? -1 : 1 + nextVal } ;
804template<
class List, std::
size_t i>
807template<
class Head,
class Tail >
813template<
class Head,
class Tail, std::
size_t i >
821template< class List, std::size_t CmpIndex, std::size_t LastChecked = typelist_size<List>::value >
833template<
class List, std::
size_t CmpIndex >
839template<
class List,
class T >
844#if variant_CONFIG_MAX_ALIGN_HACK
848#define variant_UNIQUE( name ) variant_UNIQUE2( name, __LINE__ )
849#define variant_UNIQUE2( name, line ) variant_UNIQUE3( name, line )
850#define variant_UNIQUE3( name, line ) name ## line
852#define variant_ALIGN_TYPE( type ) \
853 type variant_UNIQUE( _t ); struct_t< type > variant_UNIQUE( _st )
882 Unknown ( * variant_UNIQUE(_) )( Unknown );
883 Unknown * Unknown::* variant_UNIQUE(_);
884 Unknown ( Unknown::* variant_UNIQUE(_) )( Unknown );
886 struct_t< Unknown ( * )( Unknown) > variant_UNIQUE(_);
887 struct_t< Unknown * Unknown::* > variant_UNIQUE(_);
888 struct_t< Unknown ( Unknown::* )(Unknown) > variant_UNIQUE(_);
892#undef variant_UNIQUE2
893#undef variant_UNIQUE3
895#undef variant_ALIGN_TYPE
897#elif defined( variant_CONFIG_ALIGN_AS )
901#define variant_ALIGN_AS( unused ) \
902 variant_CONFIG_ALIGN_AS
908#define variant_ALIGN_AS( to_align ) \
909 typename detail::type_of_size< detail::alignment_types, detail::alignment_of< to_align >::value >::type
911template<
typename T >
914template<
typename T >
922template<
size_t A,
size_t S >
925 enum V { value = A < S ? A : S };
928template<
typename T >
935template<
typename List,
size_t N >
939 N ==
sizeof(
typename List::head ),
953#define variant_ALIGN_TYPE( type ) \
954 typelist< type , typelist< struct_t< type >
980 > > > > > > > > > > > > > >
981 > > > > > > > > > > > > > >
985#undef variant_ALIGN_TYPE
989#if variant_CPP11_OR_GREATER
992inline std::size_t hash( T
const & v )
994 return std::hash<T>()( v );
997inline std::size_t hash(
T0 const & ) {
return 0; }
998inline std::size_t hash(
T1 const & ) {
return 0; }
999inline std::size_t hash(
T2 const & ) {
return 0; }
1000inline std::size_t hash(
T3 const & ) {
return 0; }
1001inline std::size_t hash(
T4 const & ) {
return 0; }
1002inline std::size_t hash(
T5 const & ) {
return 0; }
1003inline std::size_t hash(
T6 const & ) {
return 0; }
1004inline std::size_t hash(
T7 const & ) {
return 0; }
1005inline std::size_t hash(
T8 const & ) {
return 0; }
1006inline std::size_t hash(
T9 const & ) {
return 0; }
1007inline std::size_t hash(
T10 const & ) {
return 0; }
1008inline std::size_t hash(
T11 const & ) {
return 0; }
1009inline std::size_t hash(
T12 const & ) {
return 0; }
1010inline std::size_t hash(
T13 const & ) {
return 0; }
1011inline std::size_t hash(
T14 const & ) {
return 0; }
1012inline std::size_t hash(
T15 const & ) {
return 0; }
1021template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
1025 typedef variant_TL16(
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15 ) variant_types;
1028 static U *
as(
void * data )
1030 return reinterpret_cast<U*
>( data );
1034 static U
const *
as(
void const * data )
1036 return reinterpret_cast<const U*
>( data );
1048 case 0: as<T0>( data )->~T0();
break;
1049 case 1: as<T1>( data )->~T1();
break;
1050 case 2: as<T2>( data )->~T2();
break;
1051 case 3: as<T3>( data )->~T3();
break;
1052 case 4: as<T4>( data )->~T4();
break;
1053 case 5: as<T5>( data )->~T5();
break;
1054 case 6: as<T6>( data )->~T6();
break;
1055 case 7: as<T7>( data )->~T7();
break;
1056 case 8: as<T8>( data )->~T8();
break;
1057 case 9: as<T9>( data )->~T9();
break;
1058 case 10: as<T10>( data )->~T10();
break;
1059 case 11: as<T11>( data )->~T11();
break;
1060 case 12: as<T12>( data )->~T12();
break;
1061 case 13: as<T13>( data )->~T13();
break;
1062 case 14: as<T14>( data )->~T14();
break;
1063 case 15: as<T15>( data )->~T15();
break;
1068#if variant_CPP11_OR_GREATER
1069 template<
class T,
class... Args >
1070 static type_index_t construct_t(
void * data, Args&&... args )
1072 new( data ) T( std::forward<Args>(args)... );
1077 template< std::size_t K,
class... Args >
1078 static type_index_t construct_i(
void * data, Args&&... args )
1082 construct_t< type >( data, std::forward<Args>(args)... );
1089 switch ( from_index )
1091 case 0:
new( to_value )
T0( std::move( *as<T0>( from_value ) ) );
break;
1092 case 1:
new( to_value )
T1( std::move( *as<T1>( from_value ) ) );
break;
1093 case 2:
new( to_value )
T2( std::move( *as<T2>( from_value ) ) );
break;
1094 case 3:
new( to_value )
T3( std::move( *as<T3>( from_value ) ) );
break;
1095 case 4:
new( to_value )
T4( std::move( *as<T4>( from_value ) ) );
break;
1096 case 5:
new( to_value )
T5( std::move( *as<T5>( from_value ) ) );
break;
1097 case 6:
new( to_value )
T6( std::move( *as<T6>( from_value ) ) );
break;
1098 case 7:
new( to_value )
T7( std::move( *as<T7>( from_value ) ) );
break;
1099 case 8:
new( to_value )
T8( std::move( *as<T8>( from_value ) ) );
break;
1100 case 9:
new( to_value )
T9( std::move( *as<T9>( from_value ) ) );
break;
1101 case 10:
new( to_value )
T10( std::move( *as<T10>( from_value ) ) );
break;
1102 case 11:
new( to_value )
T11( std::move( *as<T11>( from_value ) ) );
break;
1103 case 12:
new( to_value )
T12( std::move( *as<T12>( from_value ) ) );
break;
1104 case 13:
new( to_value )
T13( std::move( *as<T13>( from_value ) ) );
break;
1105 case 14:
new( to_value )
T14( std::move( *as<T14>( from_value ) ) );
break;
1106 case 15:
new( to_value )
T15( std::move( *as<T15>( from_value ) ) );
break;
1114 switch ( from_index )
1116 case 0: *as<T0>( to_value ) = std::move( *as<T0>( from_value ) );
break;
1117 case 1: *as<T1>( to_value ) = std::move( *as<T1>( from_value ) );
break;
1118 case 2: *as<T2>( to_value ) = std::move( *as<T2>( from_value ) );
break;
1119 case 3: *as<T3>( to_value ) = std::move( *as<T3>( from_value ) );
break;
1120 case 4: *as<T4>( to_value ) = std::move( *as<T4>( from_value ) );
break;
1121 case 5: *as<T5>( to_value ) = std::move( *as<T5>( from_value ) );
break;
1122 case 6: *as<T6>( to_value ) = std::move( *as<T6>( from_value ) );
break;
1123 case 7: *as<T7>( to_value ) = std::move( *as<T7>( from_value ) );
break;
1124 case 8: *as<T8>( to_value ) = std::move( *as<T8>( from_value ) );
break;
1125 case 9: *as<T9>( to_value ) = std::move( *as<T9>( from_value ) );
break;
1126 case 10: *as<T10>( to_value ) = std::move( *as<T10>( from_value ) );
break;
1127 case 11: *as<T11>( to_value ) = std::move( *as<T11>( from_value ) );
break;
1128 case 12: *as<T12>( to_value ) = std::move( *as<T12>( from_value ) );
break;
1129 case 13: *as<T13>( to_value ) = std::move( *as<T13>( from_value ) );
break;
1130 case 14: *as<T14>( to_value ) = std::move( *as<T14>( from_value ) );
break;
1131 case 15: *as<T15>( to_value ) = std::move( *as<T15>( from_value ) );
break;
1140 switch ( from_index )
1142 case 0:
new( to_value )
T0( *as<T0>( from_value ) );
break;
1143 case 1:
new( to_value )
T1( *as<T1>( from_value ) );
break;
1144 case 2:
new( to_value )
T2( *as<T2>( from_value ) );
break;
1145 case 3:
new( to_value )
T3( *as<T3>( from_value ) );
break;
1146 case 4:
new( to_value )
T4( *as<T4>( from_value ) );
break;
1147 case 5:
new( to_value )
T5( *as<T5>( from_value ) );
break;
1148 case 6:
new( to_value )
T6( *as<T6>( from_value ) );
break;
1149 case 7:
new( to_value )
T7( *as<T7>( from_value ) );
break;
1150 case 8:
new( to_value )
T8( *as<T8>( from_value ) );
break;
1151 case 9:
new( to_value )
T9( *as<T9>( from_value ) );
break;
1152 case 10:
new( to_value )
T10( *as<T10>( from_value ) );
break;
1153 case 11:
new( to_value )
T11( *as<T11>( from_value ) );
break;
1154 case 12:
new( to_value )
T12( *as<T12>( from_value ) );
break;
1155 case 13:
new( to_value )
T13( *as<T13>( from_value ) );
break;
1156 case 14:
new( to_value )
T14( *as<T14>( from_value ) );
break;
1157 case 15:
new( to_value )
T15( *as<T15>( from_value ) );
break;
1165 switch ( from_index )
1167 case 0: *as<T0>( to_value ) = *as<T0>( from_value );
break;
1168 case 1: *as<T1>( to_value ) = *as<T1>( from_value );
break;
1169 case 2: *as<T2>( to_value ) = *as<T2>( from_value );
break;
1170 case 3: *as<T3>( to_value ) = *as<T3>( from_value );
break;
1171 case 4: *as<T4>( to_value ) = *as<T4>( from_value );
break;
1172 case 5: *as<T5>( to_value ) = *as<T5>( from_value );
break;
1173 case 6: *as<T6>( to_value ) = *as<T6>( from_value );
break;
1174 case 7: *as<T7>( to_value ) = *as<T7>( from_value );
break;
1175 case 8: *as<T8>( to_value ) = *as<T8>( from_value );
break;
1176 case 9: *as<T9>( to_value ) = *as<T9>( from_value );
break;
1177 case 10: *as<T10>( to_value ) = *as<T10>( from_value );
break;
1178 case 11: *as<T11>( to_value ) = *as<T11>( from_value );
break;
1179 case 12: *as<T12>( to_value ) = *as<T12>( from_value );
break;
1180 case 13: *as<T13>( to_value ) = *as<T13>( from_value );
break;
1181 case 14: *as<T14>( to_value ) = *as<T14>( from_value );
break;
1182 case 15: *as<T15>( to_value ) = *as<T15>( from_value );
break;
1195template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
1218template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
1219struct variant_size<
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >
1221 enum _ { value =
detail::typelist_size<
variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) >::value };
1224#if variant_CPP14_OR_GREATER
1229#if ! variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO
1230# define variant_size_V(T) nonstd::variant_size<T>::value
1235template< std::
size_t K,
class T >
1238template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
1239struct variant_alternative< K,
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >
1241 typedef typename detail::typelist_type_at<
variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), K>::type
type;
1244#if variant_CPP11_OR_GREATER
1245template< std::
size_t K,
class T >
1249#if ! variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO
1250# define variant_alternative_T(K,T) typename nonstd::variant_alternative<K,T >::type
1258#if variant_CPP11_OR_GREATER
1261static const std::size_t variant_npos =
static_cast<std::size_t
>( -1 );
1264#if ! variant_CONFIG_NO_EXCEPTIONS
1268class bad_variant_access :
public std::exception
1271#if variant_CPP11_OR_GREATER
1274 virtual const char* what()
const throw()
1277 return "bad variant access";
1305 typedef detail::helper< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > helper_type;
1306 typedef variant_TL16( T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ) variant_types;
1313#if variant_CPP11_OR_GREATER
1399#if variant_CPP11_OR_GREATER
1487#if variant_CPP11_OR_GREATER
1490 std::is_nothrow_move_constructible<T0>::value &&
1491 std::is_nothrow_move_constructible<T1>::value &&
1492 std::is_nothrow_move_constructible<T2>::value &&
1493 std::is_nothrow_move_constructible<T3>::value &&
1494 std::is_nothrow_move_constructible<T4>::value &&
1495 std::is_nothrow_move_constructible<T5>::value &&
1496 std::is_nothrow_move_constructible<T6>::value &&
1497 std::is_nothrow_move_constructible<T7>::value &&
1498 std::is_nothrow_move_constructible<T8>::value &&
1499 std::is_nothrow_move_constructible<T9>::value &&
1500 std::is_nothrow_move_constructible<T10>::value &&
1501 std::is_nothrow_move_constructible<T11>::value &&
1502 std::is_nothrow_move_constructible<T12>::value &&
1503 std::is_nothrow_move_constructible<T13>::value &&
1504 std::is_nothrow_move_constructible<T14>::value &&
1505 std::is_nothrow_move_constructible<T15>::value)
1508 (void) helper_type::move_construct( other.type_index, other.ptr(),
ptr() );
1511 template< std::
size_t K >
1512 using type_at_t =
typename detail::typelist_type_at< variant_types, K >::type;
1514 template<
class T,
class... Args
1515 variant_REQUIRES_T( std::is_constructible< T, Args...>::value )
1520 type_index = helper_type::template construct_t<T>(
ptr(), std::forward<Args>(args)... );
1523 template<
class T,
class U,
class... Args
1524 variant_REQUIRES_T( std::is_constructible< T, std::initializer_list<U>&, Args...>::value )
1529 type_index = helper_type::template construct_t<T>(
ptr(), il, std::forward<Args>(args)... );
1532 template< std::size_t K,
class... Args
1533 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, Args...>::value )
1538 type_index = helper_type::template construct_i<K>(
ptr(), std::forward<Args>(args)... );
1541 template<
size_t K,
class U,
class... Args
1542 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, std::initializer_list<U>&, Args...>::value )
1547 type_index = helper_type::template construct_i<K>(
ptr(), il, std::forward<Args>(args)... );
1569#if variant_CPP11_OR_GREATER
1572 std::is_nothrow_move_assignable<T0>::value &&
1573 std::is_nothrow_move_assignable<T1>::value &&
1574 std::is_nothrow_move_assignable<T2>::value &&
1575 std::is_nothrow_move_assignable<T3>::value &&
1576 std::is_nothrow_move_assignable<T4>::value &&
1577 std::is_nothrow_move_assignable<T5>::value &&
1578 std::is_nothrow_move_assignable<T6>::value &&
1579 std::is_nothrow_move_assignable<T7>::value &&
1580 std::is_nothrow_move_assignable<T8>::value &&
1581 std::is_nothrow_move_assignable<T9>::value &&
1582 std::is_nothrow_move_assignable<T10>::value &&
1583 std::is_nothrow_move_assignable<T11>::value &&
1584 std::is_nothrow_move_assignable<T12>::value &&
1585 std::is_nothrow_move_assignable<T13>::value &&
1586 std::is_nothrow_move_assignable<T14>::value &&
1587 std::is_nothrow_move_assignable<T15>::value)
1589 return move_assign( std::move( other ) );
1594 variant & operator=( T0 && t0 ) {
return assign_value<0>( std::move( t0 ) ); }
1598 variant & operator=( T1 && t1 ) {
return assign_value<1>( std::move( t1 ) ); }
1602 variant & operator=( T2 && t2 ) {
return assign_value<2>( std::move( t2 ) ); }
1606 variant & operator=( T3 && t3 ) {
return assign_value<3>( std::move( t3 ) ); }
1610 variant & operator=( T4 && t4 ) {
return assign_value<4>( std::move( t4 ) ); }
1614 variant & operator=( T5 && t5 ) {
return assign_value<5>( std::move( t5 ) ); }
1618 variant & operator=( T6 && t6 ) {
return assign_value<6>( std::move( t6 ) ); }
1622 variant & operator=( T7 && t7 ) {
return assign_value<7>( std::move( t7 ) ); }
1626 variant & operator=( T8 && t8 ) {
return assign_value<8>( std::move( t8 ) ); }
1630 variant & operator=( T9 && t9 ) {
return assign_value<9>( std::move( t9 ) ); }
1634 variant & operator=( T10 && t10 ) {
return assign_value<10>( std::move( t10 ) ); }
1638 variant & operator=( T11 && t11 ) {
return assign_value<11>( std::move( t11 ) ); }
1642 variant & operator=( T12 && t12 ) {
return assign_value<12>( std::move( t12 ) ); }
1646 variant & operator=( T13 && t13 ) {
return assign_value<13>( std::move( t13 ) ); }
1650 variant & operator=( T14 && t14 ) {
return assign_value<14>( std::move( t14 ) ); }
1654 variant & operator=( T15 && t15 ) {
return assign_value<15>( std::move( t15 ) ); }
1658#if variant_CPP11_OR_GREATER
1662 variant & operator=( T0
const & t0 ) {
return assign_value<0>( t0 ); }
1666 variant & operator=( T1
const & t1 ) {
return assign_value<1>( t1 ); }
1670 variant & operator=( T2
const & t2 ) {
return assign_value<2>( t2 ); }
1674 variant & operator=( T3
const & t3 ) {
return assign_value<3>( t3 ); }
1678 variant & operator=( T4
const & t4 ) {
return assign_value<4>( t4 ); }
1682 variant & operator=( T5
const & t5 ) {
return assign_value<5>( t5 ); }
1686 variant & operator=( T6
const & t6 ) {
return assign_value<6>( t6 ); }
1690 variant & operator=( T7
const & t7 ) {
return assign_value<7>( t7 ); }
1694 variant & operator=( T8
const & t8 ) {
return assign_value<8>( t8 ); }
1698 variant & operator=( T9
const & t9 ) {
return assign_value<9>( t9 ); }
1702 variant & operator=( T10
const & t10 ) {
return assign_value<10>( t10 ); }
1706 variant & operator=( T11
const & t11 ) {
return assign_value<11>( t11 ); }
1710 variant & operator=( T12
const & t12 ) {
return assign_value<12>( t12 ); }
1714 variant & operator=( T13
const & t13 ) {
return assign_value<13>( t13 ); }
1718 variant & operator=( T14
const & t14 ) {
return assign_value<14>( t14 ); }
1722 variant & operator=( T15
const & t15 ) {
return assign_value<15>( t15 ); }
1752#if variant_CPP11_OR_GREATER
1754 template<
class T,
class... Args
1755 variant_REQUIRES_T( std::is_constructible< T, Args...>::value )
1758 T& emplace( Args&&... args )
1762 type_index = helper_type::template construct_t<T>(
ptr(), std::forward<Args>(args)... );
1767 template<
class T,
class U,
class... Args
1768 variant_REQUIRES_T( std::is_constructible< T, std::initializer_list<U>&, Args...>::value )
1771 T& emplace( std::initializer_list<U> il, Args&&... args )
1775 type_index = helper_type::template construct_t<T>(
ptr(), il, std::forward<Args>(args)... );
1780 template<
size_t K,
class... Args
1781 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, Args...>::value )
1783 variant_alternative_t<K, variant> & emplace( Args&&... args )
1785 return this->
template emplace< type_at_t<K> >( std::forward<Args>(args)... );
1788 template<
size_t K,
class U,
class... Args
1789 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, std::initializer_list<U>&, Args...>::value )
1791 variant_alternative_t<K, variant> & emplace( std::initializer_list<U> il, Args&&... args )
1793 return this->
template emplace< type_at_t<K> >( il, std::forward<Args>(args)... );
1808#if variant_CPP11_OR_GREATER
1810 std::is_nothrow_move_constructible<T0>::value && std17::is_nothrow_swappable<T0>::value &&
1811 std::is_nothrow_move_constructible<T1>::value && std17::is_nothrow_swappable<T1>::value &&
1812 std::is_nothrow_move_constructible<T2>::value && std17::is_nothrow_swappable<T2>::value &&
1813 std::is_nothrow_move_constructible<T3>::value && std17::is_nothrow_swappable<T3>::value &&
1814 std::is_nothrow_move_constructible<T4>::value && std17::is_nothrow_swappable<T4>::value &&
1815 std::is_nothrow_move_constructible<T5>::value && std17::is_nothrow_swappable<T5>::value &&
1816 std::is_nothrow_move_constructible<T6>::value && std17::is_nothrow_swappable<T6>::value &&
1817 std::is_nothrow_move_constructible<T7>::value && std17::is_nothrow_swappable<T7>::value &&
1818 std::is_nothrow_move_constructible<T8>::value && std17::is_nothrow_swappable<T8>::value &&
1819 std::is_nothrow_move_constructible<T9>::value && std17::is_nothrow_swappable<T9>::value &&
1820 std::is_nothrow_move_constructible<T10>::value && std17::is_nothrow_swappable<T10>::value &&
1821 std::is_nothrow_move_constructible<T11>::value && std17::is_nothrow_swappable<T11>::value &&
1822 std::is_nothrow_move_constructible<T12>::value && std17::is_nothrow_swappable<T12>::value &&
1823 std::is_nothrow_move_constructible<T13>::value && std17::is_nothrow_swappable<T13>::value &&
1824 std::is_nothrow_move_constructible<T14>::value && std17::is_nothrow_swappable<T14>::value &&
1825 std::is_nothrow_move_constructible<T15>::value && std17::is_nothrow_swappable<T15>::value
1840#if variant_CPP11_OR_GREATER
1841 variant tmp( std::move( *
this ) );
1842 *
this = std::move( other );
1843 other = std::move( tmp );
1865#if variant_CONFIG_NO_EXCEPTIONS
1866 assert( index_of<T>() ==
index() );
1868 if ( index_of<T>() !=
index() )
1870 throw bad_variant_access();
1879#if variant_CONFIG_NO_EXCEPTIONS
1880 assert( index_of<T>() ==
index() );
1882 if ( index_of<T>() !=
index() )
1884 throw bad_variant_access();
1887 return *as<const T>();
1890 template< std::
size_t K >
1894 return this->
template get< typename detail::typelist_type_at< variant_types, K >::type >();
1897 template< std::
size_t K >
1901 return this->
template get< typename detail::typelist_type_at< variant_types, K >::type >();
1920 return reinterpret_cast<U*
>(
ptr() );
1926 return reinterpret_cast<U
const *
>(
ptr() );
1932 return static_cast<std::size_t
>(
index );
1964#if variant_CPP11_OR_GREATER
1990 template< std::
size_t K,
class T >
1995 *as<T>() = std::forward<T>( value );
2001 new(
ptr() ) T( std::forward<T>( value ) );
2009 template< std::
size_t K,
class T >
2020 new(
ptr() ) T( value );
2031 case 0:
swap( this->get<0>(), other.
get<0>() );
break;
2032 case 1:
swap( this->get<1>(), other.
get<1>() );
break;
2033 case 2:
swap( this->get<2>(), other.
get<2>() );
break;
2034 case 3:
swap( this->get<3>(), other.
get<3>() );
break;
2035 case 4:
swap( this->get<4>(), other.
get<4>() );
break;
2036 case 5:
swap( this->get<5>(), other.
get<5>() );
break;
2037 case 6:
swap( this->get<6>(), other.
get<6>() );
break;
2038 case 7:
swap( this->get<7>(), other.
get<7>() );
break;
2039 case 8:
swap( this->get<8>(), other.
get<8>() );
break;
2040 case 9:
swap( this->get<9>(), other.
get<9>() );
break;
2041 case 10:
swap( this->get<10>(), other.
get<10>() );
break;
2042 case 11:
swap( this->get<11>(), other.
get<11>() );
break;
2043 case 12:
swap( this->get<12>(), other.
get<12>() );
break;
2044 case 13:
swap( this->get<13>(), other.
get<13>() );
break;
2045 case 14:
swap( this->get<14>(), other.
get<14>() );
break;
2046 case 15:
swap( this->get<15>(), other.
get<15>() );
break;
2054#if variant_CPP11_OR_GREATER
2056 enum { data_align = detail::typelist_max_alignof< variant_types >::value };
2058 using aligned_storage_t =
typename std::aligned_storage< data_size, data_align >::type;
2059 aligned_storage_t
data;
2061#elif variant_CONFIG_MAX_ALIGN_HACK
2063 typedef union {
unsigned char data[
data_size ]; } aligned_storage_t;
2065 detail::max_align_t hack;
2066 aligned_storage_t
data;
2085template<
class T,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2086inline bool holds_alternative(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v )
variant_noexcept
2088 return v.index() ==
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::template index_of<T>();
2091template<
class R,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2092inline R & get(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & v,
nonstd_lite_in_place_type_t(R) =
nonstd_lite_in_place_type(R) )
2094 return v.template get<R>();
2097template<
class R,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2098inline R
const & get(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
nonstd_lite_in_place_type_t(R) =
nonstd_lite_in_place_type(R) )
2100 return v.template get<R>();
2103template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2104inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type &
2105get(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & v,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2107#if variant_CONFIG_NO_EXCEPTIONS
2108 assert( K == v.index() );
2110 if ( K != v.index() )
2112 throw bad_variant_access();
2115 return v.template get<K>();
2118template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2119inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type
const &
2120get(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2122#if variant_CONFIG_NO_EXCEPTIONS
2123 assert( K == v.index() );
2125 if ( K != v.index() )
2127 throw bad_variant_access();
2130 return v.template get<K>();
2133#if variant_CPP11_OR_GREATER
2135template<
class R,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2136inline R && get(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> && v,
nonstd_lite_in_place_type_t(R) =
nonstd_lite_in_place_type(R) )
2138 return std::move(v.template get<R>());
2141template<
class R,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2142inline R
const && get( variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
const && v,
nonstd_lite_in_place_type_t(R) =
nonstd_lite_in_place_type(R) )
2144 return std::move(v.template get<R>());
2147template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2148inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type &&
2149get( variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> && v,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2151#if variant_CONFIG_NO_EXCEPTIONS
2152 assert( K ==
v.index() );
2154 if ( K !=
v.index() )
2156 throw bad_variant_access();
2159 return std::move(
v.template get<K>());
2162template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2163inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type
const &&
2164get( variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
const && v,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2166#if variant_CONFIG_NO_EXCEPTIONS
2167 assert( K ==
v.index() );
2169 if ( K !=
v.index() )
2171 throw bad_variant_access();
2174 return std::move(
v.template get<K>());
2179template<
class T,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2181get_if(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> * pv,
nonstd_lite_in_place_type_t(T) =
nonstd_lite_in_place_type(T) )
2183 return ( pv->
index() ==
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::template index_of<T>() ) ? &get<T>( *pv ) :
variant_nullptr;
2186template<
class T,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2188get_if(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const * pv,
nonstd_lite_in_place_type_t(T) =
nonstd_lite_in_place_type(T))
2190 return ( pv->
index() ==
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::template index_of<T>() ) ? &get<T>( *pv ) :
variant_nullptr;
2193template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2194inline typename std11::add_pointer< typename variant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type >::type
2195get_if(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> * pv,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2200template< std::
size_t K,
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2201inline typename std11::add_pointer< const typename variant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type >::type
2202get_if(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const * pv,
nonstd_lite_in_place_index_t(K) =
nonstd_lite_in_place_index(K) )
2209template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15
2210#if variant_CPP11_OR_GREATER
2212 std::is_move_constructible<T0>::value && std17::is_swappable<T0>::value &&
2213 std::is_move_constructible<T1>::value && std17::is_swappable<T1>::value &&
2214 std::is_move_constructible<T2>::value && std17::is_swappable<T2>::value &&
2215 std::is_move_constructible<T3>::value && std17::is_swappable<T3>::value &&
2216 std::is_move_constructible<T4>::value && std17::is_swappable<T4>::value &&
2217 std::is_move_constructible<T5>::value && std17::is_swappable<T5>::value &&
2218 std::is_move_constructible<T6>::value && std17::is_swappable<T6>::value &&
2219 std::is_move_constructible<T7>::value && std17::is_swappable<T7>::value &&
2220 std::is_move_constructible<T8>::value && std17::is_swappable<T8>::value &&
2221 std::is_move_constructible<T9>::value && std17::is_swappable<T9>::value &&
2222 std::is_move_constructible<T10>::value && std17::is_swappable<T10>::value &&
2223 std::is_move_constructible<T11>::value && std17::is_swappable<T11>::value &&
2224 std::is_move_constructible<T12>::value && std17::is_swappable<T12>::value &&
2225 std::is_move_constructible<T13>::value && std17::is_swappable<T13>::value &&
2226 std::is_move_constructible<T14>::value && std17::is_swappable<T14>::value &&
2227 std::is_move_constructible<T15>::value && std17::is_swappable<T15>::value
2232 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & a,
2233 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & b )
2234#if variant_CPP11_OR_GREATER
2235 noexcept(
noexcept( a.
swap( b ) ) )
2248template<
typename R,
typename VT >
2251 template<
typename Visitor,
typename T >
2252 static R
apply(Visitor
const& v, T
const& arg)
2258template<
typename R,
typename VT >
2261 template<
typename Visitor,
typename T >
2270struct VisitorApplicator;
2272template<
typename R,
typename Visitor,
typename V1 >
2273struct VisitorUnwrapper;
2275#if variant_CPP11_OR_GREATER
2276template<
size_t NumVars,
typename R,
typename Visitor,
typename ... T >
2278template<
size_t NumVars,
typename R,
typename Visitor,
typename T1,
typename T2 = S0,
typename T3 = S0,
typename T4 = S0,
typename T5 = S0 >
2282template<
typename R,
typename Visitor,
typename T2 >
2295 template<
typename T>
2298 return visitor(val1, val2);
2302template<
typename R,
typename Visitor,
typename T2,
typename T3 >
2317 template<
typename T>
2320 return visitor(val1, val2, val3);
2324template<
typename R,
typename Visitor,
typename T2,
typename T3,
typename T4 >
2341 template<
typename T>
2344 return visitor(val1, val2, val3, val4);
2348template<
typename R,
typename Visitor,
typename T2,
typename T3,
typename T4,
typename T5 >
2367 template<
typename T>
2370 return visitor(val1, val2, val3, val4, val5);
2376template<
typename R,
typename Visitor,
typename V2>
2389 template<
typename T1 >
2396 template<
typename T1,
typename T2 >
2403 template<
typename T1,
typename T2,
typename T3 >
2410 template<
typename T1,
typename T2,
typename T3,
typename T4 >
2417 template<
typename T1,
typename T2,
typename T3,
typename T4,
typename T5 >
2430 template<
typename Visitor,
typename V1>
2431 static R
apply(
const Visitor& v,
const V1& arg)
2433 switch( arg.index() )
2435 case 0:
return apply_visitor<0>(v, arg);
2436 case 1:
return apply_visitor<1>(v, arg);
2437 case 2:
return apply_visitor<2>(v, arg);
2438 case 3:
return apply_visitor<3>(v, arg);
2439 case 4:
return apply_visitor<4>(v, arg);
2440 case 5:
return apply_visitor<5>(v, arg);
2441 case 6:
return apply_visitor<6>(v, arg);
2442 case 7:
return apply_visitor<7>(v, arg);
2443 case 8:
return apply_visitor<8>(v, arg);
2444 case 9:
return apply_visitor<9>(v, arg);
2445 case 10:
return apply_visitor<10>(v, arg);
2446 case 11:
return apply_visitor<11>(v, arg);
2447 case 12:
return apply_visitor<12>(v, arg);
2448 case 13:
return apply_visitor<13>(v, arg);
2449 case 14:
return apply_visitor<14>(v, arg);
2450 case 15:
return apply_visitor<15>(v, arg);
2453 default: std::terminate();
2457 template<
size_t Idx,
typename Visitor,
typename V1>
2461#if variant_CPP11_OR_GREATER
2469#if variant_CPP11_OR_GREATER
2470 template<
typename Visitor,
typename V1,
typename V2,
typename ... V>
2471 static R
apply(
const Visitor& v,
const V1& arg1,
const V2& arg2,
const V ... args)
2474 Unwrapper unwrapper(v, arg1);
2475 return apply(unwrapper, arg2, args ...);
2479 template<
typename Visitor,
typename V1,
typename V2 >
2480 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2)
2483 Unwrapper unwrapper(v, arg1);
2484 return apply(unwrapper, arg2);
2487 template<
typename Visitor,
typename V1,
typename V2,
typename V3 >
2488 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3)
2491 Unwrapper unwrapper(v, arg1);
2492 return apply(unwrapper, arg2, arg3);
2495 template<
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4 >
2496 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4)
2499 Unwrapper unwrapper(v, arg1);
2500 return apply(unwrapper, arg2, arg3, arg4);
2503 template<
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4,
typename V5 >
2504 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4, V5
const& arg5)
2507 Unwrapper unwrapper(v, arg1);
2508 return apply(unwrapper, arg2, arg3, arg4, arg5);
2514#if variant_CPP11_OR_GREATER
2515template<
size_t NumVars,
typename Visitor,
typename ... V >
2518 typedef decltype(std::declval<Visitor>()(get<0>(
static_cast<const V&
>(std::declval<V>()))...)) result_type;
2519 typedef VisitorApplicator<result_type> applicator_type;
2524#if variant_CPP11_OR_GREATER
2526template<
typename Visitor,
typename ... V >
2527inline auto visit(Visitor
const& v, V
const& ... vars) ->
typename detail::VisitorImpl<
sizeof ... (V), Visitor, V... > ::result_type
2529 typedef detail::VisitorImpl<sizeof ... (V), Visitor, V... > impl_type;
2530 return impl_type::applicator_type::apply(v, vars...);
2534template<
typename R,
typename Visitor,
typename V1 >
2535inline R
visit(
const Visitor& v, V1
const& arg1)
2540template<
typename R,
typename Visitor,
typename V1,
typename V2 >
2541inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2)
2546template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3 >
2547inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3)
2552template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4 >
2553inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4)
2558template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4,
typename V5 >
2559inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4, V5
const& arg5)
2570template<
class Variant >
2573 static inline bool equal( Variant
const & v, Variant
const & w )
2577 case 0:
return get<0>( v ) == get<0>( w );
2578 case 1:
return get<1>( v ) == get<1>( w );
2579 case 2:
return get<2>( v ) == get<2>( w );
2580 case 3:
return get<3>( v ) == get<3>( w );
2581 case 4:
return get<4>( v ) == get<4>( w );
2582 case 5:
return get<5>( v ) == get<5>( w );
2583 case 6:
return get<6>( v ) == get<6>( w );
2584 case 7:
return get<7>( v ) == get<7>( w );
2585 case 8:
return get<8>( v ) == get<8>( w );
2586 case 9:
return get<9>( v ) == get<9>( w );
2587 case 10:
return get<10>( v ) == get<10>( w );
2588 case 11:
return get<11>( v ) == get<11>( w );
2589 case 12:
return get<12>( v ) == get<12>( w );
2590 case 13:
return get<13>( v ) == get<13>( w );
2591 case 14:
return get<14>( v ) == get<14>( w );
2592 case 15:
return get<15>( v ) == get<15>( w );
2594 default:
return false;
2598 static inline bool less_than( Variant
const & v, Variant
const & w )
2602 case 0:
return get<0>( v ) < get<0>( w );
2603 case 1:
return get<1>( v ) < get<1>( w );
2604 case 2:
return get<2>( v ) < get<2>( w );
2605 case 3:
return get<3>( v ) < get<3>( w );
2606 case 4:
return get<4>( v ) < get<4>( w );
2607 case 5:
return get<5>( v ) < get<5>( w );
2608 case 6:
return get<6>( v ) < get<6>( w );
2609 case 7:
return get<7>( v ) < get<7>( w );
2610 case 8:
return get<8>( v ) < get<8>( w );
2611 case 9:
return get<9>( v ) < get<9>( w );
2612 case 10:
return get<10>( v ) < get<10>( w );
2613 case 11:
return get<11>( v ) < get<11>( w );
2614 case 12:
return get<12>( v ) < get<12>( w );
2615 case 13:
return get<13>( v ) < get<13>( w );
2616 case 14:
return get<14>( v ) < get<14>( w );
2617 case 15:
return get<15>( v ) < get<15>( w );
2619 default:
return false;
2626template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2627inline bool operator==(
2628 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2629 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2631 if ( v.index() != w.
index() )
return false;
2632 else if ( v.valueless_by_exception() )
return true;
2633 else return detail::Comparator< variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::equal( v, w );
2636template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2637inline bool operator!=(
2638 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2639 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2641 return ! ( v == w );
2644template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2645inline bool operator<(
2646 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2647 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2650 else if ( v.valueless_by_exception() )
return true;
2651 else if ( v.index() < w.
index() )
return true;
2652 else if ( v.index() > w.
index() )
return false;
2653 else return detail::Comparator< variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::less_than( v, w );
2656template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2657inline bool operator>(
2658 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2659 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2664template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2665inline bool operator<=(
2666 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2667 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2672template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2673inline bool operator>=(
2674 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2675 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2682using namespace variants;
2686#if variant_CPP11_OR_GREATER
2693struct hash<
nonstd::monostate >
2701template<
class T0,
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10,
class T11,
class T12,
class T13,
class T14,
class T15 >
2702struct hash<
nonstd::variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >
2704 std::size_t operator()(
nonstd::variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v )
const variant_noexcept
2710 case 0:
return nvd::hash( 0 ) ^ nvd::hash( get<0>( v ) );
2711 case 1:
return nvd::hash( 1 ) ^ nvd::hash( get<1>( v ) );
2712 case 2:
return nvd::hash( 2 ) ^ nvd::hash( get<2>( v ) );
2713 case 3:
return nvd::hash( 3 ) ^ nvd::hash( get<3>( v ) );
2714 case 4:
return nvd::hash( 4 ) ^ nvd::hash( get<4>( v ) );
2715 case 5:
return nvd::hash( 5 ) ^ nvd::hash( get<5>( v ) );
2716 case 6:
return nvd::hash( 6 ) ^ nvd::hash( get<6>( v ) );
2717 case 7:
return nvd::hash( 7 ) ^ nvd::hash( get<7>( v ) );
2718 case 8:
return nvd::hash( 8 ) ^ nvd::hash( get<8>( v ) );
2719 case 9:
return nvd::hash( 9 ) ^ nvd::hash( get<9>( v ) );
2720 case 10:
return nvd::hash( 10 ) ^ nvd::hash( get<10>( v ) );
2721 case 11:
return nvd::hash( 11 ) ^ nvd::hash( get<11>( v ) );
2722 case 12:
return nvd::hash( 12 ) ^ nvd::hash( get<12>( v ) );
2723 case 13:
return nvd::hash( 13 ) ^ nvd::hash( get<13>( v ) );
2724 case 14:
return nvd::hash( 14 ) ^ nvd::hash( get<14>( v ) );
2725 case 15:
return nvd::hash( 15 ) ^ nvd::hash( get<15>( v ) );
2736#if variant_BETWEEN( variant_COMPILER_MSVC_VER, 1300, 1900 )
2737# pragma warning( pop )
variant & operator=(T14 const &t14)
variant & copy_assign(variant const &other)
static variant_constexpr std::size_t to_size_t(U index)
variant & operator=(T11 const &t11)
variant_alternative< K, variant >::type & get()
variant & operator=(T3 const &t3)
void swap(variant &other)
variant & operator=(T10 const &t10)
variant & operator=(T13 const &t13)
variant & operator=(T9 const &t9)
variant & operator=(T0 const &t0)
variant & assign_value(T const &value)
void * ptr() variant_noexcept
helper_type::type_index_t type_index_t
detail::helper< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > helper_type
typedef variant_ALIGN_AS(max_type) align_as_type
variant & operator=(T1 const &t1)
void swap_value(type_index_t index, variant &other)
static variant_constexpr std::size_t index_of() variant_noexcept
variant & operator=(T8 const &t8)
void const * ptr() const variant_noexcept
variant & operator=(variant const &other)
variant & operator=(T4 const &t4)
variant & operator=(T15 const &t15)
variant(variant const &other)
variant & operator=(T2 const &t2)
std::size_t index() const
variant_constexpr type_index_t variant_npos_internal() const variant_noexcept
variant & operator=(T6 const &t6)
variant_alternative< K, variant >::type const & get() const
typedef variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) variant_types
variant & operator=(T5 const &t5)
variant & operator=(T7 const &t7)
detail::typelist_max< variant_types >::type max_type
bool valueless_by_exception() const
variant & operator=(T12 const &t12)
void index_tag(index_tag_t< K >=index_tag_t< K >())
void swap(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > &a, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > &b)
std11::add_pointer< T >::type get_if(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > *pv, nonstd_lite_in_place_type_t(T)=nonstd_lite_in_place_type(T))
R visit(const Visitor &v, V1 const &arg1)
bool holds_alternative(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v) variant_noexcept
in_place_t in_place_type(detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())
in_place_t in_place_index(detail::in_place_index_tag< K >=detail::in_place_index_tag< K >())
in_place_t in_place(detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())
Value_Type get(const router::route_params_t ¶ms, string_view_t key)
Cast named parameter value to a given type.
static bool less_than(Variant const &v, Variant const &w)
static bool equal(Variant const &v, Variant const &w)
bool operator==(T const &) const
TX< T > operator^(U const &) const
TX< T > operator&&(U const &) const
TX< T > operator%(U const &) const
TX< T > * operator&() const
TX< T > operator+() const
TX< T > operator-() const
TX< T > operator!() const
TX< T > operator*(U const &) const
TX< T > operator|(U const &) const
TX< T > operator/(U const &) const
TX< T > operator~() const
TX< T > operator||(U const &) const
TX< T > operator>>(U const &) const
R operator()(const T &val1) const
TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_)
TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_)
R operator()(const T &val1) const
R operator()(const T &val1) const
TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_, T4 const &val4_)
TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_, T4 const &val4_, T5 const &val5_)
R operator()(const T &val1) const
static R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4)
static R apply(const Visitor &v, V1 const &arg1, V2 const &arg2)
static R apply(const Visitor &v, const V1 &arg)
static R apply_visitor(const Visitor &v, const V1 &arg)
static R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4, V5 const &arg5)
static R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3)
static R apply(Visitor const &, T)
static R apply(Visitor const &v, T const &arg)
R operator()(T1 const &val1, T2 const &val2, T3 const &val3, T4 const &val4, T5 const &val5) const
R operator()(T1 const &val1) const
R operator()(T1 const &val1, T2 const &val2, T3 const &val3) const
R operator()(T1 const &val1, T2 const &val2) const
R operator()(T1 const &val1, T2 const &val2, T3 const &val3, T4 const &val4) const
VisitorUnwrapper(const Visitor &visitor_, const V2 &r_)
static type_index_t copy_assign(type_index_t const from_index, const void *from_value, void *to_value)
static void destroy(type_index_t index, void *data)
typedef variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) variant_types
static U * as(void *data)
static type_index_t copy_construct(type_index_t const from_index, const void *from_value, void *to_value)
static type_index_t to_index_t(std::size_t index)
static U const * as(void const *data)
variant_CONFIG_ALIGN_AS_FALLBACK type
std11::conditional< N==sizeof(typenameList::head), typenameList::head, typenametype_of_size< typenameList::tail, N >::type >::type type
typelist_max< Tail >::type tail_type
std11::conditional<(sizeof(Head)>tail_value), Head, tail_type >::type type
typelist_type_at< Tail, i-1 >::type type
typelist_type_at< List, LastChecked-1 >::type cur_type
typelist_type_at< List, CmpIndex >::type cmp_type
remove_reference< T >::type * type
remove_volatile< typenameremove_const< T >::type >::type type
nonstd::variants::variant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::type detail::typelist_type_at< variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), K >::type type
nonstd::variants::variant_size< variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::_ _
#define nonstd_lite_in_place_type(T)
#define nonstd_lite_in_place_index_t(K)
#define nonstd_lite_in_place_type_t(T)
#define nonstd_lite_in_place_index(K)
#define variant_index_tag(K)
#define variant_CONFIG_ALIGN_AS_FALLBACK
#define variant_TL16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
#define variant_ALIGN_TYPE(type)
#define variant_REQUIRES_B(...)
#define variant_index_tag_t(K)
#define variant_constexpr