#include <cstddef>
#include <limits>
#include <new>
#include <stdexcept>
#include <utility>

Include dependency graph for variant.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	nonstd::detail::in_place_type_tag< T >

struct	nonstd::detail::in_place_index_tag< K >

struct	nonstd::in_place_t

struct	nonstd::variants::detail::remove_reference< T >

struct	nonstd::variants::detail::remove_reference< T & >

struct	nonstd::variants::detail::add_pointer< T >

struct	nonstd::variants::detail::remove_const< T >

struct	nonstd::variants::detail::remove_const< const T >

struct	nonstd::variants::detail::remove_volatile< T >

struct	nonstd::variants::detail::remove_volatile< volatile T >

struct	nonstd::variants::detail::remove_cv< T >

struct	nonstd::variants::detail::conditional< Cond, Then, Else >

struct	nonstd::variants::detail::conditional< true, Then, Else >

struct	nonstd::variants::detail::conditional< false, Then, Else >

struct	nonstd::variants::detail::TX< T >

struct	nonstd::variants::detail::S0

struct	nonstd::variants::detail::S1

struct	nonstd::variants::detail::S2

struct	nonstd::variants::detail::S3

struct	nonstd::variants::detail::S4

struct	nonstd::variants::detail::S5

struct	nonstd::variants::detail::S6

struct	nonstd::variants::detail::S7

struct	nonstd::variants::detail::S8

struct	nonstd::variants::detail::S9

struct	nonstd::variants::detail::S10

struct	nonstd::variants::detail::S11

struct	nonstd::variants::detail::S12

struct	nonstd::variants::detail::S13

struct	nonstd::variants::detail::S14

struct	nonstd::variants::detail::S15

struct	nonstd::variants::detail::nulltype

struct	nonstd::variants::detail::typelist< Head, Tail >

struct	nonstd::variants::detail::typelist_max< List >

struct	nonstd::variants::detail::typelist_max< nulltype >

struct	nonstd::variants::detail::typelist_max< typelist< Head, Tail > >

struct	nonstd::variants::detail::typelist_size< List >

struct	nonstd::variants::detail::typelist_size< T0 >

struct	nonstd::variants::detail::typelist_size< T1 >

struct	nonstd::variants::detail::typelist_size< T2 >

struct	nonstd::variants::detail::typelist_size< T3 >

struct	nonstd::variants::detail::typelist_size< T4 >

struct	nonstd::variants::detail::typelist_size< T5 >

struct	nonstd::variants::detail::typelist_size< T6 >

struct	nonstd::variants::detail::typelist_size< T7 >

struct	nonstd::variants::detail::typelist_size< T8 >

struct	nonstd::variants::detail::typelist_size< T9 >

struct	nonstd::variants::detail::typelist_size< T10 >

struct	nonstd::variants::detail::typelist_size< T11 >

struct	nonstd::variants::detail::typelist_size< T12 >

struct	nonstd::variants::detail::typelist_size< T13 >

struct	nonstd::variants::detail::typelist_size< T14 >

struct	nonstd::variants::detail::typelist_size< T15 >

struct	nonstd::variants::detail::typelist_size< nulltype >

struct	nonstd::variants::detail::typelist_size< typelist< Head, Tail > >

struct	nonstd::variants::detail::typelist_index_of< List, T >

struct	nonstd::variants::detail::typelist_index_of< nulltype, T >

struct	nonstd::variants::detail::typelist_index_of< typelist< T, Tail >, T >

struct	nonstd::variants::detail::typelist_index_of< typelist< Head, Tail >, T >

struct	nonstd::variants::detail::typelist_type_at< List, i >

struct	nonstd::variants::detail::typelist_type_at< typelist< Head, Tail >, 0 >

struct	nonstd::variants::detail::typelist_type_at< typelist< Head, Tail >, i >

struct	nonstd::variants::detail::alignment_of< T >

struct	nonstd::variants::detail::alignment_of_hack< T >

struct	nonstd::variants::detail::alignment_logic< A, S >

struct	nonstd::variants::detail::alignment_of< T >

struct	nonstd::variants::detail::type_of_size< List, N >

struct	nonstd::variants::detail::type_of_size< nulltype, N >

struct	nonstd::variants::detail::struct_t< T >

struct	nonstd::variants::detail::helper< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >

