RESTinio

Classes | Namespaces | Macros | Typedefs | Functions
variant.hpp File Reference
`#include <cstddef>`
`#include <limits>`
`#include <new>`
`#include <utility>`
`#include <cassert>`

Go to the source code of 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::index_tag_t< K >
struct | nonstd::variants::std11::remove_reference< T >
struct | nonstd::variants::std11::remove_reference< T & >
struct | nonstd::variants::std11::add_pointer< T >
struct | nonstd::variants::std11::remove_const< T >
struct | nonstd::variants::std11::remove_const< const T >
struct | nonstd::variants::std11::remove_volatile< T >
struct | nonstd::variants::std11::remove_volatile< volatile T >
struct | nonstd::variants::std11::remove_cv< T >
struct | nonstd::variants::std11::conditional< true, Then, Else >
struct | nonstd::variants::std11::conditional< false, Then, Else >
struct | nonstd::variants::std11::enable_if< B, T >
struct | nonstd::variants::std11::enable_if< true, T >
struct | nonstd::variants::std11::is_same< T, U >
struct | nonstd::variants::std11::is_same< T, T >
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< 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< 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< typelist< Head, Tail >, 0 >
struct | nonstd::variants::detail::typelist_type_at< typelist< Head, Tail >, i >
struct | nonstd::variants::detail::typelist_type_is_unique< List, CmpIndex, LastChecked >
struct | nonstd::variants::detail::typelist_type_is_unique< List, CmpIndex, 0 >
struct | nonstd::variants::detail::typelist_contains_unique_type< List, 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::monostate
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, variant< 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 >
union | nonstd::variants::variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::aligned_storage_t
struct | nonstd::variants::detail::VisitorApplicatorImpl< R, VT >
struct | nonstd::variants::detail::VisitorApplicatorImpl< R, TX< VT > >
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
namespace | nonstd
namespace | nonstd::detail
namespace | nonstd::variants
namespace | nonstd::variants::detail
namespace | nonstd::variants::std11
namespace | nonstd::variants::std17
| type traits C++17:

## Macros
#define | NONSTD_VARIANT_LITE_HPP
#define | variant_lite_MAJOR 2
#define | variant_lite_MINOR 0
#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_HAVE_TWEAK_HEADER 0
#define | variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO 0
#define | variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO 0
#define | variant_CONFIG_NO_EXCEPTIONS 1
#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_CONFIG_SELECT_VARIANT ( variant_HAVE_STD_VARIANT ? variant_VARIANT_STD : variant_VARIANT_NONSTD )
#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_index_tag_t(K) void(&)( nonstd::variants::detail::index_tag_t<K> )
#define | variant_index_tag(K) nonstd::variants::detail::index_tag<K>
#define | variant_CONFIG_MAX_TYPE_COUNT 16
#define | variant_CONFIG_MAX_VISITOR_ARG_COUNT 5
#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_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_HAVE_ENABLE_IF variant_CPP11_90
#define | variant_HAVE_IS_SAME variant_CPP11_90
#define | variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )
#define | variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION )
#define | variant_constexpr /*constexpr*/
#define | variant_constexpr14 /*constexpr*/
#define | variant_noexcept /*noexcept*/
#define | variant_nullptr NULL
#define | variant_override /*override*/
#define | variant_REQUIRES_0(...) template< bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0 >
#define | variant_REQUIRES_B(...) , bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0
#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 >())
template<std::size_t K>
void | nonstd::variants::detail::index_tag (index_tag_t< K >=index_tag_t< 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))
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 >
std11::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 >
std11::add_pointer< constT >::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 >
std11::add_pointer< typenamevariant_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 >
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 | 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)
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)

## Macro Definition Documentation

## ◆ nonstd_lite_HAVE_IN_PLACE_TYPES

#define nonstd_lite_HAVE_IN_PLACE_TYPES 1

Definition at line 101 of file variant.hpp.

## ◆ nonstd_lite_in_place

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

Definition at line 175 of file variant.hpp.

## ◆ nonstd_lite_in_place_index

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

Definition at line 177 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 173 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 171 of file variant.hpp.

## ◆ nonstd_lite_in_place_type

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

Definition at line 176 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 172 of file variant.hpp.

## ◆ NONSTD_VARIANT_LITE_HPP

#define NONSTD_VARIANT_LITE_HPP

Definition at line 11 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 905 of file variant.hpp.

## ◆ variant_ALIGN_TYPE

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

Definition at line 950 of file variant.hpp.

## ◆ variant_alternative_T

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

Definition at line 1247 of file variant.hpp.

## ◆ variant_BETWEEN

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

