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
53# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
54# define variant_CONFIG_NO_EXCEPTIONS 0
56# define variant_CONFIG_NO_EXCEPTIONS 1
63#ifndef variant_CPLUSPLUS
64# if defined(_MSVC_LANG ) && !defined(__clang__)
65# define variant_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
67# define variant_CPLUSPLUS __cplusplus
71#define variant_CPP98_OR_GREATER ( variant_CPLUSPLUS >= 199711L )
72#define variant_CPP11_OR_GREATER ( variant_CPLUSPLUS >= 201103L )
73#define variant_CPP11_OR_GREATER_ ( variant_CPLUSPLUS >= 201103L )
74#define variant_CPP14_OR_GREATER ( variant_CPLUSPLUS >= 201402L )
75#define variant_CPP17_OR_GREATER ( variant_CPLUSPLUS >= 201703L )
76#define variant_CPP20_OR_GREATER ( variant_CPLUSPLUS >= 202000L )
80#if variant_CPP17_OR_GREATER && defined(__has_include )
81# if __has_include( <variant> )
82# define variant_HAVE_STD_VARIANT 1
84# define variant_HAVE_STD_VARIANT 0
87# define variant_HAVE_STD_VARIANT 0
90#if !defined( variant_CONFIG_SELECT_VARIANT )
91# define variant_CONFIG_SELECT_VARIANT ( variant_HAVE_STD_VARIANT ? variant_VARIANT_STD : variant_VARIANT_NONSTD )
94#define variant_USES_STD_VARIANT ( (variant_CONFIG_SELECT_VARIANT == variant_VARIANT_STD) || ((variant_CONFIG_SELECT_VARIANT == variant_VARIANT_DEFAULT) && variant_HAVE_STD_VARIANT) )
100#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
101#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
105#if variant_CPP17_OR_GREATER
114using std::in_place_t;
115using std::in_place_type_t;
116using std::in_place_index_t;
118#define nonstd_lite_in_place_t( T) std::in_place_t
119#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
120#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
122#define nonstd_lite_in_place( T) std::in_place_t{}
123#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
124#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
136struct in_place_type_tag {};
138template< std::
size_t K >
139struct in_place_index_tag {};
146inline in_place_t
in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
151template< std::
size_t K >
152inline in_place_t
in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
158inline in_place_t
in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
163template< std::
size_t K >
164inline in_place_t
in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
171#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
172#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
173#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
175#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
176#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
177#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
190template< std::
size_t K >
193template< std::
size_t K >
196#define variant_index_tag_t(K) void(&)( nonstd::variants::detail::index_tag_t<K> )
197#define variant_index_tag(K) nonstd::variants::detail::index_tag<K>
207#if variant_USES_STD_VARIANT
212#if ! variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO
213# define variant_size_V(T) nonstd::variant_size<T>::value
216#if ! variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO
217# define variant_alternative_T(K,T) typename nonstd::variant_alternative<K,T >::type
223 using std::monostate;
224 using std::bad_variant_access;
225 using std::variant_size;
226 using std::variant_size_v;
227 using std::variant_alternative;
228 using std::variant_alternative_t;
235 using std::operator==;
236 using std::operator!=;
237 using std::operator<;
238 using std::operator<=;
239 using std::operator>;
240 using std::operator>=;
243 constexpr auto variant_npos = std::variant_npos;
253#if variant_CONFIG_NO_EXCEPTIONS
261#define variant_CONFIG_MAX_TYPE_COUNT 16
262#define variant_CONFIG_MAX_VISITOR_ARG_COUNT 5
266#ifndef variant_CONFIG_MAX_ALIGN_HACK
267# define variant_CONFIG_MAX_ALIGN_HACK 0
270#ifndef variant_CONFIG_ALIGN_AS
274#ifndef variant_CONFIG_ALIGN_AS_FALLBACK
275# define variant_CONFIG_ALIGN_AS_FALLBACK double
279#define variant_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
295#if defined(_MSC_VER ) && !defined(__clang__)
296# define variant_COMPILER_MSVC_VER (_MSC_VER )
297# define variant_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
299# define variant_COMPILER_MSVC_VER 0
300# define variant_COMPILER_MSVC_VERSION 0
303#define variant_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
305#if defined(__clang__)
306# define variant_COMPILER_CLANG_VERSION variant_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
308# define variant_COMPILER_CLANG_VERSION 0
311#if defined(__GNUC__) && !defined(__clang__)
312# define variant_COMPILER_GNUC_VERSION variant_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
314# define variant_COMPILER_GNUC_VERSION 0
317#if variant_BETWEEN( variant_COMPILER_MSVC_VER, 1300, 1900 )
318# pragma warning( push )
319# pragma warning( disable: 4345 )
324#define variant_HAVE( feature ) ( variant_HAVE_##feature )
327# define variant_HAS_CPP0X _HAS_CPP0X
329# define variant_HAS_CPP0X 0
334#if variant_COMPILER_MSVC_VER >= 1900
335# undef variant_CPP11_OR_GREATER
336# define variant_CPP11_OR_GREATER 1
339#define variant_CPP11_90 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1500)
340#define variant_CPP11_100 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1600)
341#define variant_CPP11_110 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1700)
342#define variant_CPP11_120 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1800)
343#define variant_CPP11_140 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1900)
344#define variant_CPP11_141 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1910)
346#define variant_CPP14_000 (variant_CPP14_OR_GREATER)
347#define variant_CPP17_000 (variant_CPP17_OR_GREATER)
351#define variant_HAVE_CONSTEXPR_11 variant_CPP11_140
352#define variant_HAVE_INITIALIZER_LIST variant_CPP11_120
353#define variant_HAVE_NOEXCEPT variant_CPP11_140
354#define variant_HAVE_NULLPTR variant_CPP11_100
355#define variant_HAVE_OVERRIDE variant_CPP11_140
359#define variant_HAVE_CONSTEXPR_14 variant_CPP14_000
367#define variant_HAVE_CONDITIONAL variant_CPP11_120
368#define variant_HAVE_REMOVE_CV variant_CPP11_120
369#define variant_HAVE_STD_ADD_POINTER variant_CPP11_90
370#define variant_HAVE_TYPE_TRAITS variant_CPP11_90
371#define variant_HAVE_ENABLE_IF variant_CPP11_90
372#define variant_HAVE_IS_SAME variant_CPP11_90
374#define variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )
375#define variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION )
379#if variant_HAVE_CONSTEXPR_11
380# define variant_constexpr constexpr
382# define variant_constexpr
385#if variant_HAVE_CONSTEXPR_14
386# define variant_constexpr14 constexpr
388# define variant_constexpr14
391#if variant_HAVE_NOEXCEPT
392# define variant_noexcept noexcept
394# define variant_noexcept
397#if variant_HAVE_NULLPTR
398# define variant_nullptr nullptr
400# define variant_nullptr NULL
403#if variant_HAVE_OVERRIDE
404# define variant_override override
406# define variant_override
411#if variant_CPP11_OR_GREATER
412# include <functional>
415#if variant_HAVE_INITIALIZER_LIST
416# include <initializer_list>
419#if variant_HAVE_TYPE_TRAITS
420# include <type_traits>
421#elif variant_HAVE_TR1_TYPE_TRAITS
422# include <tr1/type_traits>
429namespace nonstd {
namespace variants {
435#if variant_HAVE_STD_ADD_POINTER
437using std::add_pointer;
439#elif variant_HAVE_TR1_ADD_POINTER
441using std::tr1::add_pointer;
455#if variant_HAVE_REMOVE_CV
475#if variant_HAVE_CONDITIONAL
477using std::conditional;
481template<
bool Cond,
class Then,
class Else >
484template<
class Then,
class Else >
487template<
class Then,
class Else >
492#if variant_HAVE_ENABLE_IF
498template<
bool B,
class T =
void >
506#if variant_HAVE_IS_SAME
512template<
class T,
class U >
528#if variant_CPP11_OR_GREATER
530#define variant_REQUIRES_T(...) \
531 , typename std::enable_if< (__VA_ARGS__), int >::type = 0
533#define variant_REQUIRES_R(R, ...) \
534 typename std::enable_if< (__VA_ARGS__), R>::type
536#define variant_REQUIRES_A(...) \
537 , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
541#define variant_REQUIRES_0(...) \
542 template< bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0 >
544#define variant_REQUIRES_B(...) \
545 , bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0
551#if variant_CPP17_OR_GREATER
553using std::is_swappable;
554using std::is_nothrow_swappable;
556#elif variant_CPP11_OR_GREATER
564 template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
571struct is_nothrow_swappable
575 template<
typename T >
576 static constexpr bool test()
578 return noexcept(
swap( std::declval<T&>(), std::declval<T&>() ) );
581 template<
typename T >
582 static auto test(
int ) -> std::integral_constant<bool, test<T>()>{}
592template<
typename T >
593struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
595template<
typename T >
596struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
608#define variant_TL1( T1 ) detail::typelist< T1, detail::nulltype >
609#define variant_TL2( T1, T2) detail::typelist< T1, variant_TL1( T2) >
610#define variant_TL3( T1, T2, T3) detail::typelist< T1, variant_TL2( T2, T3) >
611#define variant_TL4( T1, T2, T3, T4) detail::typelist< T1, variant_TL3( T2, T3, T4) >
612#define variant_TL5( T1, T2, T3, T4, T5) detail::typelist< T1, variant_TL4( T2, T3, T4, T5) >
613#define variant_TL6( T1, T2, T3, T4, T5, T6) detail::typelist< T1, variant_TL5( T2, T3, T4, T5, T6) >
614#define variant_TL7( T1, T2, T3, T4, T5, T6, T7) detail::typelist< T1, variant_TL6( T2, T3, T4, T5, T6, T7) >
615#define variant_TL8( T1, T2, T3, T4, T5, T6, T7, T8) detail::typelist< T1, variant_TL7( T2, T3, T4, T5, T6, T7, T8) >
616#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) >
617#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) >
618#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) >
619#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) >
620#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) >
621#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) >
622#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) >
623#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) >
650 inline bool operator< ( T
const & )
const {
return false; }
680template<
class Head,
class Tail >
689template<
class List >
695 enum V { value = 0 } ;
699template<
class Head,
class Tail >
708 enum V { value = (
sizeof( Head ) > tail_value) ?
sizeof( Head ) : std::size_t( tail_value ) } ;
713#if variant_CPP11_OR_GREATER
717template<
class List >
718struct typelist_max_alignof;
721struct typelist_max_alignof<
nulltype >
723 enum V { value = 0 } ;
726template<
class Head,
class Tail >
727struct typelist_max_alignof< typelist<Head, Tail> >
730 enum TV { tail_value = size_t( typelist_max_alignof<Tail>::value ) };
733 enum V { value = (
alignof( Head ) > tail_value) ?
alignof( Head ) : std::size_t( tail_value ) };
740template<
class List >
766template<
class Head,
class Tail >
774template<
class List,
class T >
780 enum V { value = -1 };
783template<
class Tail,
class T >
786 enum V { value = 0 };
789template<
class Head,
class Tail,
class T >
796 enum V { value = nextVal == -1 ? -1 : 1 + nextVal } ;
801template<
class List, std::
size_t i>
804template<
class Head,
class Tail >
810template<
class Head,
class Tail, std::
size_t i >
818template< class List, std::size_t CmpIndex, std::size_t LastChecked = typelist_size<List>::value >
830template<
class List, std::
size_t CmpIndex >
836template<
class List,
class T >
841#if variant_CONFIG_MAX_ALIGN_HACK
845#define variant_UNIQUE( name ) variant_UNIQUE2( name, __LINE__ )
846#define variant_UNIQUE2( name, line ) variant_UNIQUE3( name, line )
847#define variant_UNIQUE3( name, line ) name ## line
849#define variant_ALIGN_TYPE( type ) \
850 type variant_UNIQUE( _t ); struct_t< type > variant_UNIQUE( _st )
879 Unknown ( * variant_UNIQUE(_) )( Unknown );
880 Unknown * Unknown::* variant_UNIQUE(_);
881 Unknown ( Unknown::* variant_UNIQUE(_) )( Unknown );
883 struct_t< Unknown ( * )( Unknown) > variant_UNIQUE(_);
884 struct_t< Unknown * Unknown::* > variant_UNIQUE(_);
885 struct_t< Unknown ( Unknown::* )(Unknown) > variant_UNIQUE(_);
889#undef variant_UNIQUE2
890#undef variant_UNIQUE3
892#undef variant_ALIGN_TYPE
894#elif defined( variant_CONFIG_ALIGN_AS )
898#define variant_ALIGN_AS( unused ) \
899 variant_CONFIG_ALIGN_AS
905#define variant_ALIGN_AS( to_align ) \
906 typename detail::type_of_size< detail::alignment_types, detail::alignment_of< to_align >::value >::type
908template<
typename T >
911template<
typename T >
919template<
size_t A,
size_t S >
922 enum V { value = A < S ? A : S };
925template<
typename T >
932template<
typename List,
size_t N >
936 N ==
sizeof(
typename List::head ),
950#define variant_ALIGN_TYPE( type ) \
951 typelist< type , typelist< struct_t< type >
977 > > > > > > > > > > > > > >
978 > > > > > > > > > > > > > >
982#undef variant_ALIGN_TYPE
986#if variant_CPP11_OR_GREATER
989inline std::size_t hash( T
const & v )
991 return std::hash<T>()( v );
994inline std::size_t hash(
T0 const & ) {
return 0; }
995inline std::size_t hash(
T1 const & ) {
return 0; }
996inline std::size_t hash(
T2 const & ) {
return 0; }
997inline std::size_t hash(
T3 const & ) {
return 0; }
998inline std::size_t hash(
T4 const & ) {
return 0; }
999inline std::size_t hash(
T5 const & ) {
return 0; }
1000inline std::size_t hash(
T6 const & ) {
return 0; }
1001inline std::size_t hash(
T7 const & ) {
return 0; }
1002inline std::size_t hash(
T8 const & ) {
return 0; }
1003inline std::size_t hash(
T9 const & ) {
return 0; }
1004inline std::size_t hash(
T10 const & ) {
return 0; }
1005inline std::size_t hash(
T11 const & ) {
return 0; }
1006inline std::size_t hash(
T12 const & ) {
return 0; }
1007inline std::size_t hash(
T13 const & ) {
return 0; }
1008inline std::size_t hash(
T14 const & ) {
return 0; }
1009inline std::size_t hash(
T15 const & ) {
return 0; }
1018template<
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 >
1022 typedef variant_TL16(
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15 ) variant_types;
1025 static U *
as(
void * data )
1027 return reinterpret_cast<U*
>( data );
1031 static U
const *
as(
void const * data )
1033 return reinterpret_cast<const U*
>( data );
1045 case 0: as<T0>( data )->~T0();
break;
1046 case 1: as<T1>( data )->~T1();
break;
1047 case 2: as<T2>( data )->~T2();
break;
1048 case 3: as<T3>( data )->~T3();
break;
1049 case 4: as<T4>( data )->~T4();
break;
1050 case 5: as<T5>( data )->~T5();
break;
1051 case 6: as<T6>( data )->~T6();
break;
1052 case 7: as<T7>( data )->~T7();
break;
1053 case 8: as<T8>( data )->~T8();
break;
1054 case 9: as<T9>( data )->~T9();
break;
1055 case 10: as<T10>( data )->~T10();
break;
1056 case 11: as<T11>( data )->~T11();
break;
1057 case 12: as<T12>( data )->~T12();
break;
1058 case 13: as<T13>( data )->~T13();
break;
1059 case 14: as<T14>( data )->~T14();
break;
1060 case 15: as<T15>( data )->~T15();
break;
1065#if variant_CPP11_OR_GREATER
1066 template<
class T,
class... Args >
1067 static type_index_t construct_t(
void * data, Args&&... args )
1069 new( data ) T( std::forward<Args>(args)... );
1074 template< std::size_t K,
class... Args >
1075 static type_index_t construct_i(
void * data, Args&&... args )
1079 construct_t< type >( data, std::forward<Args>(args)... );
1086 switch ( from_index )
1088 case 0:
new( to_value )
T0(
std::move( *as<T0>( from_value ) ) );
break;
1089 case 1:
new( to_value )
T1(
std::move( *as<T1>( from_value ) ) );
break;
1090 case 2:
new( to_value )
T2(
std::move( *as<T2>( from_value ) ) );
break;
1091 case 3:
new( to_value )
T3(
std::move( *as<T3>( from_value ) ) );
break;
1092 case 4:
new( to_value )
T4(
std::move( *as<T4>( from_value ) ) );
break;
1093 case 5:
new( to_value )
T5(
std::move( *as<T5>( from_value ) ) );
break;
1094 case 6:
new( to_value )
T6(
std::move( *as<T6>( from_value ) ) );
break;
1095 case 7:
new( to_value )
T7(
std::move( *as<T7>( from_value ) ) );
break;
1096 case 8:
new( to_value )
T8(
std::move( *as<T8>( from_value ) ) );
break;
1097 case 9:
new( to_value )
T9(
std::move( *as<T9>( from_value ) ) );
break;
1098 case 10:
new( to_value )
T10(
std::move( *as<T10>( from_value ) ) );
break;
1099 case 11:
new( to_value )
T11(
std::move( *as<T11>( from_value ) ) );
break;
1100 case 12:
new( to_value )
T12(
std::move( *as<T12>( from_value ) ) );
break;
1101 case 13:
new( to_value )
T13(
std::move( *as<T13>( from_value ) ) );
break;
1102 case 14:
new( to_value )
T14(
std::move( *as<T14>( from_value ) ) );
break;
1103 case 15:
new( to_value )
T15(
std::move( *as<T15>( from_value ) ) );
break;
1111 switch ( from_index )
1113 case 0: *as<T0>( to_value ) =
std::move( *as<T0>( from_value ) );
break;
1114 case 1: *as<T1>( to_value ) =
std::move( *as<T1>( from_value ) );
break;
1115 case 2: *as<T2>( to_value ) =
std::move( *as<T2>( from_value ) );
break;
1116 case 3: *as<T3>( to_value ) =
std::move( *as<T3>( from_value ) );
break;
1117 case 4: *as<T4>( to_value ) =
std::move( *as<T4>( from_value ) );
break;
1118 case 5: *as<T5>( to_value ) =
std::move( *as<T5>( from_value ) );
break;
1119 case 6: *as<T6>( to_value ) =
std::move( *as<T6>( from_value ) );
break;
1120 case 7: *as<T7>( to_value ) =
std::move( *as<T7>( from_value ) );
break;
1121 case 8: *as<T8>( to_value ) =
std::move( *as<T8>( from_value ) );
break;
1122 case 9: *as<T9>( to_value ) =
std::move( *as<T9>( from_value ) );
break;
1123 case 10: *as<T10>( to_value ) =
std::move( *as<T10>( from_value ) );
break;
1124 case 11: *as<T11>( to_value ) =
std::move( *as<T11>( from_value ) );
break;
1125 case 12: *as<T12>( to_value ) =
std::move( *as<T12>( from_value ) );
break;
1126 case 13: *as<T13>( to_value ) =
std::move( *as<T13>( from_value ) );
break;
1127 case 14: *as<T14>( to_value ) =
std::move( *as<T14>( from_value ) );
break;
1128 case 15: *as<T15>( to_value ) =
std::move( *as<T15>( from_value ) );
break;
1137 switch ( from_index )
1139 case 0:
new( to_value )
T0( *as<T0>( from_value ) );
break;
1140 case 1:
new( to_value )
T1( *as<T1>( from_value ) );
break;
1141 case 2:
new( to_value )
T2( *as<T2>( from_value ) );
break;
1142 case 3:
new( to_value )
T3( *as<T3>( from_value ) );
break;
1143 case 4:
new( to_value )
T4( *as<T4>( from_value ) );
break;
1144 case 5:
new( to_value )
T5( *as<T5>( from_value ) );
break;
1145 case 6:
new( to_value )
T6( *as<T6>( from_value ) );
break;
1146 case 7:
new( to_value )
T7( *as<T7>( from_value ) );
break;
1147 case 8:
new( to_value )
T8( *as<T8>( from_value ) );
break;
1148 case 9:
new( to_value )
T9( *as<T9>( from_value ) );
break;
1149 case 10:
new( to_value )
T10( *as<T10>( from_value ) );
break;
1150 case 11:
new( to_value )
T11( *as<T11>( from_value ) );
break;
1151 case 12:
new( to_value )
T12( *as<T12>( from_value ) );
break;
1152 case 13:
new( to_value )
T13( *as<T13>( from_value ) );
break;
1153 case 14:
new( to_value )
T14( *as<T14>( from_value ) );
break;
1154 case 15:
new( to_value )
T15( *as<T15>( from_value ) );
break;
1162 switch ( from_index )
1164 case 0: *as<T0>( to_value ) = *as<T0>( from_value );
break;
1165 case 1: *as<T1>( to_value ) = *as<T1>( from_value );
break;
1166 case 2: *as<T2>( to_value ) = *as<T2>( from_value );
break;
1167 case 3: *as<T3>( to_value ) = *as<T3>( from_value );
break;
1168 case 4: *as<T4>( to_value ) = *as<T4>( from_value );
break;
1169 case 5: *as<T5>( to_value ) = *as<T5>( from_value );
break;
1170 case 6: *as<T6>( to_value ) = *as<T6>( from_value );
break;
1171 case 7: *as<T7>( to_value ) = *as<T7>( from_value );
break;
1172 case 8: *as<T8>( to_value ) = *as<T8>( from_value );
break;
1173 case 9: *as<T9>( to_value ) = *as<T9>( from_value );
break;
1174 case 10: *as<T10>( to_value ) = *as<T10>( from_value );
break;
1175 case 11: *as<T11>( to_value ) = *as<T11>( from_value );
break;
1176 case 12: *as<T12>( to_value ) = *as<T12>( from_value );
break;
1177 case 13: *as<T13>( to_value ) = *as<T13>( from_value );
break;
1178 case 14: *as<T14>( to_value ) = *as<T14>( from_value );
break;
1179 case 15: *as<T15>( to_value ) = *as<T15>( from_value );
break;
1192template<
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 >
1215template<
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 >
1216struct variant_size<
variant<
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15> >
1218 enum _ { value =
detail::typelist_size<
variant_TL16(
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15) >::value };
1221#if variant_CPP14_OR_GREATER
1226#if ! variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO
1227# define variant_size_V(T) nonstd::variant_size<T>::value
1232template< std::
size_t K,
class T >
1235template< 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 >
1236struct variant_alternative< K,
variant<
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15> >
1238 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;
1241#if variant_CPP11_OR_GREATER
1242template< std::
size_t K,
class T >
1246#if ! variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO
1247# define variant_alternative_T(K,T) typename nonstd::variant_alternative<K,T >::type
1255#if variant_CPP11_OR_GREATER
1258static const std::size_t variant_npos =
static_cast<std::size_t
>( -1 );
1261#if ! variant_CONFIG_NO_EXCEPTIONS
1265class bad_variant_access :
public std::exception
1268#if variant_CPP11_OR_GREATER
1271 virtual const char* what()
const throw()
1274 return "bad variant access";
1302 typedef detail::helper< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > helper_type;
1303 typedef variant_TL16(
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15 ) variant_types;
1310#if variant_CPP11_OR_GREATER
1396#if variant_CPP11_OR_GREATER
1484#if variant_CPP11_OR_GREATER
1487 std::is_nothrow_move_constructible<T0>::value &&
1488 std::is_nothrow_move_constructible<T1>::value &&
1489 std::is_nothrow_move_constructible<T2>::value &&
1490 std::is_nothrow_move_constructible<T3>::value &&
1491 std::is_nothrow_move_constructible<T4>::value &&
1492 std::is_nothrow_move_constructible<T5>::value &&
1493 std::is_nothrow_move_constructible<T6>::value &&
1494 std::is_nothrow_move_constructible<T7>::value &&
1495 std::is_nothrow_move_constructible<T8>::value &&
1496 std::is_nothrow_move_constructible<T9>::value &&
1497 std::is_nothrow_move_constructible<T10>::value &&
1498 std::is_nothrow_move_constructible<T11>::value &&
1499 std::is_nothrow_move_constructible<T12>::value &&
1500 std::is_nothrow_move_constructible<T13>::value &&
1501 std::is_nothrow_move_constructible<T14>::value &&
1502 std::is_nothrow_move_constructible<T15>::value)
1505 (void) helper_type::move_construct( other.type_index, other.ptr(),
ptr() );
1508 template< std::
size_t K >
1509 using type_at_t =
typename detail::typelist_type_at< variant_types, K >::type;
1511 template<
class T,
class... Args
1512 variant_REQUIRES_T( std::is_constructible< T, Args...>::value )
1517 type_index = helper_type::template construct_t<T>(
ptr(), std::forward<Args>(args)... );
1520 template<
class T,
class U,
class... Args
1521 variant_REQUIRES_T( std::is_constructible< T, std::initializer_list<U>&, Args...>::value )
1526 type_index = helper_type::template construct_t<T>(
ptr(), il, std::forward<Args>(args)... );
1529 template< std::size_t K,
class... Args
1530 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, Args...>::value )
1535 type_index = helper_type::template construct_i<K>(
ptr(), std::forward<Args>(args)... );
1538 template<
size_t K,
class U,
class... Args
1539 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, std::initializer_list<U>&, Args...>::value )
1544 type_index = helper_type::template construct_i<K>(
ptr(), il, std::forward<Args>(args)... );
1566#if variant_CPP11_OR_GREATER
1569 std::is_nothrow_move_assignable<T0>::value &&
1570 std::is_nothrow_move_assignable<T1>::value &&
1571 std::is_nothrow_move_assignable<T2>::value &&
1572 std::is_nothrow_move_assignable<T3>::value &&
1573 std::is_nothrow_move_assignable<T4>::value &&
1574 std::is_nothrow_move_assignable<T5>::value &&
1575 std::is_nothrow_move_assignable<T6>::value &&
1576 std::is_nothrow_move_assignable<T7>::value &&
1577 std::is_nothrow_move_assignable<T8>::value &&
1578 std::is_nothrow_move_assignable<T9>::value &&
1579 std::is_nothrow_move_assignable<T10>::value &&
1580 std::is_nothrow_move_assignable<T11>::value &&
1581 std::is_nothrow_move_assignable<T12>::value &&
1582 std::is_nothrow_move_assignable<T13>::value &&
1583 std::is_nothrow_move_assignable<T14>::value &&
1584 std::is_nothrow_move_assignable<T15>::value)
1586 return move_assign(
std::move( other ) );
1655#if variant_CPP11_OR_GREATER
1659 variant & operator=(
T0 const & t0 ) {
return assign_value<0>( t0 ); }
1663 variant & operator=(
T1 const & t1 ) {
return assign_value<1>( t1 ); }
1667 variant & operator=(
T2 const & t2 ) {
return assign_value<2>( t2 ); }
1671 variant & operator=(
T3 const & t3 ) {
return assign_value<3>( t3 ); }
1675 variant & operator=(
T4 const & t4 ) {
return assign_value<4>( t4 ); }
1679 variant & operator=(
T5 const & t5 ) {
return assign_value<5>( t5 ); }
1683 variant & operator=(
T6 const & t6 ) {
return assign_value<6>( t6 ); }
1687 variant & operator=(
T7 const & t7 ) {
return assign_value<7>( t7 ); }
1691 variant & operator=(
T8 const & t8 ) {
return assign_value<8>( t8 ); }
1695 variant & operator=(
T9 const & t9 ) {
return assign_value<9>( t9 ); }
1699 variant & operator=(
T10 const & t10 ) {
return assign_value<10>( t10 ); }
1703 variant & operator=(
T11 const & t11 ) {
return assign_value<11>( t11 ); }
1707 variant & operator=(
T12 const & t12 ) {
return assign_value<12>( t12 ); }
1711 variant & operator=(
T13 const & t13 ) {
return assign_value<13>( t13 ); }
1715 variant & operator=(
T14 const & t14 ) {
return assign_value<14>( t14 ); }
1719 variant & operator=(
T15 const & t15 ) {
return assign_value<15>( t15 ); }
1749#if variant_CPP11_OR_GREATER
1751 template<
class T,
class... Args
1752 variant_REQUIRES_T( std::is_constructible< T, Args...>::value )
1755 T& emplace( Args&&... args )
1759 type_index = helper_type::template construct_t<T>(
ptr(), std::forward<Args>(args)... );
1764 template<
class T,
class U,
class... Args
1765 variant_REQUIRES_T( std::is_constructible< T, std::initializer_list<U>&, Args...>::value )
1768 T& emplace( std::initializer_list<U> il, Args&&... args )
1772 type_index = helper_type::template construct_t<T>(
ptr(), il, std::forward<Args>(args)... );
1777 template<
size_t K,
class... Args
1778 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, Args...>::value )
1780 variant_alternative_t<K, variant> & emplace( Args&&... args )
1782 return this->
template emplace< type_at_t<K> >( std::forward<Args>(args)... );
1785 template<
size_t K,
class U,
class... Args
1786 variant_REQUIRES_T( std::is_constructible< type_at_t<K>, std::initializer_list<U>&, Args...>::value )
1788 variant_alternative_t<K, variant> & emplace( std::initializer_list<U> il, Args&&... args )
1790 return this->
template emplace< type_at_t<K> >( il, std::forward<Args>(args)... );
1805#if variant_CPP11_OR_GREATER
1807 std::is_nothrow_move_constructible<T0>::value && std17::is_nothrow_swappable<T0>::value &&
1808 std::is_nothrow_move_constructible<T1>::value && std17::is_nothrow_swappable<T1>::value &&
1809 std::is_nothrow_move_constructible<T2>::value && std17::is_nothrow_swappable<T2>::value &&
1810 std::is_nothrow_move_constructible<T3>::value && std17::is_nothrow_swappable<T3>::value &&
1811 std::is_nothrow_move_constructible<T4>::value && std17::is_nothrow_swappable<T4>::value &&
1812 std::is_nothrow_move_constructible<T5>::value && std17::is_nothrow_swappable<T5>::value &&
1813 std::is_nothrow_move_constructible<T6>::value && std17::is_nothrow_swappable<T6>::value &&
1814 std::is_nothrow_move_constructible<T7>::value && std17::is_nothrow_swappable<T7>::value &&
1815 std::is_nothrow_move_constructible<T8>::value && std17::is_nothrow_swappable<T8>::value &&
1816 std::is_nothrow_move_constructible<T9>::value && std17::is_nothrow_swappable<T9>::value &&
1817 std::is_nothrow_move_constructible<T10>::value && std17::is_nothrow_swappable<T10>::value &&
1818 std::is_nothrow_move_constructible<T11>::value && std17::is_nothrow_swappable<T11>::value &&
1819 std::is_nothrow_move_constructible<T12>::value && std17::is_nothrow_swappable<T12>::value &&
1820 std::is_nothrow_move_constructible<T13>::value && std17::is_nothrow_swappable<T13>::value &&
1821 std::is_nothrow_move_constructible<T14>::value && std17::is_nothrow_swappable<T14>::value &&
1822 std::is_nothrow_move_constructible<T15>::value && std17::is_nothrow_swappable<T15>::value
1837#if variant_CPP11_OR_GREATER
1862#if variant_CONFIG_NO_EXCEPTIONS
1863 assert( index_of<T>() ==
index() );
1865 if ( index_of<T>() !=
index() )
1867 throw bad_variant_access();
1876#if variant_CONFIG_NO_EXCEPTIONS
1877 assert( index_of<T>() ==
index() );
1879 if ( index_of<T>() !=
index() )
1881 throw bad_variant_access();
1884 return *as<const T>();
1887 template< std::
size_t K >
1891 return this->
template get< typename detail::typelist_type_at< variant_types, K >::type >();
1894 template< std::
size_t K >
1898 return this->
template get< typename detail::typelist_type_at< variant_types, K >::type >();
1917 return reinterpret_cast<U*
>(
ptr() );
1923 return reinterpret_cast<U
const *
>(
ptr() );
1929 return static_cast<std::size_t
>(
index );
1961#if variant_CPP11_OR_GREATER
1987 template< std::
size_t K,
class T >
1992 *as<T>() = std::forward<T>( value );
1998 new(
ptr() ) T( std::forward<T>( value ) );
2006 template< std::
size_t K,
class T >
2017 new(
ptr() ) T( value );
2028 case 0:
swap( this->get<0>(), other.
get<0>() );
break;
2029 case 1:
swap( this->get<1>(), other.
get<1>() );
break;
2030 case 2:
swap( this->get<2>(), other.
get<2>() );
break;
2031 case 3:
swap( this->get<3>(), other.
get<3>() );
break;
2032 case 4:
swap( this->get<4>(), other.
get<4>() );
break;
2033 case 5:
swap( this->get<5>(), other.
get<5>() );
break;
2034 case 6:
swap( this->get<6>(), other.
get<6>() );
break;
2035 case 7:
swap( this->get<7>(), other.
get<7>() );
break;
2036 case 8:
swap( this->get<8>(), other.
get<8>() );
break;
2037 case 9:
swap( this->get<9>(), other.
get<9>() );
break;
2038 case 10:
swap( this->get<10>(), other.
get<10>() );
break;
2039 case 11:
swap( this->get<11>(), other.
get<11>() );
break;
2040 case 12:
swap( this->get<12>(), other.
get<12>() );
break;
2041 case 13:
swap( this->get<13>(), other.
get<13>() );
break;
2042 case 14:
swap( this->get<14>(), other.
get<14>() );
break;
2043 case 15:
swap( this->get<15>(), other.
get<15>() );
break;
2051#if variant_CPP11_OR_GREATER
2053 enum { data_align = detail::typelist_max_alignof< variant_types >::value };
2055 using aligned_storage_t =
typename std::aligned_storage< data_size, data_align >::type;
2056 aligned_storage_t
data;
2058#elif variant_CONFIG_MAX_ALIGN_HACK
2060 typedef union {
unsigned char data[
data_size ]; } aligned_storage_t;
2062 detail::max_align_t hack;
2063 aligned_storage_t
data;
2082template<
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 >
2083inline bool holds_alternative(
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v )
variant_noexcept
2085 return v.index() ==
variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::template index_of<T>();
2088template<
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 >
2089inline 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) )
2091 return v.template get<R>();
2094template<
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 >
2095inline 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) )
2097 return v.template get<R>();
2100template< 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 >
2101inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type &
2102get(
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) )
2104#if variant_CONFIG_NO_EXCEPTIONS
2105 assert( K == v.index() );
2107 if ( K != v.index() )
2109 throw bad_variant_access();
2112 return v.template get<K>();
2115template< 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 >
2116inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type
const &
2117get(
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) )
2119#if variant_CONFIG_NO_EXCEPTIONS
2120 assert( K == v.index() );
2122 if ( K != v.index() )
2124 throw bad_variant_access();
2127 return v.template get<K>();
2130#if variant_CPP11_OR_GREATER
2132template<
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 >
2133inline 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) )
2138template<
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 >
2139inline 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) )
2144template< 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 >
2145inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type &&
2146get( 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) )
2148#if variant_CONFIG_NO_EXCEPTIONS
2149 assert( K ==
v.index() );
2151 if ( K !=
v.index() )
2153 throw bad_variant_access();
2159template< 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 >
2160inline typename variant_alternative< K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::type
const &&
2161get( 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) )
2163#if variant_CONFIG_NO_EXCEPTIONS
2164 assert( K ==
v.index() );
2166 if ( K !=
v.index() )
2168 throw bad_variant_access();
2176template<
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 >
2178get_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) )
2180 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;
2183template<
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 >
2185get_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))
2187 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;
2190template< 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 >
2191inline 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
2192get_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) )
2197template< 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 >
2198inline 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
2199get_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) )
2206template<
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
2207#if variant_CPP11_OR_GREATER
2209 std::is_move_constructible<T0>::value && std17::is_swappable<T0>::value &&
2210 std::is_move_constructible<T1>::value && std17::is_swappable<T1>::value &&
2211 std::is_move_constructible<T2>::value && std17::is_swappable<T2>::value &&
2212 std::is_move_constructible<T3>::value && std17::is_swappable<T3>::value &&
2213 std::is_move_constructible<T4>::value && std17::is_swappable<T4>::value &&
2214 std::is_move_constructible<T5>::value && std17::is_swappable<T5>::value &&
2215 std::is_move_constructible<T6>::value && std17::is_swappable<T6>::value &&
2216 std::is_move_constructible<T7>::value && std17::is_swappable<T7>::value &&
2217 std::is_move_constructible<T8>::value && std17::is_swappable<T8>::value &&
2218 std::is_move_constructible<T9>::value && std17::is_swappable<T9>::value &&
2219 std::is_move_constructible<T10>::value && std17::is_swappable<T10>::value &&
2220 std::is_move_constructible<T11>::value && std17::is_swappable<T11>::value &&
2221 std::is_move_constructible<T12>::value && std17::is_swappable<T12>::value &&
2222 std::is_move_constructible<T13>::value && std17::is_swappable<T13>::value &&
2223 std::is_move_constructible<T14>::value && std17::is_swappable<T14>::value &&
2224 std::is_move_constructible<T15>::value && std17::is_swappable<T15>::value
2229 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & a,
2230 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> & b )
2231#if variant_CPP11_OR_GREATER
2232 noexcept(
noexcept( a.
swap( b ) ) )
2245template<
typename R,
typename VT >
2248 template<
typename Visitor,
typename T >
2249 static R
apply(Visitor
const& v, T
const& arg)
2255template<
typename R,
typename VT >
2258 template<
typename Visitor,
typename T >
2267struct VisitorApplicator;
2269template<
typename R,
typename Visitor,
typename V1 >
2270struct VisitorUnwrapper;
2272#if variant_CPP11_OR_GREATER
2273template<
size_t NumVars,
typename R,
typename Visitor,
typename ... T >
2275template<
size_t NumVars,
typename R,
typename Visitor,
typename T1,
typename T2 = S0,
typename T3 = S0,
typename T4 = S0,
typename T5 = S0 >
2279template<
typename R,
typename Visitor,
typename T2 >
2292 template<
typename T>
2295 return visitor(val1, val2);
2299template<
typename R,
typename Visitor,
typename T2,
typename T3 >
2314 template<
typename T>
2317 return visitor(val1, val2, val3);
2321template<
typename R,
typename Visitor,
typename T2,
typename T3,
typename T4 >
2338 template<
typename T>
2341 return visitor(val1, val2, val3, val4);
2345template<
typename R,
typename Visitor,
typename T2,
typename T3,
typename T4,
typename T5 >
2364 template<
typename T>
2367 return visitor(val1, val2, val3, val4, val5);
2373template<
typename R,
typename Visitor,
typename V2>
2386 template<
typename T1 >
2393 template<
typename T1,
typename T2 >
2400 template<
typename T1,
typename T2,
typename T3 >
2407 template<
typename T1,
typename T2,
typename T3,
typename T4 >
2414 template<
typename T1,
typename T2,
typename T3,
typename T4,
typename T5 >
2427 template<
typename Visitor,
typename V1>
2428 static R
apply(
const Visitor& v,
const V1& arg)
2430 switch( arg.index() )
2432 case 0:
return apply_visitor<0>(v, arg);
2433 case 1:
return apply_visitor<1>(v, arg);
2434 case 2:
return apply_visitor<2>(v, arg);
2435 case 3:
return apply_visitor<3>(v, arg);
2436 case 4:
return apply_visitor<4>(v, arg);
2437 case 5:
return apply_visitor<5>(v, arg);
2438 case 6:
return apply_visitor<6>(v, arg);
2439 case 7:
return apply_visitor<7>(v, arg);
2440 case 8:
return apply_visitor<8>(v, arg);
2441 case 9:
return apply_visitor<9>(v, arg);
2442 case 10:
return apply_visitor<10>(v, arg);
2443 case 11:
return apply_visitor<11>(v, arg);
2444 case 12:
return apply_visitor<12>(v, arg);
2445 case 13:
return apply_visitor<13>(v, arg);
2446 case 14:
return apply_visitor<14>(v, arg);
2447 case 15:
return apply_visitor<15>(v, arg);
2450 default: std::terminate();
2454 template<
size_t Idx,
typename Visitor,
typename V1>
2458#if variant_CPP11_OR_GREATER
2466#if variant_CPP11_OR_GREATER
2467 template<
typename Visitor,
typename V1,
typename V2,
typename ... V>
2468 static R
apply(
const Visitor& v,
const V1& arg1,
const V2& arg2,
const V ... args)
2471 Unwrapper unwrapper(v, arg1);
2472 return apply(unwrapper, arg2, args ...);
2476 template<
typename Visitor,
typename V1,
typename V2 >
2477 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2)
2480 Unwrapper unwrapper(v, arg1);
2481 return apply(unwrapper, arg2);
2484 template<
typename Visitor,
typename V1,
typename V2,
typename V3 >
2485 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3)
2488 Unwrapper unwrapper(v, arg1);
2489 return apply(unwrapper, arg2, arg3);
2492 template<
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4 >
2493 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4)
2496 Unwrapper unwrapper(v, arg1);
2497 return apply(unwrapper, arg2, arg3, arg4);
2500 template<
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4,
typename V5 >
2501 static R
apply(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4, V5
const& arg5)
2504 Unwrapper unwrapper(v, arg1);
2505 return apply(unwrapper, arg2, arg3, arg4, arg5);
2511#if variant_CPP11_OR_GREATER
2512template<
size_t NumVars,
typename Visitor,
typename ... V >
2515 typedef decltype(std::declval<Visitor>()(get<0>(
static_cast<const V&
>(std::declval<V>()))...)) result_type;
2516 typedef VisitorApplicator<result_type> applicator_type;
2521#if variant_CPP11_OR_GREATER
2523template<
typename Visitor,
typename ... V >
2524inline auto visit(Visitor
const& v, V
const& ... vars) ->
typename detail::VisitorImpl<
sizeof ... (V), Visitor, V... > ::result_type
2526 typedef detail::VisitorImpl<sizeof ... (V), Visitor, V... > impl_type;
2527 return impl_type::applicator_type::apply(v, vars...);
2531template<
typename R,
typename Visitor,
typename V1 >
2532inline R
visit(
const Visitor& v, V1
const& arg1)
2537template<
typename R,
typename Visitor,
typename V1,
typename V2 >
2538inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2)
2543template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3 >
2544inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3)
2549template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4 >
2550inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4)
2555template<
typename R,
typename Visitor,
typename V1,
typename V2,
typename V3,
typename V4,
typename V5 >
2556inline R
visit(
const Visitor& v, V1
const& arg1, V2
const& arg2, V3
const& arg3, V4
const& arg4, V5
const& arg5)
2567template<
class Variant >
2570 static inline bool equal( Variant
const & v, Variant
const & w )
2574 case 0:
return get<0>( v ) == get<0>( w );
2575 case 1:
return get<1>( v ) == get<1>( w );
2576 case 2:
return get<2>( v ) == get<2>( w );
2577 case 3:
return get<3>( v ) == get<3>( w );
2578 case 4:
return get<4>( v ) == get<4>( w );
2579 case 5:
return get<5>( v ) == get<5>( w );
2580 case 6:
return get<6>( v ) == get<6>( w );
2581 case 7:
return get<7>( v ) == get<7>( w );
2582 case 8:
return get<8>( v ) == get<8>( w );
2583 case 9:
return get<9>( v ) == get<9>( w );
2584 case 10:
return get<10>( v ) == get<10>( w );
2585 case 11:
return get<11>( v ) == get<11>( w );
2586 case 12:
return get<12>( v ) == get<12>( w );
2587 case 13:
return get<13>( v ) == get<13>( w );
2588 case 14:
return get<14>( v ) == get<14>( w );
2589 case 15:
return get<15>( v ) == get<15>( w );
2591 default:
return false;
2595 static inline bool less_than( Variant
const & v, Variant
const & w )
2599 case 0:
return get<0>( v ) < get<0>( w );
2600 case 1:
return get<1>( v ) < get<1>( w );
2601 case 2:
return get<2>( v ) < get<2>( w );
2602 case 3:
return get<3>( v ) < get<3>( w );
2603 case 4:
return get<4>( v ) < get<4>( w );
2604 case 5:
return get<5>( v ) < get<5>( w );
2605 case 6:
return get<6>( v ) < get<6>( w );
2606 case 7:
return get<7>( v ) < get<7>( w );
2607 case 8:
return get<8>( v ) < get<8>( w );
2608 case 9:
return get<9>( v ) < get<9>( w );
2609 case 10:
return get<10>( v ) < get<10>( w );
2610 case 11:
return get<11>( v ) < get<11>( w );
2611 case 12:
return get<12>( v ) < get<12>( w );
2612 case 13:
return get<13>( v ) < get<13>( w );
2613 case 14:
return get<14>( v ) < get<14>( w );
2614 case 15:
return get<15>( v ) < get<15>( w );
2616 default:
return false;
2623template<
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 >
2625 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2626 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2628 if ( v.index() != w.
index() )
return false;
2629 else if ( v.valueless_by_exception() )
return true;
2630 else return detail::Comparator< variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::equal( v, w );
2633template<
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 >
2635 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2636 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2638 return ! ( v == w );
2641template<
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 >
2643 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2644 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2647 else if ( v.valueless_by_exception() )
return true;
2648 else if ( v.index() < w.
index() )
return true;
2649 else if ( v.index() > w.
index() )
return false;
2650 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 );
2653template<
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 >
2655 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2656 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2661template<
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 >
2663 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2664 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2669template<
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 >
2671 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & v,
2672 variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const & w )
2679using namespace variants;
2683#if variant_CPP11_OR_GREATER
2690struct hash<
nonstd::monostate >
2698template<
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 >
2699struct hash<
nonstd::variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >
2701 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
2707 case 0:
return nvd::hash( 0 ) ^ nvd::hash( get<0>( v ) );
2708 case 1:
return nvd::hash( 1 ) ^ nvd::hash( get<1>( v ) );
2709 case 2:
return nvd::hash( 2 ) ^ nvd::hash( get<2>( v ) );
2710 case 3:
return nvd::hash( 3 ) ^ nvd::hash( get<3>( v ) );
2711 case 4:
return nvd::hash( 4 ) ^ nvd::hash( get<4>( v ) );
2712 case 5:
return nvd::hash( 5 ) ^ nvd::hash( get<5>( v ) );
2713 case 6:
return nvd::hash( 6 ) ^ nvd::hash( get<6>( v ) );
2714 case 7:
return nvd::hash( 7 ) ^ nvd::hash( get<7>( v ) );
2715 case 8:
return nvd::hash( 8 ) ^ nvd::hash( get<8>( v ) );
2716 case 9:
return nvd::hash( 9 ) ^ nvd::hash( get<9>( v ) );
2717 case 10:
return nvd::hash( 10 ) ^ nvd::hash( get<10>( v ) );
2718 case 11:
return nvd::hash( 11 ) ^ nvd::hash( get<11>( v ) );
2719 case 12:
return nvd::hash( 12 ) ^ nvd::hash( get<12>( v ) );
2720 case 13:
return nvd::hash( 13 ) ^ nvd::hash( get<13>( v ) );
2721 case 14:
return nvd::hash( 14 ) ^ nvd::hash( get<14>( v ) );
2722 case 15:
return nvd::hash( 15 ) ^ nvd::hash( get<15>( v ) );
2733#if variant_BETWEEN( variant_COMPILER_MSVC_VER, 1300, 1900 )
2734# 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)
bool_constant< false > false_type
bool_constant< true > true_type
void index_tag(index_tag_t< K >=index_tag_t< K >())
typedef variant_ALIGN_TYPE(char)
bool operator>(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
bool operator>=(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
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))
variant_constexpr bool operator>=(monostate, monostate) variant_noexcept
variant_constexpr bool operator!=(monostate, monostate) variant_noexcept
R visit(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4, V5 const &arg5)
bool operator<=(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
R visit(const Visitor &v, V1 const &arg1)
bool operator==(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
bool operator!=(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
bool holds_alternative(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v) variant_noexcept
variant_constexpr bool operator==(monostate, monostate) variant_noexcept
variant_constexpr bool operator>(monostate, monostate) variant_noexcept
bool operator<(variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &w)
std11::add_pointer< consttypenamevariant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::type >::type get_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))
variant_constexpr bool operator<=(monostate, monostate) variant_noexcept
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))
variant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::type 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_index_t(K)=nonstd_lite_in_place_index(K))
variant_constexpr bool operator<(monostate, monostate) 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 >())
constexpr std::size_t N
A special marker that means infinite repetitions.
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<<(U const &) const
TX< T > operator~() const
TX< T > operator||(U const &) const
bool operator<(T 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 variant_index_tag(K)
#define nonstd_lite_in_place_type(T)
#define nonstd_lite_in_place_index_t(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_REQUIRES_B(...)
#define nonstd_lite_in_place_type_t(T)
#define nonstd_lite_in_place_index(K)
#define variant_index_tag_t(K)
#define variant_constexpr