class	nonstd::variants::variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >

class	nonstd::variants::monostate

struct	nonstd::variants::variant_size< T >

struct	nonstd::variants::variant_size< variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >

struct	nonstd::variants::variant_alternative< K, T >

struct	nonstd::variants::variant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >

class	nonstd::variants::bad_variant_access

class	nonstd::variants::variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >

struct	nonstd::variants::detail::VisitorApplicatorImpl< R, VT >

struct	nonstd::variants::detail::VisitorApplicatorImpl< R, TX< VT > >

struct	nonstd::variants::detail::VisitorApplicator< R >

struct	nonstd::variants::detail::VisitorUnwrapper< R, Visitor, V2 >

struct	nonstd::variants::detail::TypedVisitorUnwrapper< NumVars, R, Visitor, T1, T2, T3, T4, T5 >

struct	nonstd::variants::detail::TypedVisitorUnwrapper< 2, R, Visitor, T2 >

struct	nonstd::variants::detail::TypedVisitorUnwrapper< 3, R, Visitor, T2, T3 >

struct	nonstd::variants::detail::TypedVisitorUnwrapper< 4, R, Visitor, T2, T3, T4 >

struct	nonstd::variants::detail::TypedVisitorUnwrapper< 5, R, Visitor, T2, T3, T4, T5 >

struct	nonstd::variants::detail::VisitorUnwrapper< R, Visitor, V2 >

struct	nonstd::variants::detail::VisitorApplicator< R >

struct	nonstd::variants::detail::Comparator< Variant >

Namespaces
	nonstd

	nonstd::detail

	nonstd::variants

	nonstd::variants::detail

Macros
#define	NONSTD_VARIANT_LITE_HPP

#define	variant_lite_MAJOR 1

#define	variant_lite_MINOR 1

#define	variant_lite_PATCH 0

#define	variant_lite_VERSION variant_STRINGIFY(variant_lite_MAJOR) "." variant_STRINGIFY(variant_lite_MINOR) "." variant_STRINGIFY(variant_lite_PATCH)

#define	variant_STRINGIFY( x) variant_STRINGIFY_( x )

#define	variant_STRINGIFY_(x) #x

#define	variant_VARIANT_DEFAULT 0

#define	variant_VARIANT_NONSTD 1

#define	variant_VARIANT_STD 2

#define	variant_CONFIG_SELECT_VARIANT ( variant_HAVE_STD_VARIANT ? variant_VARIANT_STD : variant_VARIANT_NONSTD )

#define	variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO 0

#define	variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO 0

#define	variant_CPLUSPLUS __cplusplus

#define	variant_CPP98_OR_GREATER ( variant_CPLUSPLUS >= 199711L )

#define	variant_CPP11_OR_GREATER ( variant_CPLUSPLUS >= 201103L )

#define	variant_CPP11_OR_GREATER_ ( variant_CPLUSPLUS >= 201103L )

#define	variant_CPP14_OR_GREATER ( variant_CPLUSPLUS >= 201402L )

#define	variant_CPP17_OR_GREATER ( variant_CPLUSPLUS >= 201703L )

#define	variant_CPP20_OR_GREATER ( variant_CPLUSPLUS >= 202000L )

#define	variant_HAVE_STD_VARIANT 0

#define	variant_USES_STD_VARIANT ( (variant_CONFIG_SELECT_VARIANT == variant_VARIANT_STD) \|\| ((variant_CONFIG_SELECT_VARIANT == variant_VARIANT_DEFAULT) && variant_HAVE_STD_VARIANT) )

#define	nonstd_lite_HAVE_IN_PLACE_TYPES 1

#define	nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

#define	nonstd_lite_in_place_type_t(T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

#define	nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )

#define	nonstd_lite_in_place( T) nonstd::in_place_type<T>

#define	nonstd_lite_in_place_type(T) nonstd::in_place_type<T>

#define	nonstd_lite_in_place_index(K) nonstd::in_place_index<K>

#define	variant_CONFIG_MAX_ALIGN_HACK 0

#define	variant_CONFIG_ALIGN_AS_FALLBACK double

#define	variant_BETWEEN(v, lo, hi) ( lo <= v && v < hi )

#define	variant_COMPILER_MSVC_VER 0

#define	variant_COMPILER_MSVC_VERSION 0

