absl::variant_internal Namespace Reference

Classes
struct	AccessedType
struct	AccessedType< SimpleArray< T, Size > >
struct	ConversionIsPossible
struct	ConversionIsPossibleImpl
struct	ConversionIsPossibleImpl< Variant, T, void_t< decltype(ImaginaryFun< Variant >::Run(std::declval< T >()))> >
struct	ConversionVisitor
struct	FlattenIndices
struct	FlattenIndices< HeadSize, TailSize... >
struct	FlattenIndices<>
struct	GiveQualsTo
struct	GiveQualsTo< const T &&, U >
struct	GiveQualsTo< const T &, U >
struct	GiveQualsTo< T &&, U >
struct	GiveQualsTo< T &, U >
struct	GiveQualsTo< volatile const T &&, U >
struct	GiveQualsTo< volatile const T &, U >
struct	GiveQualsTo< volatile T &&, U >
struct	GiveQualsTo< volatile T &, U >
struct	ImaginaryFun
struct	ImaginaryFun< variant< H, T... >, I >
struct	ImaginaryFun< variant<>, I >
struct	IndexOfConstructedType
struct	IndexOfConstructedType< Variant, T, void_t< decltype(ImaginaryFun< Variant >::Run(std::declval< T >()))> >
struct	IndexOfImpl
struct	IndexOfImpl< Expected >
struct	IndexOfImpl< Expected, Expected, Tail... >
struct	IndexOfImpl< Expected, Head, Tail... >
struct	IndexOfMeta
struct	IsNeitherSelfNorInPlace
struct	IsNeitherSelfNorInPlace< Self, in_place_index_t< I > >
struct	IsNeitherSelfNorInPlace< Self, in_place_type_t< T > >
struct	IsNeitherSelfNorInPlace< Self, Self >
struct	MakeVisitationMatrix
struct	MakeVisitationMatrix< ReturnType, FunctionObject, index_sequence< HeadEndIndex, TailEndIndices... >, BoundIndices... >
struct	MakeVisitationMatrix< ReturnType, FunctionObject, index_sequence<>, BoundIndices... >
struct	MakeVisitationMatrixImpl
struct	MakeVisitationMatrixImpl< ReturnType, FunctionObject, index_sequence< EndIndices... >, index_sequence< CurrIndices... >, BoundIndices... >
struct	NoMatch
struct	NumCasesOfSwitch
struct	NumCasesOfSwitch< HeadNumAlternatives, TailNumAlternatives... >
struct	NumCasesOfSwitch<>
struct	PickCaseImpl
struct	PickCaseImpl< true >
struct	ReachableSwitchCase
struct	SimpleArray
struct	UnambiguousIndexOf
struct	UnambiguousIndexOf< variant< Alts... >, T >
struct	UnambiguousIndexOfImpl
struct	UnambiguousIndexOfImpl< variant< Head, Tail... >, Head, CurrIndex >
struct	UnambiguousIndexOfImpl< variant< Head, Tail... >, T, CurrIndex >
struct	UnambiguousIndexOfImpl< variant<>, T, CurrIndex >
struct	UnflattenIndex
struct	UnflattenIndex< I, 0, HeadSize, TailSize... >
struct	UnreachableSwitchCase
struct	VariantAccessResultImpl
struct	VariantAccessResultImpl< I, const Variantemplate< T... > & >
struct	VariantAccessResultImpl< I, const Variantemplate< T... > && >
struct	VariantAccessResultImpl< I, Variantemplate< T... > & >
struct	VariantAccessResultImpl< I, Variantemplate< T... > && >
struct	VariantAlternativeSfinae
struct	VariantAlternativeSfinae< 0, variant< T0, Ts... > >
struct	VariantAlternativeSfinae< I, variant< T0, Tn... > >
struct	VariantCoreAccess
class	VariantStateBase
struct	VisitIndices
struct	VisitIndices< EndIndex >
struct	VisitIndicesFallback
struct	VisitIndicesResultImpl
struct	VisitIndicesSwitch
struct	VisitIndicesVariadic
struct	VisitIndicesVariadicImpl
struct	VisitIndicesVariadicImpl< absl::index_sequence< N... >, EndIndices... >

Typedefs
template<class T >
using	AccessedTypeT = typename AccessedType< T >::type
template<class T >
using	AlwaysZero = SizeT< 0 >
template<class T , class U >
using	GiveQualsToT = typename GiveQualsTo< T, U >::type
template<class Expected , class... Types>
using	IndexOf = typename IndexOfMeta< Expected, Types... >::type
using	NPos = SizeT< variant_npos >
template<class Op , std::size_t I, std::size_t EndIndex>
using	PickCase = typename PickCaseImpl<(I< EndIndex)>::template Apply< Op, I >
template<std::size_t I>
using	SizeT = std::integral_constant< std::size_t, I >
template<class T , std::size_t >
using	UnambiguousTypeOfImpl = T
template<class Variant , class T >
using	UnambiguousTypeOfT = UnambiguousTypeOfImpl< T, UnambiguousIndexOf< Variant, T >::value >
template<std::size_t I, class Variant >
using	VariantAccessResult = typename VariantAccessResultImpl< I, Variant && >::type
template<std::size_t I, class T >
using	VariantAlternativeSfinaeT = typename VariantAlternativeSfinae< I, T >::type
template<class Op , class... Vs>
using	VisitIndicesResultT = typename VisitIndicesResultImpl< Op, Vs... >::type

