variant.h File Reference

#include "absl/base/config.h"
#include "absl/utility/utility.h"
#include <functional>
#include <new>
#include <type_traits>
#include <utility>
#include "absl/base/macros.h"
#include "absl/base/port.h"
#include "absl/meta/type_traits.h"
#include "absl/types/internal/variant.h"

Include dependency graph for 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::ConversionVisitor< To >
struct	std::hash< absl::monostate >
struct	std::hash< absl::variant< T... > >
struct	absl::monostate
class	absl::variant< Types >
class	absl::variant< T0, Tn... >
struct	absl::variant_alternative< I, T >
struct	absl::variant_alternative< I, const T >
struct	absl::variant_alternative< I, const volatile T >
struct	absl::variant_alternative< I, variant< Types... > >
struct	absl::variant_alternative< I, volatile T >
struct	absl::variant_size< T >
struct	absl::variant_size< const T >
struct	absl::variant_size< const volatile T >
struct	absl::variant_size< variant< Ts... > >
struct	absl::variant_size< volatile T >

Namespaces
	absl
	absl::variant_internal
	std

Typedefs
template<std::size_t I, class T >
using	absl::variant_alternative_t = typename variant_alternative< I, T >::type

Functions
template<typename To , typename Variant >
To	absl::ConvertVariantTo (Variant &&variant)
template<class T , class... Types>
constexpr T &	absl::get (variant< Types... > &v)
template<class T , class... Types>
constexpr T &&	absl::get (variant< Types... > &&v)
template<class T , class... Types>
constexpr const T &	absl::get (const variant< Types... > &v)
template<class T , class... Types>
constexpr const T &&	absl::get (const variant< Types... > &&v)
template<std::size_t I, class... Types>
constexpr variant_alternative_t< I, variant< Types... > > &	absl::get (variant< Types... > &v)
template<std::size_t I, class... Types>
constexpr variant_alternative_t< I, variant< Types... > > &&	absl::get (variant< Types... > &&v)
template<std::size_t I, class... Types>
constexpr const variant_alternative_t< I, variant< Types... > > &	absl::get (const variant< Types... > &v)
template<std::size_t I, class... Types>
constexpr const variant_alternative_t< I, variant< Types... > > &&	absl::get (const variant< Types... > &&v)
template<std::size_t I, class... Types>
constexpr absl::add_pointer_t< variant_alternative_t< I, variant< Types... > > >	absl::get_if (variant< Types... > *v) noexcept
template<std::size_t I, class... Types>
constexpr absl::add_pointer_t< const variant_alternative_t< I, variant< Types... > > >	absl::get_if (const variant< Types... > *v) noexcept
template<class T , class... Types>
constexpr absl::add_pointer_t< T >	absl::get_if (variant< Types... > *v) noexcept
template<class T , class... Types>
constexpr absl::add_pointer_t< const T >	absl::get_if (const variant< Types... > *v) noexcept
template<class T , class... Types>
constexpr bool	absl::holds_alternative (const variant< Types... > &v) noexcept
constexpr bool	absl::operator!= (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveNotEqualT< Types... >	absl::operator!= (const variant< Types... > &a, const variant< Types... > &b)
constexpr bool	absl::operator< (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveLessThanT< Types... >	absl::operator< (const variant< Types... > &a, const variant< Types... > &b)
constexpr bool	absl::operator<= (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveLessThanOrEqualT< Types... >	absl::operator<= (const variant< Types... > &a, const variant< Types... > &b)
constexpr bool	absl::operator== (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveEqualT< Types... >	absl::operator== (const variant< Types... > &a, const variant< Types... > &b)
constexpr bool	absl::operator> (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveGreaterThanT< Types... >	absl::operator> (const variant< Types... > &a, const variant< Types... > &b)
constexpr bool	absl::operator>= (monostate, monostate) noexcept
template<typename... Types>
constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT< Types... >	absl::operator>= (const variant< Types... > &a, const variant< Types... > &b)
template<typename... Ts, absl::enable_if_t< absl::conjunction< std::is_move_constructible< Ts >..., type_traits_internal::IsSwappable< Ts >... >::value, int > = 0>
void	absl::swap (variant< Ts... > &v, variant< Ts... > &w) noexcept(noexcept(v.swap(w)))
template<typename Visitor , typename... Variants>
variant_internal::VisitResult< Visitor, Variants... >	absl::visit (Visitor &&vis, Variants &&...vars)