Definition at line 279 of file variant.hpp.

## ◆ variant_COMPILER_CLANG_VERSION

#define variant_COMPILER_CLANG_VERSION 0

Definition at line 308 of file variant.hpp.

## ◆ variant_COMPILER_GNUC_VERSION

#define variant_COMPILER_GNUC_VERSION 0

Definition at line 314 of file variant.hpp.

## ◆ variant_COMPILER_MSVC_VER

#define variant_COMPILER_MSVC_VER 0

Definition at line 299 of file variant.hpp.

## ◆ variant_COMPILER_MSVC_VERSION

#define variant_COMPILER_MSVC_VERSION 0

Definition at line 300 of file variant.hpp.

## ◆ variant_COMPILER_VERSION

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

Definition at line 303 of file variant.hpp.

## ◆ variant_CONFIG_ALIGN_AS_FALLBACK

#define variant_CONFIG_ALIGN_AS_FALLBACK double

Definition at line 275 of file variant.hpp.

## ◆ variant_CONFIG_MAX_ALIGN_HACK

#define variant_CONFIG_MAX_ALIGN_HACK 0

Definition at line 267 of file variant.hpp.

## ◆ variant_CONFIG_MAX_TYPE_COUNT

#define variant_CONFIG_MAX_TYPE_COUNT 16

Definition at line 261 of file variant.hpp.

## ◆ variant_CONFIG_MAX_VISITOR_ARG_COUNT

#define variant_CONFIG_MAX_VISITOR_ARG_COUNT 5

Definition at line 262 of file variant.hpp.

## ◆ variant_CONFIG_NO_EXCEPTIONS

#define variant_CONFIG_NO_EXCEPTIONS 1

Definition at line 56 of file variant.hpp.

## ◆ variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO

#define variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO 0

Definition at line 47 of file variant.hpp.

## ◆ variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO

#define variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO 0

Definition at line 43 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 91 of file variant.hpp.

## ◆ variant_constexpr

#define variant_constexpr /*constexpr*/

Definition at line 382 of file variant.hpp.

## ◆ variant_constexpr14

#define variant_constexpr14 /*constexpr*/

Definition at line 388 of file variant.hpp.

## ◆ variant_CPLUSPLUS

#define variant_CPLUSPLUS __cplusplus

Definition at line 67 of file variant.hpp.

## ◆ variant_CPP11_100

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

Definition at line 340 of file variant.hpp.

## ◆ variant_CPP11_110

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

Definition at line 341 of file variant.hpp.

## ◆ variant_CPP11_120

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

Definition at line 342 of file variant.hpp.

## ◆ variant_CPP11_140

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

Definition at line 343 of file variant.hpp.

## ◆ variant_CPP11_141

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

Definition at line 344 of file variant.hpp.

## ◆ variant_CPP11_90

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

Definition at line 339 of file variant.hpp.

## ◆ variant_CPP11_OR_GREATER

#define variant_CPP11_OR_GREATER ( variant_CPLUSPLUS >= 201103L )

Definition at line 72 of file variant.hpp.

## ◆ variant_CPP11_OR_GREATER_

#define variant_CPP11_OR_GREATER_ ( variant_CPLUSPLUS >= 201103L )

Definition at line 73 of file variant.hpp.

## ◆ variant_CPP14_000

#define variant_CPP14_000 (variant_CPP14_OR_GREATER)

Definition at line 346 of file variant.hpp.

## ◆ variant_CPP14_OR_GREATER

#define variant_CPP14_OR_GREATER ( variant_CPLUSPLUS >= 201402L )

Definition at line 74 of file variant.hpp.

## ◆ variant_CPP17_000

#define variant_CPP17_000 (variant_CPP17_OR_GREATER)

Definition at line 347 of file variant.hpp.

## ◆ variant_CPP17_OR_GREATER

#define variant_CPP17_OR_GREATER ( variant_CPLUSPLUS >= 201703L )

Definition at line 75 of file variant.hpp.

## ◆ variant_CPP20_OR_GREATER

#define variant_CPP20_OR_GREATER ( variant_CPLUSPLUS >= 202000L )

Definition at line 76 of file variant.hpp.

## ◆ variant_CPP98_OR_GREATER

#define variant_CPP98_OR_GREATER ( variant_CPLUSPLUS >= 199711L )

Definition at line 71 of file variant.hpp.

## ◆ variant_HAS_CPP0X

#define variant_HAS_CPP0X 0

Definition at line 329 of file variant.hpp.

## ◆ variant_HAVE

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

Definition at line 324 of file variant.hpp.

## ◆ variant_HAVE_CONDITIONAL