#define	variant_COMPILER_VERSION(major, minor, patch) ( 10 * ( 10 * (major) + (minor) ) + (patch) )

#define	variant_COMPILER_CLANG_VERSION 0

#define	variant_COMPILER_GNUC_VERSION 0

#define	variant_HAVE(feature) ( variant_HAVE_##feature )

#define	variant_HAS_CPP0X 0

#define	variant_CPP11_90 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1500)

#define	variant_CPP11_100 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1600)

#define	variant_CPP11_110 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1700)

#define	variant_CPP11_120 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1800)

#define	variant_CPP11_140 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1900)

#define	variant_CPP11_141 (variant_CPP11_OR_GREATER_ \|\| variant_COMPILER_MSVC_VER >= 1910)

#define	variant_CPP14_000 (variant_CPP14_OR_GREATER)

#define	variant_CPP17_000 (variant_CPP17_OR_GREATER)

#define	variant_HAVE_CONSTEXPR_11 variant_CPP11_140

#define	variant_HAVE_INITIALIZER_LIST variant_CPP11_120

#define	variant_HAVE_NOEXCEPT variant_CPP11_140

#define	variant_HAVE_NULLPTR variant_CPP11_100

#define	variant_HAVE_OVERRIDE variant_CPP11_140

#define	variant_HAVE_CONSTEXPR_14 variant_CPP14_000

#define	variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )

#define	variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION )

#define	variant_HAVE_CONDITIONAL variant_CPP11_120

#define	variant_HAVE_REMOVE_CV variant_CPP11_120

#define	variant_HAVE_STD_ADD_POINTER variant_CPP11_90

#define	variant_HAVE_TYPE_TRAITS variant_CPP11_90

#define	variant_constexpr /constexpr/

#define	variant_constexpr14 /constexpr/

#define	variant_noexcept /noexcept/

#define	variant_nullptr NULL

#define	variant_override /override/

#define	variant_TL1(T1) detail::typelist< T1, detail::nulltype >

#define	variant_TL2(T1, T2) detail::typelist< T1, variant_TL1( T2) >

#define	variant_TL3(T1, T2, T3) detail::typelist< T1, variant_TL2( T2, T3) >

#define	variant_TL4(T1, T2, T3, T4) detail::typelist< T1, variant_TL3( T2, T3, T4) >

#define	variant_TL5(T1, T2, T3, T4, T5) detail::typelist< T1, variant_TL4( T2, T3, T4, T5) >

#define	variant_TL6(T1, T2, T3, T4, T5, T6) detail::typelist< T1, variant_TL5( T2, T3, T4, T5, T6) >

#define	variant_TL7(T1, T2, T3, T4, T5, T6, T7) detail::typelist< T1, variant_TL6( T2, T3, T4, T5, T6, T7) >

#define	variant_TL8(T1, T2, T3, T4, T5, T6, T7, T8) detail::typelist< T1, variant_TL7( T2, T3, T4, T5, T6, T7, T8) >

#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) >

#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) >

#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) >

#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) >

#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) >

#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) >

#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) >

#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) >

#define	variant_ALIGN_AS(to_align) typename detail::type_of_size< detail::alignment_types, detail::alignment_of< to_align >::value >::type

#define	variant_ALIGN_TYPE(type) typelist< type , typelist< struct_t< type >

#define	variant_size_V(T) nonstd::variant_size<T>::value

#define	variant_alternative_T(K, T) typename nonstd::variant_alternative<K,T >::type

Typedefs
typedef TX< S0 >	nonstd::variants::detail::T0

typedef TX< S1 >	nonstd::variants::detail::T1

typedef TX< S2 >	nonstd::variants::detail::T2

typedef TX< S3 >	nonstd::variants::detail::T3

typedef TX< S4 >	nonstd::variants::detail::T4

typedef TX< S5 >	nonstd::variants::detail::T5

typedef TX< S6 >	nonstd::variants::detail::T6

typedef TX< S7 >	nonstd::variants::detail::T7

typedef TX< S8 >	nonstd::variants::detail::T8

typedef TX< S9 >	nonstd::variants::detail::T9

typedef TX< S10 >	nonstd::variants::detail::T10

typedef TX< S11 >	nonstd::variants::detail::T11

typedef TX< S12 >	nonstd::variants::detail::T12

