#include <variant.h>

Inheritance diagram for absl::variant< T0, Tn... >:

Public Member Functions
template<class T , class... Args, typename std::enable_if< std::is_constructible< absl::variant_alternative_t< variant_internal::UnambiguousIndexOf< variant, T >::value, variant >, Args... >::value >::type * = nullptr>
T &	emplace (Args &&...args)

template<class T , class U , class... Args, typename std::enable_if< std::is_constructible< absl::variant_alternative_t< variant_internal::UnambiguousIndexOf< variant, T >::value, variant >, std::initializer_list< U > &, Args... >::value >::type * = nullptr>
T &	emplace (std::initializer_list< U > il, Args &&...args)

template<std::size_t I, class... Args, typename std::enable_if< std::is_constructible< absl::variant_alternative_t< I, variant >, Args... >::value >::type * = nullptr>
absl::variant_alternative_t< I, variant > &	emplace (Args &&...args)

template<std::size_t I, class U , class... Args, typename std::enable_if< std::is_constructible< absl::variant_alternative_t< I, variant >, std::initializer_list< U > &, Args... >::value >::type * = nullptr>
absl::variant_alternative_t< I, variant > &	emplace (std::initializer_list< U > il, Args &&...args)

constexpr std::size_t	index () const noexcept

variant &	operator= (const variant &other)=default

variant &	operator= (variant &&other)=default

template<class T , std::size_t I = std::enable_if< !std::is_same<absl::decay_t<T>, variant>::value, variant_internal::IndexOfConstructedType<variant, T>>::type::value, class Tj = absl::variant_alternative_t<I, variant>, typename std::enable_if< std::is_assignable< Tj &, T >::value &&std::is_constructible< Tj, T >::value >::type * = nullptr>
variant &	operator= (T &&t) noexcept(std::is_nothrow_assignable< Tj &, T >::value &&std::is_nothrow_constructible< Tj, T >::value)

void	swap (variant &rhs) noexcept(absl::conjunction< std::is_nothrow_move_constructible< T0 >, std::is_nothrow_move_constructible< Tn >..., type_traits_internal::IsNothrowSwappable< T0 >, type_traits_internal::IsNothrowSwappable< Tn >... >::value)

constexpr bool	valueless_by_exception () const noexcept

constexpr	variant ()=default

	variant (const variant &other)=default

	variant (variant &&other)=default

template<class T , std::size_t I = std::enable_if< variant_internal::IsNeitherSelfNorInPlace<variant, absl::decay_t<T>>::value, variant_internal::IndexOfConstructedType<variant, T>>::type::value, class Tj = absl::variant_alternative_t<I, variant>, absl::enable_if_t< std::is_constructible< Tj, T >::value > * = nullptr>
constexpr	variant (T &&t) noexcept(std::is_nothrow_constructible< Tj, T >::value)

template<class T , class... Args, typename std::enable_if< std::is_constructible< variant_internal::UnambiguousTypeOfT< variant, T >, Args... >::value >::type * = nullptr>
constexpr	variant (in_place_type_t< T >, Args &&...args)

template<class T , class U , class... Args, typename std::enable_if< std::is_constructible< variant_internal::UnambiguousTypeOfT< variant, T >, std::initializer_list< U > &, Args... >::value >::type * = nullptr>
constexpr	variant (in_place_type_t< T >, std::initializer_list< U > il, Args &&...args)

template<std::size_t I, class... Args, typename std::enable_if< std::is_constructible< variant_internal::VariantAlternativeSfinaeT< I, variant >, Args... >::value >::type * = nullptr>
constexpr	variant (in_place_index_t< I >, Args &&...args)

template<std::size_t I, class U , class... Args, typename std::enable_if< std::is_constructible< variant_internal::VariantAlternativeSfinaeT< I, variant >, std::initializer_list< U > &, Args... >::value >::type * = nullptr>
constexpr	variant (in_place_index_t< I >, std::initializer_list< U > il, Args &&...args)

	~variant ()=default

Private Types
using	Base = variant_internal::VariantBase< T0, Tn... >

Friends
struct	variant_internal::VariantCoreAccess