Functions
	ABSL_INTERNAL_INLINE_CONSTEXPR (std::size_t, MaxUnrolledVisitCases, 33)
template<class T >
constexpr T	AccessSimpleArray (const T &value)
template<class T , std::size_t Size, class... SizeT>
constexpr AccessedTypeT< T >	AccessSimpleArray (const SimpleArray< T, Size > &table, std::size_t head_index, SizeT... tail_indices)
template<class Self , std::size_t I>
VariantAccessResult< I, Self >	AccessUnion (Self &&self, SizeT< I >)
template<class ReturnType , class FunctionObject , std::size_t... Indices>
constexpr ReturnType	call_with_indices (FunctionObject &&function)
template<class T >
void	DeducedDestroy (T &self)
void	Rethrow ()
void	ThrowBadVariantAccess ()
template<class ReturnType >
ReturnType	TypedThrowBadVariantAccess ()

Typedef Documentation

AccessedTypeT

template<class T >

using absl::variant_internal::AccessedTypeT = typedef typename AccessedType<T>::type

Definition at line 175 of file internal/variant.h.

AlwaysZero

template<class T >

using absl::variant_internal::AlwaysZero = typedef SizeT<0>

Definition at line 196 of file internal/variant.h.

GiveQualsToT

template<class T , class U >

using absl::variant_internal::GiveQualsToT = typedef typename GiveQualsTo<T, U>::type

Definition at line 122 of file internal/variant.h.

IndexOf

template<class Expected , class... Types>

using absl::variant_internal::IndexOf = typedef typename IndexOfMeta<Expected, Types...>::type

Definition at line 775 of file internal/variant.h.

NPos

using absl::variant_internal::NPos = typedef SizeT<variant_npos>

Definition at line 128 of file internal/variant.h.

PickCase

template<class Op , std::size_t I, std::size_t EndIndex>

using absl::variant_internal::PickCase = typedef typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>

Definition at line 313 of file internal/variant.h.

SizeT

template<std::size_t I>

using absl::variant_internal::SizeT = typedef std::integral_constant<std::size_t, I>

Definition at line 126 of file internal/variant.h.

UnambiguousTypeOfImpl

template<class T , std::size_t >

using absl::variant_internal::UnambiguousTypeOfImpl = typedef T

Definition at line 812 of file internal/variant.h.

UnambiguousTypeOfT

template<class Variant , class T >

using absl::variant_internal::UnambiguousTypeOfT = typedef UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>

Definition at line 816 of file internal/variant.h.

VariantAccessResult

template<std::size_t I, class Variant >

using absl::variant_internal::VariantAccessResult = typedef typename VariantAccessResultImpl<I, Variant&&>::type

Definition at line 160 of file internal/variant.h.

VariantAlternativeSfinaeT

template<std::size_t I, class T >

using absl::variant_internal::VariantAlternativeSfinaeT = typedef typename VariantAlternativeSfinae<I, T>::type

Definition at line 75 of file internal/variant.h.

VisitIndicesResultT

template<class Op , class... Vs>

using absl::variant_internal::VisitIndicesResultT = typedef typename VisitIndicesResultImpl<Op, Vs...>::type

Definition at line 204 of file internal/variant.h.

Function Documentation

ABSL_INTERNAL_INLINE_CONSTEXPR()

absl::variant_internal::ABSL_INTERNAL_INLINE_CONSTEXPR	(	std::size_t	,
		MaxUnrolledVisitCases	,
		33
	)

AccessSimpleArray() [1/2]

template<class T >

constexpr T absl::variant_internal::AccessSimpleArray

(

const T &

value

)

Definition at line 183 of file internal/variant.h.

AccessSimpleArray() [2/2]

template<class T , std::size_t Size, class... SizeT>

constexpr AccessedTypeT<T> absl::variant_internal::AccessSimpleArray	(	const SimpleArray< T, Size > &	table,
		std::size_t	head_index,
		SizeT...	tail_indices
	)

Definition at line 188 of file internal/variant.h.

AccessUnion()

template<class Self , std::size_t I>

VariantAccessResult<I, Self> absl::variant_internal::AccessUnion ( Self &&  self, SizeT< I >    )

inline

Definition at line 535 of file internal/variant.h.

call_with_indices()

template<class ReturnType , class FunctionObject , std::size_t... Indices>

constexpr ReturnType absl::variant_internal::call_with_indices

(

FunctionObject &&

function

)

Definition at line 211 of file internal/variant.h.

DeducedDestroy()

template<class T >

void absl::variant_internal::DeducedDestroy

(

T &

self

)

Definition at line 544 of file internal/variant.h.

Rethrow()

void absl::variant_internal::Rethrow

(

)

Definition at line 48 of file bad_variant_access.cc.

ThrowBadVariantAccess()

void absl::variant_internal::ThrowBadVariantAccess

(

)

Definition at line 39 of file bad_variant_access.cc.

TypedThrowBadVariantAccess()

template<class ReturnType >

ReturnType absl::variant_internal::TypedThrowBadVariantAccess

(

)

Definition at line 316 of file internal/variant.h.