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

File indexing completed on 2025-12-16 09:41:08

 // 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.
 //
 // Implementation details of absl/types/variant.h, pulled into a
 // separate file to avoid cluttering the top of the API header with
 // implementation details.
 
 #ifndef ABSL_TYPES_INTERNAL_VARIANT_H_
 #define ABSL_TYPES_INTERNAL_VARIANT_H_
 
 #include <cassert>
 #include <cstddef>
 #include <cstdlib>
 #include <memory>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
 #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"
 
 #if !defined(ABSL_USES_STD_VARIANT)
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 template <class... Types>
 class variant;
 
 ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
 
 template <class T>
 struct variant_size;
 
 template <std::size_t I, class T>
 struct variant_alternative;
 
 namespace variant_internal {
 
 // NOTE: See specializations below for details.
 template <std::size_t I, class T>
 struct VariantAlternativeSfinae {};
 
 // Requires: I < variant_size_v<T>.
 //
 // Value: The Ith type of Types...
 template <std::size_t I, class T0, class... Tn>
 struct VariantAlternativeSfinae<I, variant<T0, Tn...>>
     : VariantAlternativeSfinae<I - 1, variant<Tn...>> {};
 
 // Value: T0
 template <class T0, class... Ts>
 struct VariantAlternativeSfinae<0, variant<T0, Ts...>> {
   using type = T0;
 };
 
 template <std::size_t I, class T>
 using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
 
 // NOTE: Requires T to be a reference type.
 template <class T, class U>
 struct GiveQualsTo;
 
 template <class T, class U>
 struct GiveQualsTo<T&, U> {
   using type = U&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<T&&, U> {
   using type = U&&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<const T&, U> {
   using type = const U&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<const T&&, U> {
   using type = const U&&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<volatile T&, U> {
   using type = volatile U&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<volatile T&&, U> {
   using type = volatile U&&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<volatile const T&, U> {
   using type = volatile const U&;
 };
 
 template <class T, class U>
 struct GiveQualsTo<volatile const T&&, U> {
   using type = volatile const U&&;
 };
 
 template <class T, class U>
 using GiveQualsToT = typename GiveQualsTo<T, U>::type;
 
 // Convenience alias, since size_t integral_constant is used a lot in this file.
 template <std::size_t I>
 using SizeT = std::integral_constant<std::size_t, I>;
 
 using NPos = SizeT<variant_npos>;
 
 template <class Variant, class T, class = void>
 struct IndexOfConstructedType {};
 
 template <std::size_t I, class Variant>
 struct VariantAccessResultImpl;
 
 template <std::size_t I, template <class...> class Variantemplate, class... T>
 struct VariantAccessResultImpl<I, Variantemplate<T...>&> {
   using type = typename absl::variant_alternative<I, variant<T...>>::type&;
 };
 
 template <std::size_t I, template <class...> class Variantemplate, class... T>
 struct VariantAccessResultImpl<I, const Variantemplate<T...>&> {
   using type =
       const typename absl::variant_alternative<I, variant<T...>>::type&;
 };
 
 template <std::size_t I, template <class...> class Variantemplate, class... T>
 struct VariantAccessResultImpl<I, Variantemplate<T...>&&> {
   using type = typename absl::variant_alternative<I, variant<T...>>::type&&;
 };
 
 template <std::size_t I, template <class...> class Variantemplate, class... T>
 struct VariantAccessResultImpl<I, const Variantemplate<T...>&&> {
   using type =
       const typename absl::variant_alternative<I, variant<T...>>::type&&;
 };
 
 template <std::size_t I, class Variant>
 using VariantAccessResult =
     typename VariantAccessResultImpl<I, Variant&&>::type;
 
 // NOTE: This is used instead of std::array to reduce instantiation overhead.
 template <class T, std::size_t Size>
 struct SimpleArray {
   static_assert(Size != 0, "");
   T value[Size];
 };
 
 template <class T>
 struct AccessedType {
   using type = T;
 };
 
 template <class T>
 using AccessedTypeT = typename AccessedType<T>::type;
 
 template <class T, std::size_t Size>
 struct AccessedType<SimpleArray<T, Size>> {
   using type = AccessedTypeT<T>;
 };
 
 template <class T>
 constexpr T AccessSimpleArray(const T& value) {
   return value;
 }
 
 template <class T, std::size_t Size, class... SizeT>
 constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size>& table,
                                              std::size_t head_index,
                                              SizeT... tail_indices) {
   return AccessSimpleArray(table.value[head_index], tail_indices...);
 }
 
 // Note: Intentionally is an alias.
 template <class T>
 using AlwaysZero = SizeT<0>;
 
 template <class Op, class... Vs>
 struct VisitIndicesResultImpl {
   using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
 };
 
 template <class Op, class... Vs>
 using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
 
 template <class ReturnType, class FunctionObject, class EndIndices,
           class BoundIndices>
 struct MakeVisitationMatrix;
 
 template <class ReturnType, class FunctionObject, std::size_t... Indices>
 constexpr ReturnType call_with_indices(FunctionObject&& function) {
   static_assert(
       std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(
                                    SizeT<Indices>()...))>::value,
       "Not all visitation overloads have the same return type.");
   return std::forward<FunctionObject>(function)(SizeT<Indices>()...);
 }
 
 template <class ReturnType, class FunctionObject, std::size_t... BoundIndices>
 struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
                             index_sequence<BoundIndices...>> {
   using ResultType = ReturnType (*)(FunctionObject&&);
   static constexpr ResultType Run() {
     return &call_with_indices<ReturnType, FunctionObject,
                               (BoundIndices - 1)...>;
   }
 };
 
 template <typename Is, std::size_t J>
 struct AppendToIndexSequence;
 
 template <typename Is, std::size_t J>
 using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type;
 
 template <std::size_t... Is, std::size_t J>
 struct AppendToIndexSequence<index_sequence<Is...>, J> {
   using type = index_sequence<Is..., J>;
 };
 
 template <class ReturnType, class FunctionObject, class EndIndices,
           class CurrIndices, class BoundIndices>
 struct MakeVisitationMatrixImpl;
 
 template <class ReturnType, class FunctionObject, class EndIndices,
           std::size_t... CurrIndices, class BoundIndices>
 struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
                                 index_sequence<CurrIndices...>, BoundIndices> {
   using ResultType = SimpleArray<
       typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices,
                                     index_sequence<>>::ResultType,
       sizeof...(CurrIndices)>;
 
   static constexpr ResultType Run() {
     return {{MakeVisitationMatrix<
         ReturnType, FunctionObject, EndIndices,
         AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}};
   }
 };
 
 template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex,
           std::size_t... TailEndIndices, std::size_t... BoundIndices>
 struct MakeVisitationMatrix<ReturnType, FunctionObject,
                             index_sequence<HeadEndIndex, TailEndIndices...>,
                             index_sequence<BoundIndices...>>
     : MakeVisitationMatrixImpl<ReturnType, FunctionObject,
                                index_sequence<TailEndIndices...>,
                                absl::make_index_sequence<HeadEndIndex>,
                                index_sequence<BoundIndices...>> {};
 
 struct UnreachableSwitchCase {
   template <class Op>
   [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
       Op&& /*ignored*/) {
     ABSL_UNREACHABLE();
   }
 };
 
 template <class Op, std::size_t I>
 struct ReachableSwitchCase {
   static VisitIndicesResultT<Op, std::size_t> Run(Op&& op) {
     return absl::base_internal::invoke(std::forward<Op>(op), SizeT<I>());
   }
 };
 
 // The number 33 is just a guess at a reasonable maximum to our switch. It is
 // not based on any analysis. The reason it is a power of 2 plus 1 instead of a
 // power of 2 is because the number was picked to correspond to a power of 2
 // amount of "normal" alternatives, plus one for the possibility of the user
 // providing "monostate" in addition to the more natural alternatives.
 ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
 
 // Note: The default-definition is for unreachable cases.
 template <bool IsReachable>
 struct PickCaseImpl {
   template <class Op, std::size_t I>
   using Apply = UnreachableSwitchCase;
 };
 
 template <>
 struct PickCaseImpl</*IsReachable =*/true> {
   template <class Op, std::size_t I>
   using Apply = ReachableSwitchCase<Op, I>;
 };
 
 // Note: This form of dance with template aliases is to make sure that we
 //       instantiate a number of templates proportional to the number of variant
 //       alternatives rather than a number of templates proportional to our
 //       maximum unrolled amount of visitation cases (aliases are effectively
 //       "free" whereas other template instantiations are costly).
 template <class Op, std::size_t I, std::size_t EndIndex>
 using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
 
 template <class ReturnType>
 [[noreturn]] ReturnType TypedThrowBadVariantAccess() {
   absl::variant_internal::ThrowBadVariantAccess();
 }
 
 // Given N variant sizes, determine the number of cases there would need to be
 // in a single switch-statement that would cover every possibility in the
 // corresponding N-ary visit operation.
 template <std::size_t... NumAlternatives>
 struct NumCasesOfSwitch;
 
 template <std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
 struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...> {
   static constexpr std::size_t value =
       (HeadNumAlternatives + 1) *
       NumCasesOfSwitch<TailNumAlternatives...>::value;
 };
 
 template <>
 struct NumCasesOfSwitch<> {
   static constexpr std::size_t value = 1;
 };
 
 // A switch statement optimizes better than the table of function pointers.
 template <std::size_t EndIndex>
 struct VisitIndicesSwitch {
   static_assert(EndIndex <= MaxUnrolledVisitCases,
                 "Maximum unrolled switch size exceeded.");
 
   template <class Op>
   static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i) {
     switch (i) {
       case 0:
         return PickCase<Op, 0, EndIndex>::Run(std::forward<Op>(op));
       case 1:
         return PickCase<Op, 1, EndIndex>::Run(std::forward<Op>(op));
       case 2:
         return PickCase<Op, 2, EndIndex>::Run(std::forward<Op>(op));
       case 3:
         return PickCase<Op, 3, EndIndex>::Run(std::forward<Op>(op));
       case 4:
         return PickCase<Op, 4, EndIndex>::Run(std::forward<Op>(op));
       case 5:
         return PickCase<Op, 5, EndIndex>::Run(std::forward<Op>(op));
       case 6:
         return PickCase<Op, 6, EndIndex>::Run(std::forward<Op>(op));
       case 7:
         return PickCase<Op, 7, EndIndex>::Run(std::forward<Op>(op));
       case 8:
         return PickCase<Op, 8, EndIndex>::Run(std::forward<Op>(op));
       case 9:
         return PickCase<Op, 9, EndIndex>::Run(std::forward<Op>(op));
       case 10:
         return PickCase<Op, 10, EndIndex>::Run(std::forward<Op>(op));
       case 11:
         return PickCase<Op, 11, EndIndex>::Run(std::forward<Op>(op));
       case 12:
         return PickCase<Op, 12, EndIndex>::Run(std::forward<Op>(op));
       case 13:
         return PickCase<Op, 13, EndIndex>::Run(std::forward<Op>(op));
       case 14:
         return PickCase<Op, 14, EndIndex>::Run(std::forward<Op>(op));
       case 15:
         return PickCase<Op, 15, EndIndex>::Run(std::forward<Op>(op));
       case 16:
         return PickCase<Op, 16, EndIndex>::Run(std::forward<Op>(op));
       case 17:
         return PickCase<Op, 17, EndIndex>::Run(std::forward<Op>(op));
       case 18:
         return PickCase<Op, 18, EndIndex>::Run(std::forward<Op>(op));
       case 19:
         return PickCase<Op, 19, EndIndex>::Run(std::forward<Op>(op));
       case 20:
         return PickCase<Op, 20, EndIndex>::Run(std::forward<Op>(op));
       case 21:
         return PickCase<Op, 21, EndIndex>::Run(std::forward<Op>(op));
       case 22:
         return PickCase<Op, 22, EndIndex>::Run(std::forward<Op>(op));
       case 23:
         return PickCase<Op, 23, EndIndex>::Run(std::forward<Op>(op));
       case 24:
         return PickCase<Op, 24, EndIndex>::Run(std::forward<Op>(op));
       case 25:
         return PickCase<Op, 25, EndIndex>::Run(std::forward<Op>(op));
       case 26:
         return PickCase<Op, 26, EndIndex>::Run(std::forward<Op>(op));
       case 27:
         return PickCase<Op, 27, EndIndex>::Run(std::forward<Op>(op));
       case 28:
         return PickCase<Op, 28, EndIndex>::Run(std::forward<Op>(op));
       case 29:
         return PickCase<Op, 29, EndIndex>::Run(std::forward<Op>(op));
       case 30:
         return PickCase<Op, 30, EndIndex>::Run(std::forward<Op>(op));
       case 31:
         return PickCase<Op, 31, EndIndex>::Run(std::forward<Op>(op));
       case 32:
         return PickCase<Op, 32, EndIndex>::Run(std::forward<Op>(op));
       default:
         ABSL_ASSERT(i == variant_npos);
         return absl::base_internal::invoke(std::forward<Op>(op), NPos());
     }
   }
 };
 
 template <std::size_t... EndIndices>
 struct VisitIndicesFallback {
   template <class Op, class... SizeT>
   static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) {
     return AccessSimpleArray(
         MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
                              index_sequence<(EndIndices + 1)...>,
                              index_sequence<>>::Run(),
         (indices + 1)...)(std::forward<Op>(op));
   }
 };
 
 // Take an N-dimensional series of indices and convert them into a single index
 // without loss of information. The purpose of this is to be able to convert an
 // N-ary visit operation into a single switch statement.
 template <std::size_t...>
 struct FlattenIndices;
 
 template <std::size_t HeadSize, std::size_t... TailSize>
 struct FlattenIndices<HeadSize, TailSize...> {
   template <class... SizeType>
   static constexpr std::size_t Run(std::size_t head, SizeType... tail) {
     return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
   }
 };
 
 template <>
 struct FlattenIndices<> {
   static constexpr std::size_t Run() { return 0; }
 };
 
 // Take a single "flattened" index (flattened by FlattenIndices) and determine
 // the value of the index of one of the logically represented dimensions.
 template <std::size_t I, std::size_t IndexToGet, std::size_t HeadSize,
           std::size_t... TailSize>
 struct UnflattenIndex {
   static constexpr std::size_t value =
       UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
 };
 
 template <std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
 struct UnflattenIndex<I, 0, HeadSize, TailSize...> {
   static constexpr std::size_t value = (I % HeadSize);
 };
 
 // The backend for converting an N-ary visit operation into a unary visit.
 template <class IndexSequence, std::size_t... EndIndices>
 struct VisitIndicesVariadicImpl;
 
 template <std::size_t... N, std::size_t... EndIndices>
 struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...> {
   // A type that can take an N-ary function object and converts it to a unary
   // function object that takes a single, flattened index, and "unflattens" it
   // into its individual dimensions when forwarding to the wrapped object.
   template <class Op>
   struct FlattenedOp {
     template <std::size_t I>
     VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
         SizeT<I> /*index*/) && {
       return base_internal::invoke(
           std::forward<Op>(op),
           SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
                 std::size_t{1}>()...);
     }
 
     Op&& op;
   };
 
   template <class Op, class... SizeType>
   static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(Op&& op,
                                                               SizeType... i) {
     return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
         FlattenedOp<Op>{std::forward<Op>(op)},
         FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
             (i + std::size_t{1})...));
   }
 };
 
 template <std::size_t... EndIndices>
 struct VisitIndicesVariadic
     : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>,
                                EndIndices...> {};
 
 // This implementation will flatten N-ary visit operations into a single switch
 // statement when the number of cases would be less than our maximum specified
 // switch-statement size.
 // TODO(calabrese)
 //   Based on benchmarks, determine whether the function table approach actually
 //   does optimize better than a chain of switch statements and possibly update
 //   the implementation accordingly. Also consider increasing the maximum switch
 //   size.
 template <std::size_t... EndIndices>
 struct VisitIndices
     : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <=
                            MaxUnrolledVisitCases),
                           VisitIndicesVariadic<EndIndices...>,
                           VisitIndicesFallback<EndIndices...>> {};
 
 template <std::size_t EndIndex>
 struct VisitIndices<EndIndex>
     : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases),
                           VisitIndicesSwitch<EndIndex>,
                           VisitIndicesFallback<EndIndex>> {};
 
 // Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
 // below is returning the address of a temporary or local object.
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4172)
 #endif  // _MSC_VER
 
 // TODO(calabrese) std::launder
 // TODO(calabrese) constexpr
 // NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
 // MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
 template <class Self, std::size_t I>
 inline VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
   return reinterpret_cast<VariantAccessResult<I, Self>>(self);
 }
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
 template <class T>
 void DeducedDestroy(T& self) {  // NOLINT
   self.~T();
 }
 
 // NOTE: This type exists as a single entity for variant and its bases to
 // befriend. It contains helper functionality that manipulates the state of the
 // variant, such as the implementation of things like assignment and emplace
 // operations.
 struct VariantCoreAccess {
   template <class VariantType>
   static typename VariantType::Variant& Derived(VariantType& self) {  // NOLINT
     return static_cast<typename VariantType::Variant&>(self);
   }
 
   template <class VariantType>
   static const typename VariantType::Variant& Derived(
       const VariantType& self) {  // NOLINT
     return static_cast<const typename VariantType::Variant&>(self);
   }
 
   template <class VariantType>
   static void Destroy(VariantType& self) {  // NOLINT
     Derived(self).destroy();
     self.index_ = absl::variant_npos;
   }
 
   template <class Variant>
   static void SetIndex(Variant& self, std::size_t i) {  // NOLINT
     self.index_ = i;
   }
 
   template <class Variant>
   static void InitFrom(Variant& self, Variant&& other) {  // NOLINT
     VisitIndices<absl::variant_size<Variant>::value>::Run(
         InitFromVisitor<Variant, Variant&&>{&self,
                                             std::forward<Variant>(other)},
         other.index());
     self.index_ = other.index();
   }
 
   // Access a variant alternative, assuming the index is correct.
   template <std::size_t I, class Variant>
   static VariantAccessResult<I, Variant> Access(Variant&& self) {
     // This cast instead of invocation of AccessUnion with an rvalue is a
     // workaround for msvc. Without this there is a runtime failure when dealing
     // with rvalues.
     // TODO(calabrese) Reduce test case and find a simpler workaround.
     return static_cast<VariantAccessResult<I, Variant>>(
         variant_internal::AccessUnion(self.state_, SizeT<I>()));
   }
 
   // Access a variant alternative, throwing if the index is incorrect.
   template <std::size_t I, class Variant>
   static VariantAccessResult<I, Variant> CheckedAccess(Variant&& self) {
     if (ABSL_PREDICT_FALSE(self.index_ != I)) {
       TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
     }
 
     return Access<I>(std::forward<Variant>(self));
   }
 
   // The implementation of the move-assignment operation for a variant.
   template <class VType>
   struct MoveAssignVisitor {
     using DerivedType = typename VType::Variant;
     template <std::size_t NewIndex>
     void operator()(SizeT<NewIndex> /*new_i*/) const {
       if (left->index_ == NewIndex) {
         Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
       } else {
         Derived(*left).template emplace<NewIndex>(
             std::move(Access<NewIndex>(*right)));
       }
     }
 
     void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
       Destroy(*left);
     }
 
     VType* left;
     VType* right;
   };
 
   template <class VType>
   static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType* left,
                                                         VType* other) {
     return {left, other};
   }
 
   // The implementation of the assignment operation for a variant.
   template <class VType>
   struct CopyAssignVisitor {
     using DerivedType = typename VType::Variant;
     template <std::size_t NewIndex>
     void operator()(SizeT<NewIndex> /*new_i*/) const {
       using New =
           typename absl::variant_alternative<NewIndex, DerivedType>::type;
 
       if (left->index_ == NewIndex) {
         Access<NewIndex>(*left) = Access<NewIndex>(*right);
       } else if (std::is_nothrow_copy_constructible<New>::value ||
                  !std::is_nothrow_move_constructible<New>::value) {
         Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
       } else {
         Derived(*left) = DerivedType(Derived(*right));
       }
     }
 
     void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
       Destroy(*left);
     }
 
     VType* left;
     const VType* right;
   };
 
   template <class VType>
   static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType* left,
                                                         const VType& other) {
     return {left, &other};
   }
 
   // The implementation of conversion-assignment operations for variant.
   template <class Left, class QualifiedNew>
   struct ConversionAssignVisitor {
     using NewIndex =
         variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
 
     void operator()(SizeT<NewIndex::value> /*old_i*/
     ) const {
       Access<NewIndex::value>(*left) = std::forward<QualifiedNew>(other);
     }
 
     template <std::size_t OldIndex>
     void operator()(SizeT<OldIndex> /*old_i*/
     ) const {
       using New =
           typename absl::variant_alternative<NewIndex::value, Left>::type;
       if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
           !std::is_nothrow_move_constructible<New>::value) {
         left->template emplace<NewIndex::value>(
             std::forward<QualifiedNew>(other));
       } else {
         // the standard says "equivalent to
         // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
         // because the variant's move assignment operator could be deleted.
         left->template emplace<NewIndex::value>(
             New(std::forward<QualifiedNew>(other)));
       }
     }
 
     Left* left;
     QualifiedNew&& other;
   };
 
   template <class Left, class QualifiedNew>
   static ConversionAssignVisitor<Left, QualifiedNew>
   MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual) {
     return {left, std::forward<QualifiedNew>(qual)};
   }
 
   // Backend for operations for `emplace()` which destructs `*self` then
   // construct a new alternative with `Args...`.
   template <std::size_t NewIndex, class Self, class... Args>
   static typename absl::variant_alternative<NewIndex, Self>::type& Replace(
       Self* self, Args&&... args) {
     Destroy(*self);
     using New = typename absl::variant_alternative<NewIndex, Self>::type;
     New* const result = ::new (static_cast<void*>(&self->state_))
         New(std::forward<Args>(args)...);
     self->index_ = NewIndex;
     return *result;
   }
 
   template <class LeftVariant, class QualifiedRightVariant>
   struct InitFromVisitor {
     template <std::size_t NewIndex>
     void operator()(SizeT<NewIndex> /*new_i*/) const {
       using Alternative =
           typename variant_alternative<NewIndex, LeftVariant>::type;
       ::new (static_cast<void*>(&left->state_)) Alternative(
           Access<NewIndex>(std::forward<QualifiedRightVariant>(right)));
     }
 
     void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
       // This space intentionally left blank.
     }
     LeftVariant* left;
     QualifiedRightVariant&& right;
   };
 };
 
 template <class Expected, class... T>
 struct IndexOfImpl;
 
 template <class Expected>
 struct IndexOfImpl<Expected> {
   using IndexFromEnd = SizeT<0>;
   using MatchedIndexFromEnd = IndexFromEnd;
   using MultipleMatches = std::false_type;
 };
 
 template <class Expected, class Head, class... Tail>
 struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...> {
   using IndexFromEnd =
       SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
 };
 
 template <class Expected, class... Tail>
 struct IndexOfImpl<Expected, Expected, Tail...>
     : IndexOfImpl<Expected, Tail...> {
   using IndexFromEnd =
       SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
   using MatchedIndexFromEnd = IndexFromEnd;
   using MultipleMatches = std::integral_constant<
       bool, IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
 };
 
 template <class Expected, class... Types>
 struct IndexOfMeta {
   using Results = IndexOfImpl<Expected, Types...>;
   static_assert(!Results::MultipleMatches::value,
                 "Attempted to access a variant by specifying a type that "
                 "matches more than one alternative.");
   static_assert(Results::MatchedIndexFromEnd::value != 0,
                 "Attempted to access a variant by specifying a type that does "
                 "not match any alternative.");
   using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
 };
 
 template <class Expected, class... Types>
 using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
 
 template <class Variant, class T, std::size_t CurrIndex>
 struct UnambiguousIndexOfImpl;
 
 // Terminating case encountered once we've checked all of the alternatives
 template <class T, std::size_t CurrIndex>
 struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex> {};
 
 // Case where T is not Head
 template <class Head, class... Tail, class T, std::size_t CurrIndex>
 struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex>
     : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type {};
 
 // Case where T is Head
 template <class Head, class... Tail, std::size_t CurrIndex>
 struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex>
     : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value ==
                     sizeof...(Tail)
                 ? CurrIndex
                 : CurrIndex + sizeof...(Tail) + 1> {};
 
 template <class Variant, class T>
 struct UnambiguousIndexOf;
 
 struct NoMatch {
   struct type {};
 };
 
 template <class... Alts, class T>
 struct UnambiguousIndexOf<variant<Alts...>, T>
     : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value !=
                            sizeof...(Alts),
                        UnambiguousIndexOfImpl<variant<Alts...>, T, 0>,
                        NoMatch>::type::type {};
 
 template <class T, std::size_t /*Dummy*/>
 using UnambiguousTypeOfImpl = T;
 
 template <class Variant, class T>
 using UnambiguousTypeOfT =
     UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
 
 template <class H, class... T>
 class VariantStateBase;
 
 // This is an implementation of the "imaginary function" that is described in
 // [variant.ctor]
 // It is used in order to determine which alternative to construct during
 // initialization from some type T.
 template <class Variant, std::size_t I = 0>
 struct ImaginaryFun;
 
 template <std::size_t I>
 struct ImaginaryFun<variant<>, I> {
   static void Run() = delete;
 };
 
 template <class H, class... T, std::size_t I>
 struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1> {
   using ImaginaryFun<variant<T...>, I + 1>::Run;
 
   // NOTE: const& and && are used instead of by-value due to lack of guaranteed
   // move elision of C++17. This may have other minor differences, but tests
   // pass.
   static SizeT<I> Run(const H&, SizeT<I>);
   static SizeT<I> Run(H&&, SizeT<I>);
 };
 
 // The following metafunctions are used in constructor and assignment
 // constraints.
 template <class Self, class T>
 struct IsNeitherSelfNorInPlace : std::true_type {};
 
 template <class Self>
 struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type {};
 
 template <class Self, class T>
 struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type {};
 
 template <class Self, std::size_t I>
 struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type {};
 
 template <class Variant, class T>
 struct IndexOfConstructedType<
     Variant, T,
     void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
     : decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {})) {};
 
 template <std::size_t... Is>
 struct ContainsVariantNPos
     : absl::negation<std::is_same<  // NOLINT
           std::integer_sequence<bool, 0 <= Is...>,
           std::integer_sequence<bool, Is != absl::variant_npos...>>> {};
 
 template <class Op, class... QualifiedVariants>
 using RawVisitResult =
     absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
 
 // NOTE: The spec requires that all return-paths yield the same type and is not
 // SFINAE-friendly, so we can deduce the return type by examining the first
 // result. If it's not callable, then we get an error, but are compliant and
 // fast to compile.
 // TODO(calabrese) Possibly rewrite in a way that yields better compile errors
 // at the cost of longer compile-times.
 template <class Op, class... QualifiedVariants>
 struct VisitResultImpl {
   using type =
       absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
 };
 
 // Done in two steps intentionally so that we don't cause substitution to fail.
 template <class Op, class... QualifiedVariants>
 using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
 
 template <class Op, class... QualifiedVariants>
 struct PerformVisitation {
   using ReturnType = VisitResult<Op, QualifiedVariants...>;
 
   template <std::size_t... Is>
   constexpr ReturnType operator()(SizeT<Is>... indices) const {
     return Run(typename ContainsVariantNPos<Is...>::type{},
                absl::index_sequence_for<QualifiedVariants...>(), indices...);
   }
 
   template <std::size_t... TupIs, std::size_t... Is>
   constexpr ReturnType Run(std::false_type /*has_valueless*/,
                            index_sequence<TupIs...>, SizeT<Is>...) const {
     static_assert(
         std::is_same<ReturnType,
                      absl::result_of_t<Op(VariantAccessResult<
                                           Is, QualifiedVariants>...)>>::value,
         "All visitation overloads must have the same return type.");
     return absl::base_internal::invoke(
         std::forward<Op>(op),
         VariantCoreAccess::Access<Is>(
             std::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
   }
 
   template <std::size_t... TupIs, std::size_t... Is>
   [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/,
                               index_sequence<TupIs...>, SizeT<Is>...) const {
     absl::variant_internal::ThrowBadVariantAccess();
   }
 
   // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
   // Attempts using lambda variadic captures fail on current GCC.
   std::tuple<QualifiedVariants&&...> variant_tup;
   Op&& op;
 };
 
 template <class... T>
 union Union;
 
 // We want to allow for variant<> to be trivial. For that, we need the default
 // constructor to be trivial, which means we can't define it ourselves.
 // Instead, we use a non-default constructor that takes NoopConstructorTag
 // that doesn't affect the triviality of the types.
 struct NoopConstructorTag {};
 
 template <std::size_t I>
 struct EmplaceTag {};
 
 template <>
 union Union<> {
   constexpr explicit Union(NoopConstructorTag) noexcept {}
 };
 
 // Suppress bogus warning on MSVC: MSVC complains that Union<T...> has a defined
 // deleted destructor from the `std::is_destructible` check below.
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4624)
 #endif  // _MSC_VER
 
 template <class Head, class... Tail>
 union Union<Head, Tail...> {
   using TailUnion = Union<Tail...>;
 
   explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
       : tail(NoopConstructorTag()) {}
 
   template <class... P>
   explicit constexpr Union(EmplaceTag<0>, P&&... args)
       : head(std::forward<P>(args)...) {}
 
   template <std::size_t I, class... P>
   explicit constexpr Union(EmplaceTag<I>, P&&... args)
       : tail(EmplaceTag<I - 1>{}, std::forward<P>(args)...) {}
 
   Head head;
   TailUnion tail;
 };
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
 // TODO(calabrese) Just contain a Union in this union (certain configs fail).
 template <class... T>
 union DestructibleUnionImpl;
 
 template <>
 union DestructibleUnionImpl<> {
   constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept {}
 };
 
 template <class Head, class... Tail>
 union DestructibleUnionImpl<Head, Tail...> {
   using TailUnion = DestructibleUnionImpl<Tail...>;
 
   explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
       : tail(NoopConstructorTag()) {}
 
   template <class... P>
   explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args)
       : head(std::forward<P>(args)...) {}
 
   template <std::size_t I, class... P>
   explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args)
       : tail(EmplaceTag<I - 1>{}, std::forward<P>(args)...) {}
 
   ~DestructibleUnionImpl() {}
 
   Head head;
   TailUnion tail;
 };
 
 // This union type is destructible even if one or more T are not trivially
 // destructible. In the case that all T are trivially destructible, then so is
 // this resultant type.
 template <class... T>
 using DestructibleUnion =
     absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>,
                         DestructibleUnionImpl<T...>>;
 
 // Deepest base, containing the actual union and the discriminator
 template <class H, class... T>
 class VariantStateBase {
  protected:
   using Variant = variant<H, T...>;
 
   template <class LazyH = H,
             class ConstructibleH = absl::enable_if_t<
                 std::is_default_constructible<LazyH>::value, LazyH>>
   constexpr VariantStateBase() noexcept(
       std::is_nothrow_default_constructible<ConstructibleH>::value)
       : state_(EmplaceTag<0>()), index_(0) {}
 
   template <std::size_t I, class... P>
   explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args)
       : state_(tag, std::forward<P>(args)...), index_(I) {}
 
   explicit constexpr VariantStateBase(NoopConstructorTag)
       : state_(NoopConstructorTag()), index_(variant_npos) {}
 
   void destroy() {}  // Does nothing (shadowed in child if non-trivial)
 
   DestructibleUnion<H, T...> state_;
   std::size_t index_;
 };
 
 using absl::internal::type_identity;
 
 // OverloadSet::Overload() is a unary function which is overloaded to
 // take any of the element types of the variant, by reference-to-const.
 // The return type of the overload on T is type_identity<T>, so that you
 // can statically determine which overload was called.
 //
 // Overload() is not defined, so it can only be called in unevaluated
 // contexts.
 template <typename... Ts>
 struct OverloadSet;
 
 template <typename T, typename... Ts>
 struct OverloadSet<T, Ts...> : OverloadSet<Ts...> {
   using Base = OverloadSet<Ts...>;
   static type_identity<T> Overload(const T&);
   using Base::Overload;
 };
 
 template <>
 struct OverloadSet<> {
   // For any case not handled above.
   static void Overload(...);
 };
 
 template <class T>
 using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
 
 template <class T>
 using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
 
 template <class T>
 using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
 
 template <class T>
 using GreaterThanOrEqualResult =
     decltype(std::declval<T>() >= std::declval<T>());
 
 template <class T>
 using EqualResult = decltype(std::declval<T>() == std::declval<T>());
 
 template <class T>
 using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
 
 using type_traits_internal::is_detected_convertible;
 
 template <class... T>
 using RequireAllHaveEqualT = absl::enable_if_t<
     absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
     bool>;
 
 template <class... T>
 using RequireAllHaveNotEqualT =
     absl::enable_if_t<absl::conjunction<is_detected_convertible<
                           bool, NotEqualResult, T>...>::value,
                       bool>;
 
 template <class... T>
 using RequireAllHaveLessThanT =
     absl::enable_if_t<absl::conjunction<is_detected_convertible<
                           bool, LessThanResult, T>...>::value,
                       bool>;
 
 template <class... T>
 using RequireAllHaveLessThanOrEqualT =
     absl::enable_if_t<absl::conjunction<is_detected_convertible<
                           bool, LessThanOrEqualResult, T>...>::value,
                       bool>;
 
 template <class... T>
 using RequireAllHaveGreaterThanOrEqualT =
     absl::enable_if_t<absl::conjunction<is_detected_convertible<
                           bool, GreaterThanOrEqualResult, T>...>::value,
                       bool>;
 
 template <class... T>
 using RequireAllHaveGreaterThanT =
     absl::enable_if_t<absl::conjunction<is_detected_convertible<
                           bool, GreaterThanResult, T>...>::value,
                       bool>;
 
 // Helper template containing implementations details of variant that can't go
 // in the private section. For convenience, this takes the variant type as a
 // single template parameter.
 template <typename T>
 struct VariantHelper;
 
 template <typename... Ts>
 struct VariantHelper<variant<Ts...>> {
   // Type metafunction which returns the element type selected if
   // OverloadSet::Overload() is well-formed when called with argument type U.
   template <typename U>
   using BestMatch = decltype(variant_internal::OverloadSet<Ts...>::Overload(
       std::declval<U>()));
 
   // Type metafunction which returns true if OverloadSet::Overload() is
   // well-formed when called with argument type U.
   // CanAccept can't be just an alias because there is a MSVC bug on parameter
   // pack expansion involving decltype.
   template <typename U>
   struct CanAccept
       : std::integral_constant<bool, !std::is_void<BestMatch<U>>::value> {};
 
   // Type metafunction which returns true if Other is an instantiation of
   // variant, and variants's converting constructor from Other will be
   // well-formed. We will use this to remove constructors that would be
   // ill-formed from the overload set.
   template <typename Other>
   struct CanConvertFrom;
 
   template <typename... Us>
   struct CanConvertFrom<variant<Us...>>
       : public absl::conjunction<CanAccept<Us>...> {};
 };
 
 // A type with nontrivial copy ctor and trivial move ctor.
 struct TrivialMoveOnly {
   TrivialMoveOnly(TrivialMoveOnly&&) = default;
 };
 
 // Trait class to detect whether a type is trivially move constructible.
 // A union's defaulted copy/move constructor is deleted if any variant member's
 // copy/move constructor is nontrivial.
 template <typename T>
 struct IsTriviallyMoveConstructible
     : std::is_move_constructible<Union<T, TrivialMoveOnly>> {};
 
 // To guarantee triviality of all special-member functions that can be trivial,
 // we use a chain of conditional bases for each one.
 // The order of inheritance of bases from child to base are logically:
 //
 // variant
 // VariantCopyAssignBase
 // VariantMoveAssignBase
 // VariantCopyBase
 // VariantMoveBase
 // VariantStateBaseDestructor
 // VariantStateBase
 //
 // Note that there is a separate branch at each base that is dependent on
 // whether or not that corresponding special-member-function can be trivial in
 // the resultant variant type.
 
 template <class... T>
 class VariantStateBaseDestructorNontrivial;
 
 template <class... T>
 class VariantMoveBaseNontrivial;
 
 template <class... T>
 class VariantCopyBaseNontrivial;
 
 template <class... T>
 class VariantMoveAssignBaseNontrivial;
 
 template <class... T>
 class VariantCopyAssignBaseNontrivial;
 
 // Base that is dependent on whether or not the destructor can be trivial.
 template <class... T>
 using VariantStateBaseDestructor =
     absl::conditional_t<std::is_destructible<Union<T...>>::value,
                         VariantStateBase<T...>,
                         VariantStateBaseDestructorNontrivial<T...>>;
 
 // Base that is dependent on whether or not the move-constructor can be
 // implicitly generated by the compiler (trivial or deleted).
 // Previously we were using `std::is_move_constructible<Union<T...>>` to check
 // whether all Ts have trivial move constructor, but it ran into a GCC bug:
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
 // So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
 // work around the bug.
 template <class... T>
 using VariantMoveBase = absl::conditional_t<
     absl::disjunction<
         absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
         absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
     VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>;
 
 // Base that is dependent on whether or not the copy-constructor can be trivial.
 template <class... T>
 using VariantCopyBase = absl::conditional_t<
     absl::disjunction<
         absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
         std::is_copy_constructible<Union<T...>>>::value,
     VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>;
 
 // Base that is dependent on whether or not the move-assign can be trivial.
 template <class... T>
 using VariantMoveAssignBase = absl::conditional_t<
     absl::disjunction<
         absl::conjunction<absl::is_move_assignable<Union<T...>>,
                           std::is_move_constructible<Union<T...>>,
                           std::is_destructible<Union<T...>>>,
         absl::negation<absl::conjunction<std::is_move_constructible<T>...,
                                          // Note: We're not qualifying this with
                                          // absl:: because it doesn't compile
                                          // under MSVC.
                                          is_move_assignable<T>...>>>::value,
     VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>;
 
 // Base that is dependent on whether or not the copy-assign can be trivial.
 template <class... T>
 using VariantCopyAssignBase = absl::conditional_t<
     absl::disjunction<
         absl::conjunction<absl::is_copy_assignable<Union<T...>>,
                           std::is_copy_constructible<Union<T...>>,
                           std::is_destructible<Union<T...>>>,
         absl::negation<absl::conjunction<std::is_copy_constructible<T>...,
                                          // Note: We're not qualifying this with
                                          // absl:: because it doesn't compile
                                          // under MSVC.
                                          is_copy_assignable<T>...>>>::value,
     VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>;
 
 template <class... T>
 using VariantBase = VariantCopyAssignBase<T...>;
 
 template <class... T>
 class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
  private:
   using Base = VariantStateBase<T...>;
 
  protected:
   using Base::Base;
 
   VariantStateBaseDestructorNontrivial() = default;
   VariantStateBaseDestructorNontrivial(VariantStateBaseDestructorNontrivial&&) =
       default;
   VariantStateBaseDestructorNontrivial(
       const VariantStateBaseDestructorNontrivial&) = default;
   VariantStateBaseDestructorNontrivial& operator=(
       VariantStateBaseDestructorNontrivial&&) = default;
   VariantStateBaseDestructorNontrivial& operator=(
       const VariantStateBaseDestructorNontrivial&) = default;
 
   struct Destroyer {
     template <std::size_t I>
     void operator()(SizeT<I> i) const {
       using Alternative =
           typename absl::variant_alternative<I, variant<T...>>::type;
       variant_internal::AccessUnion(self->state_, i).~Alternative();
     }
 
     void operator()(SizeT<absl::variant_npos> /*i*/) const {
       // This space intentionally left blank
     }
 
     VariantStateBaseDestructorNontrivial* self;
   };
 
   void destroy() { VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_); }
 
   ~VariantStateBaseDestructorNontrivial() { destroy(); }
 
  protected:
   using Base::index_;
   using Base::state_;
 };
 
 template <class... T>
 class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
  private:
   using Base = VariantStateBaseDestructor<T...>;
 
  protected:
   using Base::Base;
 
   struct Construct {
     template <std::size_t I>
     void operator()(SizeT<I> i) const {
       using Alternative =
           typename absl::variant_alternative<I, variant<T...>>::type;
       ::new (static_cast<void*>(&self->state_)) Alternative(
           variant_internal::AccessUnion(std::move(other->state_), i));
     }
 
     void operator()(SizeT<absl::variant_npos> /*i*/) const {}
 
     VariantMoveBaseNontrivial* self;
     VariantMoveBaseNontrivial* other;
   };
 
   VariantMoveBaseNontrivial() = default;
   VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
       absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
       : Base(NoopConstructorTag()) {
     VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
     index_ = other.index_;
   }
 
   VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const&) = default;
 
   VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial&&) = default;
   VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial const&) =
       default;
 
  protected:
   using Base::index_;
   using Base::state_;
 };
 
 template <class... T>
 class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
  private:
   using Base = VariantMoveBase<T...>;
 
  protected:
   using Base::Base;
 
   VariantCopyBaseNontrivial() = default;
   VariantCopyBaseNontrivial(VariantCopyBaseNontrivial&&) = default;
 
   struct Construct {
     template <std::size_t I>
     void operator()(SizeT<I> i) const {
       using Alternative =
           typename absl::variant_alternative<I, variant<T...>>::type;
       ::new (static_cast<void*>(&self->state_))
           Alternative(variant_internal::AccessUnion(other->state_, i));
     }
 
     void operator()(SizeT<absl::variant_npos> /*i*/) const {}
 
     VariantCopyBaseNontrivial* self;
     const VariantCopyBaseNontrivial* other;
   };
 
   VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other)
       : Base(NoopConstructorTag()) {
     VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
     index_ = other.index_;
   }
 
   VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial&&) = default;
   VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial const&) =
       default;
 
  protected:
   using Base::index_;
   using Base::state_;
 };
 
 template <class... T>
 class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
   friend struct VariantCoreAccess;
 
  private:
   using Base = VariantCopyBase<T...>;
 
  protected:
   using Base::Base;
 
   VariantMoveAssignBaseNontrivial() = default;
   VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial&&) = default;
   VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial&) =
       default;
   VariantMoveAssignBaseNontrivial& operator=(
       VariantMoveAssignBaseNontrivial const&) = default;
 
   VariantMoveAssignBaseNontrivial&
   operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
       absl::conjunction<std::is_nothrow_move_constructible<T>...,
                         std::is_nothrow_move_assignable<T>...>::value) {
     VisitIndices<sizeof...(T)>::Run(
         VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
     return *this;
   }
 
  protected:
   using Base::index_;
   using Base::state_;
 };
 
 template <class... T>
 class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
   friend struct VariantCoreAccess;
 
  private:
   using Base = VariantMoveAssignBase<T...>;
 
  protected:
   using Base::Base;
 
   VariantCopyAssignBaseNontrivial() = default;
   VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial&&) = default;
   VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial&) =
       default;
   VariantCopyAssignBaseNontrivial& operator=(
       VariantCopyAssignBaseNontrivial&&) = default;
 
   VariantCopyAssignBaseNontrivial& operator=(
       const VariantCopyAssignBaseNontrivial& other) {
     VisitIndices<sizeof...(T)>::Run(
         VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
     return *this;
   }
 
  protected:
   using Base::index_;
   using Base::state_;
 };
 
 ////////////////////////////////////////
 // Visitors for Comparison Operations //
 ////////////////////////////////////////
 
 template <class... Types>
 struct EqualsOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return true;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
   }
 };
 
 template <class... Types>
 struct NotEqualsOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return false;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
   }
 };
 
 template <class... Types>
 struct LessThanOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return false;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
   }
 };
 
 template <class... Types>
 struct GreaterThanOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return false;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
   }
 };
 
 template <class... Types>
 struct LessThanOrEqualsOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return true;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
   }
 };
 
 template <class... Types>
 struct GreaterThanOrEqualsOp {
   const variant<Types...>* v;
   const variant<Types...>* w;
 
   constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
     return true;
   }
 
   template <std::size_t I>
   constexpr bool operator()(SizeT<I> /*v_i*/) const {
     return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
   }
 };
 
 // Precondition: v.index() == w.index();
 template <class... Types>
 struct SwapSameIndex {
   variant<Types...>* v;
   variant<Types...>* w;
   template <std::size_t I>
   void operator()(SizeT<I>) const {
     type_traits_internal::Swap(VariantCoreAccess::Access<I>(*v),
                                VariantCoreAccess::Access<I>(*w));
   }
 
   void operator()(SizeT<variant_npos>) const {}
 };
 
 // TODO(calabrese) do this from a different namespace for proper adl usage
 template <class... Types>
 struct Swap {
   variant<Types...>* v;
   variant<Types...>* w;
 
   void generic_swap() const {
     variant<Types...> tmp(std::move(*w));
     VariantCoreAccess::Destroy(*w);
     VariantCoreAccess::InitFrom(*w, std::move(*v));
     VariantCoreAccess::Destroy(*v);
     VariantCoreAccess::InitFrom(*v, std::move(tmp));
   }
 
   void operator()(SizeT<absl::variant_npos> /*w_i*/) const {
     if (!v->valueless_by_exception()) {
       generic_swap();
     }
   }
 
   template <std::size_t Wi>
   void operator()(SizeT<Wi> /*w_i*/) {
     if (v->index() == Wi) {
       VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
     } else {
       generic_swap();
     }
   }
 };
 
 template <typename Variant, typename = void, typename... Ts>
 struct VariantHashBase {
   VariantHashBase() = delete;
   VariantHashBase(const VariantHashBase&) = delete;
   VariantHashBase(VariantHashBase&&) = delete;
   VariantHashBase& operator=(const VariantHashBase&) = delete;
   VariantHashBase& operator=(VariantHashBase&&) = delete;
 };
 
 struct VariantHashVisitor {
   template <typename T>
   size_t operator()(const T& t) {
     return std::hash<T>{}(t);
   }
 };
 
 template <typename Variant, typename... Ts>
 struct VariantHashBase<Variant,
                        absl::enable_if_t<absl::conjunction<
                            type_traits_internal::IsHashable<Ts>...>::value>,
                        Ts...> {
   using argument_type = Variant;
   using result_type = size_t;
   size_t operator()(const Variant& var) const {
     type_traits_internal::AssertHashEnabled<Ts...>();
     if (var.valueless_by_exception()) {
       return 239799884;
     }
     size_t result = VisitIndices<variant_size<Variant>::value>::Run(
         PerformVisitation<VariantHashVisitor, const Variant&>{
             std::forward_as_tuple(var), VariantHashVisitor{}},
         var.index());
     // Combine the index and the hash result in order to distinguish
     // std::variant<int, int> holding the same value as different alternative.
     return result ^ var.index();
   }
 };
 
 }  // namespace variant_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // !defined(ABSL_USES_STD_VARIANT)
 #endif  // ABSL_TYPES_INTERNAL_VARIANT_H_

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