Classes | Typedefs | Functions
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.



abseil_cpp
Author(s):
autogenerated on Mon Feb 28 2022 21:31:23