typedef TX< S13 >	nonstd::variants::detail::T13

typedef TX< S14 >	nonstd::variants::detail::T14

typedef TX< S15 >	nonstd::variants::detail::T15

typedef nulltype	nonstd::variants::detail::alignment_types

Functions
template<class T >
in_place_t	nonstd::in_place (detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())

template<std::size_t K>
in_place_t	nonstd::in_place (detail::in_place_index_tag< K >=detail::in_place_index_tag< K >())

template<class T >
in_place_t	nonstd::in_place_type (detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())

template<std::size_t K>
in_place_t	nonstd::in_place_index (detail::in_place_index_tag< K >=detail::in_place_index_tag< K >())

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (char)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (short)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (int)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (long)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (float)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (double)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (long double)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (char *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (short *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (int *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (long *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (float *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (double *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (long double *)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (Unknown(*)(Unknown))

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (Unknown Unknown::)

typedef	nonstd::variants::detail::variant_ALIGN_TYPE (Unknown(Unknown::*)(Unknown))

template<typename T >
std::size_t	nonstd::variants::detail::hash (T const &v)

variant_constexpr bool	nonstd::variants::operator< (monostate, monostate) variant_noexcept

variant_constexpr bool	nonstd::variants::operator> (monostate, monostate) variant_noexcept

variant_constexpr bool	nonstd::variants::operator<= (monostate, monostate) variant_noexcept

variant_constexpr bool	nonstd::variants::operator>= (monostate, monostate) variant_noexcept

variant_constexpr bool	nonstd::variants::operator== (monostate, monostate) variant_noexcept

variant_constexpr bool	nonstd::variants::operator!= (monostate, monostate) variant_noexcept

template<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 >
bool	nonstd::variants::holds_alternative (variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v) variant_noexcept

template<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 >
R &	nonstd::variants::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))

template<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 >
R const &	nonstd::variants::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))

template<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 >
variant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::type &	nonstd::variants::get (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))

template<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 >
variant_alternative< K, variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > >::type const &	nonstd::variants::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))

template<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 >
detail::add_pointer< T >::type	nonstd::variants::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))

template<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 >
detail::add_pointer< const T >::type	nonstd::variants::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_type_t(T)=nonstd_lite_in_place_type(T))

template<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 >
detail::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	nonstd::variants::get_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))

template<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 >
detail::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	nonstd::variants::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))

template<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 >
void	nonstd::variants::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) variant_noexcept

template<typename R , typename Visitor , typename V1 >
R	nonstd::variants::visit (const Visitor &v, V1 const &arg1)

template<typename R , typename Visitor , typename V1 , typename V2 >
R	nonstd::variants::visit (const Visitor &v, V1 const &arg1, V2 const &arg2)

template<typename R , typename Visitor , typename V1 , typename V2 , typename V3 >
R	nonstd::variants::visit (const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3)

template<typename R , typename Visitor , typename V1 , typename V2 , typename V3 , typename V4 >
R	nonstd::variants::visit (const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4)

template<typename R , typename Visitor , typename V1 , typename V2 , typename V3 , typename V4 , typename V5 >
R	nonstd::variants::visit (const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4, V5 const &arg5)

template<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 >
bool	nonstd::variants::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)

template<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 >
bool	nonstd::variants::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)

template<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 >
bool	nonstd::variants::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)

template<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 >
bool	nonstd::variants::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)

template<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 >
bool	nonstd::variants::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)

template<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 >
bool	nonstd::variants::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)

Variables
static const std::size_t	nonstd::variants::variant_npos = static_cast<std::size_t>( -1 )

Macro Definition Documentation

◆ NONSTD_VARIANT_LITE_HPP

#define NONSTD_VARIANT_LITE_HPP

Definition at line 11 of file variant.hpp.

◆ variant_lite_MAJOR

#define variant_lite_MAJOR 1

Definition at line 13 of file variant.hpp.

◆ variant_lite_MINOR

#define variant_lite_MINOR 1

Definition at line 14 of file variant.hpp.

◆ variant_lite_PATCH

#define variant_lite_PATCH 0

Definition at line 15 of file variant.hpp.

◆ variant_lite_VERSION

#define variant_lite_VERSION variant_STRINGIFY(variant_lite_MAJOR) "." variant_STRINGIFY(variant_lite_MINOR) "." variant_STRINGIFY(variant_lite_PATCH)

