Classes | Namespaces | Typedefs | Functions
internal/variant.h File Reference
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <memory>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include "absl/base/config.h"
#include "absl/base/internal/identity.h"
#include "absl/base/internal/inline_variable.h"
#include "absl/base/internal/invoke.h"
#include "absl/base/macros.h"
#include "absl/base/optimization.h"
#include "absl/meta/type_traits.h"
#include "absl/types/bad_variant_access.h"
#include "absl/utility/utility.h"
Include dependency graph for internal/variant.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  absl::variant_internal::AccessedType< T >
 
struct  absl::variant_internal::AccessedType< SimpleArray< T, Size > >
 
struct  absl::variant_internal::VariantCoreAccess::ConversionAssignVisitor< Left, QualifiedNew >
 
struct  absl::variant_internal::ConversionIsPossible< Variant, T >
 
struct  absl::variant_internal::ConversionIsPossibleImpl< Variant, T, class >
 
struct  absl::variant_internal::VariantCoreAccess::CopyAssignVisitor< VType >
 
struct  absl::variant_internal::VisitIndicesVariadicImpl< absl::index_sequence< N... >, EndIndices... >::FlattenedOp< Op >
 
struct  absl::variant_internal::FlattenIndices<... >
 
struct  absl::variant_internal::FlattenIndices< HeadSize, TailSize... >
 
struct  absl::variant_internal::FlattenIndices<>
 
struct  absl::variant_internal::GiveQualsTo< T, U >
 
struct  absl::variant_internal::GiveQualsTo< const T &&, U >
 
struct  absl::variant_internal::GiveQualsTo< const T &, U >
 
struct  absl::variant_internal::GiveQualsTo< T &&, U >
 
struct  absl::variant_internal::GiveQualsTo< T &, U >
 
struct  absl::variant_internal::GiveQualsTo< volatile const T &&, U >
 
struct  absl::variant_internal::GiveQualsTo< volatile const T &, U >
 
struct  absl::variant_internal::GiveQualsTo< volatile T &&, U >
 
struct  absl::variant_internal::GiveQualsTo< volatile T &, U >
 
struct  absl::variant_internal::ImaginaryFun< Variant, I >
 
struct  absl::variant_internal::ImaginaryFun< variant< H, T... >, I >
 
struct  absl::variant_internal::ImaginaryFun< variant<>, I >
 
struct  absl::variant_internal::IndexOfConstructedType< Variant, T, class >
 
struct  absl::variant_internal::IndexOfImpl< Expected, T >
 
struct  absl::variant_internal::IndexOfImpl< Expected >
 
struct  absl::variant_internal::IndexOfImpl< Expected, Expected, Tail... >
 
struct  absl::variant_internal::IndexOfImpl< Expected, Head, Tail... >
 
struct  absl::variant_internal::IndexOfMeta< Expected, Types >
 
struct  absl::variant_internal::VariantCoreAccess::InitFromVisitor< LeftVariant, QualifiedRightVariant >
 
struct  absl::variant_internal::IsNeitherSelfNorInPlace< Self, T >
 
struct  absl::variant_internal::IsNeitherSelfNorInPlace< Self, in_place_index_t< I > >
 
struct  absl::variant_internal::IsNeitherSelfNorInPlace< Self, in_place_type_t< T > >
 
struct  absl::variant_internal::IsNeitherSelfNorInPlace< Self, Self >
 
struct  absl::variant_internal::MakeVisitationMatrix< ReturnType, FunctionObject, EndIndices, BoundIndices >
 
struct  absl::variant_internal::MakeVisitationMatrix< ReturnType, FunctionObject, index_sequence< HeadEndIndex, TailEndIndices... >, BoundIndices... >
 
struct  absl::variant_internal::MakeVisitationMatrix< ReturnType, FunctionObject, index_sequence<>, BoundIndices... >
 
struct  absl::variant_internal::MakeVisitationMatrixImpl< ReturnType, FunctionObject, EndIndices, CurrIndices, BoundIndices >
 
struct  absl::variant_internal::MakeVisitationMatrixImpl< ReturnType, FunctionObject, index_sequence< EndIndices... >, index_sequence< CurrIndices... >, BoundIndices... >
 
struct  absl::variant_internal::VariantCoreAccess::MoveAssignVisitor< VType >
 
struct  absl::variant_internal::NoMatch
 
