Classes | Namespaces | Typedefs | Functions
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)
 


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