Definition at line 17 of file variant.hpp.

◆ variant_STRINGIFY

#define variant_STRINGIFY ( x ) variant_STRINGIFY_( x )

Definition at line 19 of file variant.hpp.

◆ variant_STRINGIFY_

#define variant_STRINGIFY_ ( x ) #x

Definition at line 20 of file variant.hpp.

◆ variant_VARIANT_DEFAULT

#define variant_VARIANT_DEFAULT 0

Definition at line 24 of file variant.hpp.

◆ variant_VARIANT_NONSTD

#define variant_VARIANT_NONSTD 1

Definition at line 25 of file variant.hpp.

◆ variant_VARIANT_STD

#define variant_VARIANT_STD 2

Definition at line 26 of file variant.hpp.

◆ variant_CONFIG_SELECT_VARIANT

#define variant_CONFIG_SELECT_VARIANT ( variant_HAVE_STD_VARIANT ? variant_VARIANT_STD : variant_VARIANT_NONSTD )

Definition at line 29 of file variant.hpp.

◆ variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO

#define variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO 0

Definition at line 33 of file variant.hpp.

◆ variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO

#define variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO 0

Definition at line 37 of file variant.hpp.

◆ variant_CPLUSPLUS

#define variant_CPLUSPLUS __cplusplus

Definition at line 47 of file variant.hpp.

◆ variant_CPP98_OR_GREATER

#define variant_CPP98_OR_GREATER ( variant_CPLUSPLUS >= 199711L )

Definition at line 51 of file variant.hpp.

◆ variant_CPP11_OR_GREATER

#define variant_CPP11_OR_GREATER ( variant_CPLUSPLUS >= 201103L )

Definition at line 52 of file variant.hpp.

◆ variant_CPP11_OR_GREATER_

#define variant_CPP11_OR_GREATER_ ( variant_CPLUSPLUS >= 201103L )

Definition at line 53 of file variant.hpp.

◆ variant_CPP14_OR_GREATER

#define variant_CPP14_OR_GREATER ( variant_CPLUSPLUS >= 201402L )

Definition at line 54 of file variant.hpp.

◆ variant_CPP17_OR_GREATER

#define variant_CPP17_OR_GREATER ( variant_CPLUSPLUS >= 201703L )

Definition at line 55 of file variant.hpp.

◆ variant_CPP20_OR_GREATER

#define variant_CPP20_OR_GREATER ( variant_CPLUSPLUS >= 202000L )

Definition at line 56 of file variant.hpp.

◆ variant_HAVE_STD_VARIANT

#define variant_HAVE_STD_VARIANT 0

Definition at line 67 of file variant.hpp.

◆ variant_USES_STD_VARIANT

#define variant_USES_STD_VARIANT ( (variant_CONFIG_SELECT_VARIANT == variant_VARIANT_STD) || ((variant_CONFIG_SELECT_VARIANT == variant_VARIANT_DEFAULT) && variant_HAVE_STD_VARIANT) )

Definition at line 70 of file variant.hpp.

◆ nonstd_lite_HAVE_IN_PLACE_TYPES

#define nonstd_lite_HAVE_IN_PLACE_TYPES 1

Definition at line 77 of file variant.hpp.

◆ nonstd_lite_in_place_t

#define nonstd_lite_in_place_t ( T ) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

Definition at line 147 of file variant.hpp.

◆ nonstd_lite_in_place_type_t

#define nonstd_lite_in_place_type_t ( T ) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

Definition at line 148 of file variant.hpp.

◆ nonstd_lite_in_place_index_t

#define nonstd_lite_in_place_index_t ( K ) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )

Definition at line 149 of file variant.hpp.

◆ nonstd_lite_in_place

#define nonstd_lite_in_place ( T ) nonstd::in_place_type<T>

Definition at line 151 of file variant.hpp.

◆ nonstd_lite_in_place_type

#define nonstd_lite_in_place_type ( T ) nonstd::in_place_type<T>

Definition at line 152 of file variant.hpp.

◆ nonstd_lite_in_place_index

#define nonstd_lite_in_place_index ( K ) nonstd::in_place_index<K>

Definition at line 153 of file variant.hpp.

◆ variant_CONFIG_MAX_ALIGN_HACK