struct  absl::variant_internal::NumCasesOfSwitch< NumAlternatives >
 
struct  absl::variant_internal::NumCasesOfSwitch< HeadNumAlternatives, TailNumAlternatives... >
 
struct  absl::variant_internal::NumCasesOfSwitch<>
 
struct  absl::variant_internal::PickCaseImpl< IsReachable >
 
struct  absl::variant_internal::PickCaseImpl< true >
 
struct  absl::variant_internal::ReachableSwitchCase< Op, I >
 
struct  absl::variant_internal::SimpleArray< T, Size >
 
struct  absl::variant_internal::NoMatch::type
 
struct  absl::variant_internal::UnambiguousIndexOf< Variant, T >
 
struct  absl::variant_internal::UnambiguousIndexOf< variant< Alts... >, T >
 
struct  absl::variant_internal::UnambiguousIndexOfImpl< Variant, T, CurrIndex >
 
struct  absl::variant_internal::UnambiguousIndexOfImpl< variant< Head, Tail... >, Head, CurrIndex >
 
struct  absl::variant_internal::UnambiguousIndexOfImpl< variant< Head, Tail... >, T, CurrIndex >
 
struct  absl::variant_internal::UnambiguousIndexOfImpl< variant<>, T, CurrIndex >
 
struct  absl::variant_internal::UnflattenIndex< I, IndexToGet, HeadSize, TailSize >
 
struct  absl::variant_internal::UnflattenIndex< I, 0, HeadSize, TailSize... >
 
struct  absl::variant_internal::UnreachableSwitchCase
 
class  absl::variant< Types >
 
struct  absl::variant_alternative< I, T >
 
struct  absl::variant_size< T >
 
struct  absl::variant_internal::VariantAccessResultImpl< I, Variant >
 
struct  absl::variant_internal::VariantAccessResultImpl< I, const Variantemplate< T... > & >
 
struct  absl::variant_internal::VariantAccessResultImpl< I, const Variantemplate< T... > && >
 
struct  absl::variant_internal::VariantAccessResultImpl< I, Variantemplate< T... > & >
 
struct  absl::variant_internal::VariantAccessResultImpl< I, Variantemplate< T... > && >
 
struct  absl::variant_internal::VariantAlternativeSfinae< I, T >
 
struct  absl::variant_internal::VariantAlternativeSfinae< 0, variant< T0, Ts... > >
 
struct  absl::variant_internal::VariantAlternativeSfinae< I, variant< T0, Tn... > >
 
struct  absl::variant_internal::VariantCoreAccess
 
class  absl::variant_internal::VariantStateBase< H, T >
 
struct  absl::variant_internal::VisitIndices< EndIndices >
 
struct  absl::variant_internal::VisitIndices< EndIndex >
 
struct  absl::variant_internal::VisitIndicesFallback< EndIndices >
 
struct  absl::variant_internal::VisitIndicesResultImpl< Op, Vs >
 
struct  absl::variant_internal::VisitIndicesSwitch< EndIndex >
 
struct  absl::variant_internal::VisitIndicesVariadic< EndIndices >
 
struct  absl::variant_internal::VisitIndicesVariadicImpl< IndexSequence, EndIndices >
 
struct  absl::variant_internal::VisitIndicesVariadicImpl< absl::index_sequence< N... >, EndIndices... >
 

Namespaces

 absl
 
 absl::variant_internal
 

Typedefs

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

Functions

 absl::ABSL_INTERNAL_INLINE_CONSTEXPR (size_t, variant_npos,-1)
 
 absl::variant_internal::ABSL_INTERNAL_INLINE_CONSTEXPR (std::size_t, MaxUnrolledVisitCases, 33)
 
template<class T >
constexpr T absl::variant_internal::AccessSimpleArray (const T &value)
 
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)
 
template<class Self , std::size_t I>
VariantAccessResult< I, Self > absl::variant_internal::AccessUnion (Self &&self, SizeT< I >)
 
template<class ReturnType , class FunctionObject , std::size_t... Indices>
constexpr ReturnType absl::variant_internal::call_with_indices (FunctionObject &&function)
 
template<class T >
void absl::variant_internal::DeducedDestroy (T &self)
 
template<class ReturnType >
ReturnType absl::variant_internal::TypedThrowBadVariantAccess ()
 


abseil_cpp
Author(s):
autogenerated on Tue Jun 18 2019 19:44:38