#define variant_HAVE_CONDITIONAL variant_CPP11_120

Definition at line 367 of file variant.hpp.

## ◆ variant_HAVE_CONSTEXPR_11

#define variant_HAVE_CONSTEXPR_11 variant_CPP11_140

Definition at line 351 of file variant.hpp.

## ◆ variant_HAVE_CONSTEXPR_14

#define variant_HAVE_CONSTEXPR_14 variant_CPP14_000

Definition at line 359 of file variant.hpp.

## ◆ variant_HAVE_ENABLE_IF

#define variant_HAVE_ENABLE_IF variant_CPP11_90

Definition at line 371 of file variant.hpp.

## ◆ variant_HAVE_INITIALIZER_LIST

#define variant_HAVE_INITIALIZER_LIST variant_CPP11_120

Definition at line 352 of file variant.hpp.

## ◆ variant_HAVE_IS_SAME

#define variant_HAVE_IS_SAME variant_CPP11_90

Definition at line 372 of file variant.hpp.

## ◆ variant_HAVE_NOEXCEPT

#define variant_HAVE_NOEXCEPT variant_CPP11_140

Definition at line 353 of file variant.hpp.

## ◆ variant_HAVE_NULLPTR

#define variant_HAVE_NULLPTR variant_CPP11_100

Definition at line 354 of file variant.hpp.

## ◆ variant_HAVE_OVERRIDE

#define variant_HAVE_OVERRIDE variant_CPP11_140

Definition at line 355 of file variant.hpp.

## ◆ variant_HAVE_REMOVE_CV

#define variant_HAVE_REMOVE_CV variant_CPP11_120

Definition at line 368 of file variant.hpp.

## ◆ variant_HAVE_STD_ADD_POINTER

#define variant_HAVE_STD_ADD_POINTER variant_CPP11_90

Definition at line 369 of file variant.hpp.

## ◆ variant_HAVE_STD_VARIANT

#define variant_HAVE_STD_VARIANT 0

Definition at line 87 of file variant.hpp.

## ◆ variant_HAVE_TR1_ADD_POINTER

#define variant_HAVE_TR1_ADD_POINTER (!! variant_COMPILER_GNUC_VERSION )

Definition at line 375 of file variant.hpp.

## ◆ variant_HAVE_TR1_TYPE_TRAITS

#define variant_HAVE_TR1_TYPE_TRAITS (!! variant_COMPILER_GNUC_VERSION )

Definition at line 374 of file variant.hpp.

## ◆ variant_HAVE_TWEAK_HEADER

#define variant_HAVE_TWEAK_HEADER 0

Definition at line 36 of file variant.hpp.

## ◆ variant_HAVE_TYPE_TRAITS

#define variant_HAVE_TYPE_TRAITS variant_CPP11_90

Definition at line 370 of file variant.hpp.

## ◆ variant_index_tag

#define variant_index_tag | ( |  | K | ) | nonstd::variants::detail::index_tag<K>

Definition at line 197 of file variant.hpp.

## ◆ variant_index_tag_t

#define variant_index_tag_t | ( |  | K | ) | void(&)( nonstd::variants::detail::index_tag_t<K> )

Definition at line 196 of file variant.hpp.

## ◆ variant_lite_MAJOR

#define variant_lite_MAJOR 2

Definition at line 13 of file variant.hpp.

## ◆ variant_lite_MINOR

#define variant_lite_MINOR 0

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_noexcept

#define variant_noexcept /*noexcept*/

Definition at line 394 of file variant.hpp.

## ◆ variant_nullptr

#define variant_nullptr NULL

Definition at line 400 of file variant.hpp.

## ◆ variant_override

#define variant_override /*override*/

Definition at line 406 of file variant.hpp.

## ◆ variant_REQUIRES_0

#define variant_REQUIRES_0 | ( |  | ... | ) | template< bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0 >

Definition at line 541 of file variant.hpp.

## ◆ variant_REQUIRES_B

#define variant_REQUIRES_B | ( |  | ... | ) | , bool B = (__VA_ARGS__), typename std11::enable_if<B, int>::type = 0

Definition at line 544 of file variant.hpp.

## ◆ variant_size_V

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

Definition at line 1227 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_TL1

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

Definition at line 608 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 617 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 618 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 619 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 620 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 621 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 622 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 623 of file variant.hpp.

## ◆ variant_TL2

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

Definition at line 609 of file variant.hpp.

## ◆ variant_TL3

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

Definition at line 610 of file variant.hpp.

## ◆ variant_TL4

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

Definition at line 611 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 612 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 613 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 614 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 615 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 616 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 94 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.