#define variant_CONFIG_MAX_ALIGN_HACK 0

Definition at line 214 of file variant.hpp.

◆ variant_CONFIG_ALIGN_AS_FALLBACK

#define variant_CONFIG_ALIGN_AS_FALLBACK double

Definition at line 222 of file variant.hpp.

◆ variant_BETWEEN

#define variant_BETWEEN	(	v,
		lo,
		hi
	)	( lo <= v && v < hi )

Definition at line 226 of file variant.hpp.

◆ variant_COMPILER_MSVC_VER

#define variant_COMPILER_MSVC_VER 0

Definition at line 245 of file variant.hpp.

◆ variant_COMPILER_MSVC_VERSION

#define variant_COMPILER_MSVC_VERSION 0

Definition at line 246 of file variant.hpp.

◆ variant_COMPILER_VERSION

#define variant_COMPILER_VERSION	(	major,
		minor,
		patch
	)	( 10 * ( 10 * (major) + (minor) ) + (patch) )

Definition at line 249 of file variant.hpp.

◆ variant_COMPILER_CLANG_VERSION

#define variant_COMPILER_CLANG_VERSION 0

Definition at line 254 of file variant.hpp.

◆ variant_COMPILER_GNUC_VERSION

#define variant_COMPILER_GNUC_VERSION 0

Definition at line 260 of file variant.hpp.

◆ variant_HAVE

#define variant_HAVE ( feature ) ( variant_HAVE_##feature )

Definition at line 270 of file variant.hpp.

◆ variant_HAS_CPP0X

#define variant_HAS_CPP0X 0

Definition at line 275 of file variant.hpp.

◆ variant_CPP11_90

#define variant_CPP11_90 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1500)

Definition at line 285 of file variant.hpp.

◆ variant_CPP11_100

#define variant_CPP11_100 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1600)

Definition at line 286 of file variant.hpp.

◆ variant_CPP11_110

#define variant_CPP11_110 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1700)

Definition at line 287 of file variant.hpp.

◆ variant_CPP11_120

#define variant_CPP11_120 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1800)

Definition at line 288 of file variant.hpp.

◆ variant_CPP11_140

#define variant_CPP11_140 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1900)

Definition at line 289 of file variant.hpp.

◆ variant_CPP11_141

#define variant_CPP11_141 (variant_CPP11_OR_GREATER_ || variant_COMPILER_MSVC_VER >= 1910)

Definition at line 290 of file variant.hpp.

◆ variant_CPP14_000

#define variant_CPP14_000 (variant_CPP14_OR_GREATER)

Definition at line 292 of file variant.hpp.

◆ variant_CPP17_000

#define variant_CPP17_000 (variant_CPP17_OR_GREATER)

Definition at line 293 of file variant.hpp.

◆ variant_HAVE_CONSTEXPR_11

#define variant_HAVE_CONSTEXPR_11 variant_CPP11_140

Definition at line 297 of file variant.hpp.

◆ variant_HAVE_INITIALIZER_LIST

#define variant_HAVE_INITIALIZER_LIST variant_CPP11_120

Definition at line 298 of file variant.hpp.

◆ variant_HAVE_NOEXCEPT

#define variant_HAVE_NOEXCEPT variant_CPP11_140

Definition at line 299 of file variant.hpp.

◆ variant_HAVE_NULLPTR

#define variant_HAVE_NULLPTR variant_CPP11_100

Definition at line 300 of file variant.hpp.

◆ variant_HAVE_OVERRIDE

#define variant_HAVE_OVERRIDE variant_CPP11_140

Definition at line 301 of file variant.hpp.

◆ variant_HAVE_CONSTEXPR_14

#define variant_HAVE_CONSTEXPR_14 variant_CPP14_000

Definition at line 305 of file variant.hpp.

◆ variant_HAVE_TR1_TYPE_TRAITS

#define variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )

Definition at line 313 of file variant.hpp.

◆ variant_HAVE_TR1_ADD_POINTER

#define variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION )

Definition at line 314 of file variant.hpp.

◆ variant_HAVE_CONDITIONAL

#define variant_HAVE_CONDITIONAL variant_CPP11_120

Definition at line 316 of file variant.hpp.

◆ variant_HAVE_REMOVE_CV

#define variant_HAVE_REMOVE_CV variant_CPP11_120

