EIC code displayed by LXR master/​include/​absl/​types/​variant.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-07-15 08:27:11

 // Copyright 2018 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 // -----------------------------------------------------------------------------
 // variant.h
 // -----------------------------------------------------------------------------
 //
 // This header file defines an `absl::variant` type for holding a type-safe
 // value of some prescribed set of types (noted as alternative types), and
 // associated functions for managing variants.
 //
 // The `absl::variant` type is a form of type-safe union. An `absl::variant`
 // should always hold a value of one of its alternative types (except in the
 // "valueless by exception state" -- see below). A default-constructed
 // `absl::variant` will hold the value of its first alternative type, provided
 // it is default-constructible.
 //
 // In exceptional cases due to error, an `absl::variant` can hold no
 // value (known as a "valueless by exception" state), though this is not the
 // norm.
 //
 // As with `absl::optional`, an `absl::variant` -- when it holds a value --
 // allocates a value of that type directly within the `variant` itself; it
 // cannot hold a reference, array, or the type `void`; it can, however, hold a
 // pointer to externally managed memory.
 //
 // `absl::variant` is a C++11 compatible version of the C++17 `std::variant`
 // abstraction and is designed to be a drop-in replacement for code compliant
 // with C++17.
 
 #ifndef ABSL_TYPES_VARIANT_H_
 #define ABSL_TYPES_VARIANT_H_
 
 #include "absl/base/config.h"
 #include "absl/utility/utility.h"
 
 #ifdef ABSL_USES_STD_VARIANT
 
 #include <variant>  // IWYU pragma: export
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 using std::bad_variant_access;
 using std::get;
 using std::get_if;
 using std::holds_alternative;
 using std::monostate;
 using std::variant;
 using std::variant_alternative;
 using std::variant_alternative_t;
 using std::variant_npos;
 using std::variant_size;
 using std::variant_size_v;
 using std::visit;
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_VARIANT
 
 #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"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // absl::variant
 // -----------------------------------------------------------------------------
 //
 // An `absl::variant` type is a form of type-safe union. An `absl::variant` --
 // except in exceptional cases -- always holds a value of one of its alternative
 // types.
 //
 // Example:
 //
 //   // Construct a variant that holds either an integer or a std::string and
 //   // assign it to a std::string.
 //   absl::variant<int, std::string> v = std::string("abc");
 //
 //   // A default-constructed variant will hold a value-initialized value of
 //   // the first alternative type.
 //   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
 //
 //   // variants are assignable.
 //
 //   // copy assignment
 //   auto v1 = absl::variant<int, std::string>("abc");
 //   auto v2 = absl::variant<int, std::string>(10);
 //   v2 = v1;  // copy assign
 //
 //   // move assignment
 //   auto v1 = absl::variant<int, std::string>("abc");
 //   v1 = absl::variant<int, std::string>(10);
 //
 //   // assignment through type conversion
 //   a = 128;         // variant contains int
 //   a = "128";       // variant contains std::string
 //
 // An `absl::variant` holding a value of one of its alternative types `T` holds
 // an allocation of `T` directly within the variant itself. An `absl::variant`
 // is not allowed to allocate additional storage, such as dynamic memory, to
 // allocate the contained value. The contained value shall be allocated in a
 // region of the variant storage suitably aligned for all alternative types.
 template <typename... Ts>
 class variant;
 
 // swap()
 //
 // Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
 // where `v` and `w` are `absl::variant` types.
 //
 // Note that this function requires all alternative types to be both swappable
 // and move-constructible, because any two variants may refer to either the same
 // type (in which case, they will be swapped) or to two different types (in
 // which case the values will need to be moved).
 //
 template <
     typename... Ts,
     absl::enable_if_t<
         absl::conjunction<std::is_move_constructible<Ts>...,
                           type_traits_internal::IsSwappable<Ts>...>::value,
         int> = 0>
 void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) {
   v.swap(w);
 }
 
 // variant_size
 //
 // Returns the number of alternative types available for a given `absl::variant`
 // type as a compile-time constant expression. As this is a class template, it
 // is not generally useful for accessing the number of alternative types of
 // any given `absl::variant` instance.
 //
 // Example:
 //
 //   auto a = absl::variant<int, std::string>;
 //   constexpr int num_types =
 //       absl::variant_size<absl::variant<int, std::string>>();
 //
 //   // You can also use the member constant `value`.
 //   constexpr int num_types =
 //       absl::variant_size<absl::variant<int, std::string>>::value;
 //
 //   // `absl::variant_size` is more valuable for use in generic code:
 //   template <typename Variant>
 //   constexpr bool IsVariantMultivalue() {
 //       return absl::variant_size<Variant>() > 1;
 //   }
 //
 // Note that the set of cv-qualified specializations of `variant_size` are
 // provided to ensure that those specializations compile (especially when passed
 // within template logic).
 template <class T>
 struct variant_size;
 
 template <class... Ts>
 struct variant_size<variant<Ts...>>
     : std::integral_constant<std::size_t, sizeof...(Ts)> {};
 
 // Specialization of `variant_size` for const qualified variants.
 template <class T>
 struct variant_size<const T> : variant_size<T>::type {};
 
 // Specialization of `variant_size` for volatile qualified variants.
 template <class T>
 struct variant_size<volatile T> : variant_size<T>::type {};
 
 // Specialization of `variant_size` for const volatile qualified variants.
 template <class T>
 struct variant_size<const volatile T> : variant_size<T>::type {};
 
 // variant_alternative
 //
 // Returns the alternative type for a given `absl::variant` at the passed
 // index value as a compile-time constant expression. As this is a class
 // template resulting in a type, it is not useful for access of the run-time
 // value of any given `absl::variant` variable.
 //
 // Example:
 //
 //   // The type of the 0th alternative is "int".
 //   using alternative_type_0
 //     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
 //
 //   static_assert(std::is_same<alternative_type_0, int>::value, "");
 //
 //   // `absl::variant_alternative` is more valuable for use in generic code:
 //   template <typename Variant>
 //   constexpr bool IsFirstElementTrivial() {
 //       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
 //   }
 //
 // Note that the set of cv-qualified specializations of `variant_alternative`
 // are provided to ensure that those specializations compile (especially when
 // passed within template logic).
 template <std::size_t I, class T>
 struct variant_alternative;
 
 template <std::size_t I, class... Types>
 struct variant_alternative<I, variant<Types...>> {
   using type =
       variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
 };
 
 // Specialization of `variant_alternative` for const qualified variants.
 template <std::size_t I, class T>
 struct variant_alternative<I, const T> {
   using type = const typename variant_alternative<I, T>::type;
 };
 
 // Specialization of `variant_alternative` for volatile qualified variants.
 template <std::size_t I, class T>
 struct variant_alternative<I, volatile T> {
   using type = volatile typename variant_alternative<I, T>::type;
 };
 
 // Specialization of `variant_alternative` for const volatile qualified
 // variants.
 template <std::size_t I, class T>
 struct variant_alternative<I, const volatile T> {
   using type = const volatile typename variant_alternative<I, T>::type;
 };
 
 // Template type alias for variant_alternative<I, T>::type.
 //
 // Example:
 //
 //   using alternative_type_0
 //     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
 //   static_assert(std::is_same<alternative_type_0, int>::value, "");
 template <std::size_t I, class T>
 using variant_alternative_t = typename variant_alternative<I, T>::type;
 
 // holds_alternative()
 //
 // Checks whether the given variant currently holds a given alternative type,
 // returning `true` if so.
 //
 // Example:
 //
 //   absl::variant<int, std::string> foo = 42;
 //   if (absl::holds_alternative<int>(foo)) {
 //       std::cout << "The variant holds an integer";
 //   }
 template <class T, class... Types>
 constexpr bool holds_alternative(const variant<Types...>& v) noexcept {
   static_assert(
       variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
                                                0>::value != sizeof...(Types),
       "The type T must occur exactly once in Types...");
   return v.index() ==
          variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
 }
 
 // get()
 //
 // Returns a reference to the value currently within a given variant, using
 // either a unique alternative type amongst the variant's set of alternative
 // types, or the variant's index value. Attempting to get a variant's value
 // using a type that is not unique within the variant's set of alternative types
 // is a compile-time error. If the index of the alternative being specified is
 // different from the index of the alternative that is currently stored, throws
 // `absl::bad_variant_access`.
 //
 // Example:
 //
 //   auto a = absl::variant<int, std::string>;
 //
 //   // Get the value by type (if unique).
 //   int i = absl::get<int>(a);
 //
 //   auto b = absl::variant<int, int>;
 //
 //   // Getting the value by a type that is not unique is ill-formed.
 //   int j = absl::get<int>(b);     // Compile Error!
 //
 //   // Getting value by index not ambiguous and allowed.
 //   int k = absl::get<1>(b);
 
 // Overload for getting a variant's lvalue by type.
 template <class T, class... Types>
 constexpr T& get(variant<Types...>& v) {  // NOLINT
   return variant_internal::VariantCoreAccess::CheckedAccess<
       variant_internal::IndexOf<T, Types...>::value>(v);
 }
 
 // Overload for getting a variant's rvalue by type.
 template <class T, class... Types>
 constexpr T&& get(variant<Types...>&& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<
       variant_internal::IndexOf<T, Types...>::value>(std::move(v));
 }
 
 // Overload for getting a variant's const lvalue by type.
 template <class T, class... Types>
 constexpr const T& get(const variant<Types...>& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<
       variant_internal::IndexOf<T, Types...>::value>(v);
 }
 
 // Overload for getting a variant's const rvalue by type.
 template <class T, class... Types>
 constexpr const T&& get(const variant<Types...>&& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<
       variant_internal::IndexOf<T, Types...>::value>(std::move(v));
 }
 
 // Overload for getting a variant's lvalue by index.
 template <std::size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>>& get(
     variant<Types...>& v) {  // NOLINT
   return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
 }
 
 // Overload for getting a variant's rvalue by index.
 template <std::size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>>&& get(
     variant<Types...>&& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
 }
 
 // Overload for getting a variant's const lvalue by index.
 template <std::size_t I, class... Types>
 constexpr const variant_alternative_t<I, variant<Types...>>& get(
     const variant<Types...>& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
 }
 
 // Overload for getting a variant's const rvalue by index.
 template <std::size_t I, class... Types>
 constexpr const variant_alternative_t<I, variant<Types...>>&& get(
     const variant<Types...>&& v) {
   return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
 }
 
 // get_if()
 //
 // Returns a pointer to the value currently stored within a given variant, if
 // present, using either a unique alternative type amongst the variant's set of
 // alternative types, or the variant's index value. If such a value does not
 // exist, returns `nullptr`.
 //
 // As with `get`, attempting to get a variant's value using a type that is not
 // unique within the variant's set of alternative types is a compile-time error.
 
 // Overload for getting a pointer to the value stored in the given variant by
 // index.
 template <std::size_t I, class... Types>
 constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
 get_if(variant<Types...>* v) noexcept {
   return (v != nullptr && v->index() == I)
              ? std::addressof(
                    variant_internal::VariantCoreAccess::Access<I>(*v))
              : nullptr;
 }
 
 // Overload for getting a pointer to the const value stored in the given
 // variant by index.
 template <std::size_t I, class... Types>
 constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
 get_if(const variant<Types...>* v) noexcept {
   return (v != nullptr && v->index() == I)
              ? std::addressof(
                    variant_internal::VariantCoreAccess::Access<I>(*v))
              : nullptr;
 }
 
 // Overload for getting a pointer to the value stored in the given variant by
 // type.
 template <class T, class... Types>
 constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept {
   return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
 }
 
 // Overload for getting a pointer to the const value stored in the given variant
 // by type.
 template <class T, class... Types>
 constexpr absl::add_pointer_t<const T> get_if(
     const variant<Types...>* v) noexcept {
   return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
 }
 
 // visit()
 //
 // Calls a provided functor on a given set of variants. `absl::visit()` is
 // commonly used to conditionally inspect the state of a given variant (or set
 // of variants).
 //
 // The functor must return the same type when called with any of the variants'
 // alternatives.
 //
 // Example:
 //
 //   // Define a visitor functor
 //   struct GetVariant {
 //       template<typename T>
 //       void operator()(const T& i) const {
 //         std::cout << "The variant's value is: " << i;
 //       }
 //   };
 //
 //   // Declare our variant, and call `absl::visit()` on it.
 //   // Note that `GetVariant()` returns void in either case.
 //   absl::variant<int, std::string> foo = std::string("foo");
 //   GetVariant visitor;
 //   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
 template <typename Visitor, typename... Variants>
 variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
                                                           Variants&&... vars) {
   return variant_internal::
       VisitIndices<variant_size<absl::decay_t<Variants> >::value...>::Run(
           variant_internal::PerformVisitation<Visitor, Variants...>{
               std::forward_as_tuple(std::forward<Variants>(vars)...),
               std::forward<Visitor>(vis)},
           vars.index()...);
 }
 
 // monostate
 //
 // The monostate class serves as a first alternative type for a variant for
 // which the first variant type is otherwise not default-constructible.
 struct monostate {};
 
 // `absl::monostate` Relational Operators
 
 constexpr bool operator<(monostate, monostate) noexcept { return false; }
 constexpr bool operator>(monostate, monostate) noexcept { return false; }
 constexpr bool operator<=(monostate, monostate) noexcept { return true; }
 constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 constexpr bool operator==(monostate, monostate) noexcept { return true; }
 constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 
 
 //------------------------------------------------------------------------------
 // `absl::variant` Template Definition
 //------------------------------------------------------------------------------
 template <typename T0, typename... Tn>
 class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   static_assert(absl::conjunction<std::is_object<T0>,
                                   std::is_object<Tn>...>::value,
                 "Attempted to instantiate a variant containing a non-object "
                 "type.");
   // Intentionally not qualifying `negation` with `absl::` to work around a bug
   // in MSVC 2015 with inline namespace and variadic template.
   static_assert(absl::conjunction<negation<std::is_array<T0> >,
                                   negation<std::is_array<Tn> >...>::value,
                 "Attempted to instantiate a variant containing an array type.");
   static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
                                   std::is_nothrow_destructible<Tn>...>::value,
                 "Attempted to instantiate a variant containing a non-nothrow "
                 "destructible type.");
 
   friend struct variant_internal::VariantCoreAccess;
 
  private:
   using Base = variant_internal::VariantBase<T0, Tn...>;
 
  public:
   // Constructors
 
   // Constructs a variant holding a default-initialized value of the first
   // alternative type.
   constexpr variant() /*noexcept(see 111above)*/ = default;
 
   // Copy constructor, standard semantics
   variant(const variant& other) = default;
 
   // Move constructor, standard semantics
   variant(variant&& other) /*noexcept(see above)*/ = default;
 
   // Constructs a variant of an alternative type specified by overload
   // resolution of the provided forwarding arguments through
   // direct-initialization.
   //
   // Note: If the selected constructor is a constexpr constructor, this
   // constructor shall be a constexpr constructor.
   //
   // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
   // has been voted passed the design phase in the C++ standard meeting in Mar
   // 2018. It will be implemented and integrated into `absl::variant`.
   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)
       : Base(variant_internal::EmplaceTag<I>(), std::forward<T>(t)) {}
 
   // Constructs a variant of an alternative type from the arguments through
   // direct-initialization.
   //
   // Note: If the selected constructor is a constexpr constructor, this
   // constructor shall be a constexpr constructor.
   template <class T, class... Args,
             typename std::enable_if<std::is_constructible<
                 variant_internal::UnambiguousTypeOfT<variant, T>,
                 Args...>::value>::type* = nullptr>
   constexpr explicit variant(in_place_type_t<T>, Args&&... args)
       : Base(variant_internal::EmplaceTag<
                  variant_internal::UnambiguousIndexOf<variant, T>::value>(),
              std::forward<Args>(args)...) {}
 
   // Constructs a variant of an alternative type from an initializer list
   // and other arguments through direct-initialization.
   //
   // Note: If the selected constructor is a constexpr constructor, this
   // constructor shall be a constexpr constructor.
   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 explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
                              Args&&... args)
       : Base(variant_internal::EmplaceTag<
                  variant_internal::UnambiguousIndexOf<variant, T>::value>(),
              il, std::forward<Args>(args)...) {}
 
   // Constructs a variant of an alternative type from a provided index,
   // through value-initialization using the provided forwarded arguments.
   template <std::size_t I, class... Args,
             typename std::enable_if<std::is_constructible<
                 variant_internal::VariantAlternativeSfinaeT<I, variant>,
                 Args...>::value>::type* = nullptr>
   constexpr explicit variant(in_place_index_t<I>, Args&&... args)
       : Base(variant_internal::EmplaceTag<I>(), std::forward<Args>(args)...) {}
 
   // Constructs a variant of an alternative type from a provided index,
   // through value-initialization of an initializer list and the provided
   // forwarded arguments.
   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 explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
                              Args&&... args)
       : Base(variant_internal::EmplaceTag<I>(), il,
              std::forward<Args>(args)...) {}
 
   // Destructors
 
   // Destroys the variant's currently contained value, provided that
   // `absl::valueless_by_exception()` is false.
   ~variant() = default;
 
   // Assignment Operators
 
   // Copy assignment operator
   variant& operator=(const variant& other) = default;
 
   // Move assignment operator
   variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
 
   // Converting assignment operator
   //
   // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
   // has been voted passed the design phase in the C++ standard meeting in Mar
   // 2018. It will be implemented and integrated into `absl::variant`.
   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) {
     variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
         variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
             this, std::forward<T>(t)),
         index());
 
     return *this;
   }
 
 
   // emplace() Functions
 
   // Constructs a value of the given alternative type T within the variant. The
   // existing value of the variant is destroyed first (provided that
   // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
   // in the variant.
   //
   // Example:
   //
   //   absl::variant<std::vector<int>, int, std::string> v;
   //   v.emplace<int>(99);
   //   v.emplace<std::string>("abc");
   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) {
     return variant_internal::VariantCoreAccess::Replace<
         variant_internal::UnambiguousIndexOf<variant, T>::value>(
         this, std::forward<Args>(args)...);
   }
 
   // Constructs a value of the given alternative type T within the variant using
   // an initializer list. The existing value of the variant is destroyed first
   // (provided that `absl::valueless_by_exception()` is false). Requires that T
   // is unambiguous in the variant.
   //
   // Example:
   //
   //   absl::variant<std::vector<int>, int, std::string> v;
   //   v.emplace<std::vector<int>>({0, 1, 2});
   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) {
     return variant_internal::VariantCoreAccess::Replace<
         variant_internal::UnambiguousIndexOf<variant, T>::value>(
         this, il, std::forward<Args>(args)...);
   }
 
   // Destroys the current value of the variant (provided that
   // `absl::valueless_by_exception()` is false) and constructs a new value at
   // the given index.
   //
   // Example:
   //
   //   absl::variant<std::vector<int>, int, int> v;
   //   v.emplace<1>(99);
   //   v.emplace<2>(98);
   //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
   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) {
     return variant_internal::VariantCoreAccess::Replace<I>(
         this, std::forward<Args>(args)...);
   }
 
   // Destroys the current value of the variant (provided that
   // `absl::valueless_by_exception()` is false) and constructs a new value at
   // the given index using an initializer list and the provided arguments.
   //
   // Example:
   //
   //   absl::variant<std::vector<int>, int, int> v;
   //   v.emplace<0>({0, 1, 2});
   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) {
     return variant_internal::VariantCoreAccess::Replace<I>(
         this, il, std::forward<Args>(args)...);
   }
 
   // variant::valueless_by_exception()
   //
   // Returns false if and only if the variant currently holds a valid value.
   constexpr bool valueless_by_exception() const noexcept {
     return this->index_ == absl::variant_npos;
   }
 
   // variant::index()
   //
   // Returns the index value of the variant's currently selected alternative
   // type.
   constexpr std::size_t index() const noexcept { return this->index_; }
 
   // variant::swap()
   //
   // Swaps the values of two variant objects.
   //
   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) {
     return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
         variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
   }
 };
 
 // We need a valid declaration of variant<> for SFINAE and overload resolution
 // to work properly above, but we don't need a full declaration since this type
 // will never be constructed. This declaration, though incomplete, suffices.
 template <>
 class variant<>;
 
 //------------------------------------------------------------------------------
 // Relational Operators
 //------------------------------------------------------------------------------
 //
 // If neither operand is in the `variant::valueless_by_exception` state:
 //
 //   * If the index of both variants is the same, the relational operator
 //     returns the result of the corresponding relational operator for the
 //     corresponding alternative type.
 //   * If the index of both variants is not the same, the relational operator
 //     returns the result of that operation applied to the value of the left
 //     operand's index and the value of the right operand's index.
 //   * If at least one operand is in the valueless_by_exception state:
 //     - A variant in the valueless_by_exception state is only considered equal
 //       to another variant in the valueless_by_exception state.
 //     - If exactly one operand is in the valueless_by_exception state, the
 //       variant in the valueless_by_exception state is less than the variant
 //       that is not in the valueless_by_exception state.
 //
 // Note: The value 1 is added to each index in the relational comparisons such
 // that the index corresponding to the valueless_by_exception state wraps around
 // to 0 (the lowest value for the index type), and the remaining indices stay in
 // the same relative order.
 
 // Equal-to operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() == b.index()) &&
          variant_internal::VisitIndices<sizeof...(Types)>::Run(
              variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
 }
 
 // Not equal operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index()) ||
          variant_internal::VisitIndices<sizeof...(Types)>::Run(
              variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
 }
 
 // Less-than operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) < (b.index() + 1)
              : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
 }
 
 // Greater-than operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) > (b.index() + 1)
              : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::GreaterThanOp<Types...>{&a, &b},
                    a.index());
 }
 
 // Less-than or equal-to operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) < (b.index() + 1)
              : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
                    a.index());
 }
 
 // Greater-than or equal-to operator
 template <typename... Types>
 constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
 operator>=(const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) > (b.index() + 1)
              : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
                    a.index());
 }
 
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 namespace std {
 
 // hash()
 template <>  // NOLINT
 struct hash<absl::monostate> {
   std::size_t operator()(absl::monostate) const { return 0; }
 };
 
 template <class... T>  // NOLINT
 struct hash<absl::variant<T...>>
     : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
                                               absl::remove_const_t<T>...> {};
 
 }  // namespace std
 
 #endif  // ABSL_USES_STD_VARIANT
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace variant_internal {
 
 // Helper visitor for converting a variant<Ts...>` into another type (mostly
 // variant) that can be constructed from any type.
 template <typename To>
 struct ConversionVisitor {
   template <typename T>
   To operator()(T&& v) const {
     return To(std::forward<T>(v));
   }
 };
 
 }  // namespace variant_internal
 
 // ConvertVariantTo()
 //
 // Helper functions to convert an `absl::variant` to a variant of another set of
 // types, provided that the alternative type of the new variant type can be
 // converted from any type in the source variant.
 //
 // Example:
 //
 //   absl::variant<name1, name2, float> InternalReq(const Req&);
 //
 //   // name1 and name2 are convertible to name
 //   absl::variant<name, float> ExternalReq(const Req& req) {
 //     return absl::ConvertVariantTo<absl::variant<name, float>>(
 //              InternalReq(req));
 //   }
 template <typename To, typename Variant>
 To ConvertVariantTo(Variant&& variant) {
   return absl::visit(variant_internal::ConversionVisitor<To>{},
                      std::forward<Variant>(variant));
 }
 
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_VARIANT_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team