NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
variant.hpp File Reference
#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:

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::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 >
nonstd::variants::visit (const Visitor &v, V1 const &arg1)
 
template<typename R , typename Visitor , typename V1 , typename V2 >
nonstd::variants::visit (const Visitor &v, V1 const &arg1, V2 const &arg2)
 
template<typename R , typename Visitor , typename V1 , typename V2 , typename V3 >
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 >
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 >
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

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

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,
 
)    typename nonstd::variant_alternative<K,T >::type

Definition at line 1001 of file variant.hpp.