Definition at line 317 of file variant.hpp.

◆ variant_HAVE_STD_ADD_POINTER

#define variant_HAVE_STD_ADD_POINTER variant_CPP11_90

Definition at line 318 of file variant.hpp.

◆ variant_HAVE_TYPE_TRAITS

#define variant_HAVE_TYPE_TRAITS variant_CPP11_90

Definition at line 319 of file variant.hpp.

◆ variant_constexpr

#define variant_constexpr /*constexpr*/

Definition at line 326 of file variant.hpp.

◆ variant_constexpr14

#define variant_constexpr14 /*constexpr*/

Definition at line 332 of file variant.hpp.

◆ variant_noexcept

#define variant_noexcept /*noexcept*/

Definition at line 338 of file variant.hpp.

◆ variant_nullptr

#define variant_nullptr NULL

Definition at line 344 of file variant.hpp.

◆ variant_override

#define variant_override /*override*/

Definition at line 350 of file variant.hpp.

◆ variant_TL1

#define variant_TL1 ( T1 ) detail::typelist< T1, detail::nulltype >

Definition at line 453 of file variant.hpp.

◆ variant_TL2

#define variant_TL2	(	T1,
		T2
	)	detail::typelist< T1, variant_TL1( T2) >

Definition at line 454 of file variant.hpp.

◆ variant_TL3

#define variant_TL3	(	T1,
		T2,
		T3
	)	detail::typelist< T1, variant_TL2( T2, T3) >

Definition at line 455 of file variant.hpp.

◆ variant_TL4

#define variant_TL4	(	T1,
		T2,
		T3,
		T4
	)	detail::typelist< T1, variant_TL3( T2, T3, T4) >

Definition at line 456 of file variant.hpp.

◆ variant_TL5

#define variant_TL5	(	T1,
		T2,
		T3,
		T4,
		T5
	)	detail::typelist< T1, variant_TL4( T2, T3, T4, T5) >

Definition at line 457 of file variant.hpp.

◆ variant_TL6

#define variant_TL6	(	T1,
		T2,
		T3,
		T4,
		T5,
		T6
	)	detail::typelist< T1, variant_TL5( T2, T3, T4, T5, T6) >

Definition at line 458 of file variant.hpp.

◆ variant_TL7

#define variant_TL7	(	T1,
		T2,
		T3,
		T4,
		T5,
		T6,
		T7
	)	detail::typelist< T1, variant_TL6( T2, T3, T4, T5, T6, T7) >

Definition at line 459 of file variant.hpp.

◆ variant_TL8

#define variant_TL8	(	T1,
		T2,
		T3,
		T4,
		T5,
		T6,
		T7,
		T8
	)	detail::typelist< T1, variant_TL7( T2, T3, T4, T5, T6, T7, T8) >

Definition at line 460 of file variant.hpp.

◆ variant_TL9

#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) >

Definition at line 461 of file variant.hpp.

◆ variant_TL10

#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) >

Definition at line 462 of file variant.hpp.

◆ variant_TL11

#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) >

Definition at line 463 of file variant.hpp.

◆ variant_TL12

#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) >

Definition at line 464 of file variant.hpp.

◆ variant_TL13

#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) >

Definition at line 465 of file variant.hpp.

◆ variant_TL14

#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) >

Definition at line 466 of file variant.hpp.

◆ variant_TL15

#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) >

Definition at line 467 of file variant.hpp.

◆ variant_TL16

#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) >

Definition at line 468 of file variant.hpp.

◆ variant_ALIGN_AS

#define variant_ALIGN_AS ( to_align ) typename detail::type_of_size< detail::alignment_types, detail::alignment_of< to_align >::value >::type

Definition at line 725 of file variant.hpp.

◆ variant_ALIGN_TYPE

#define variant_ALIGN_TYPE ( type ) typelist< type , typelist< struct_t< type >

Definition at line 770 of file variant.hpp.

◆ variant_size_V

#define variant_size_V ( T ) nonstd::variant_size<T>::value

Definition at line 981 of file variant.hpp.

◆ variant_alternative_T

#define variant_alternative_T	(	K,
		T
	)	typename nonstd::variant_alternative<K,T >::type

Definition at line 1001 of file variant.hpp.

Classes

Namespaces

Macros

Typedefs

Functions

Variables