1// -*- C++ -*-
2//===------------------------------ variant -------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_VARIANT
12#define _LIBCPP_VARIANT
13
14/*
15   variant synopsis
16
17namespace std {
18
19  // 20.7.2, class template variant
20  template <class... Types>
21  class variant {
22  public:
23
24    // 20.7.2.1, constructors
25    constexpr variant() noexcept(see below);
26    variant(const variant&);
27    variant(variant&&) noexcept(see below);
28
29    template <class T> constexpr variant(T&&) noexcept(see below);
30
31    template <class T, class... Args>
32    constexpr explicit variant(in_place_type_t<T>, Args&&...);
33
34    template <class T, class U, class... Args>
35    constexpr explicit variant(
36        in_place_type_t<T>, initializer_list<U>, Args&&...);
37
38    template <size_t I, class... Args>
39    constexpr explicit variant(in_place_index_t<I>, Args&&...);
40
41    template <size_t I, class U, class... Args>
42    constexpr explicit variant(
43        in_place_index_t<I>, initializer_list<U>, Args&&...);
44
45    // 20.7.2.2, destructor
46    ~variant();
47
48    // 20.7.2.3, assignment
49    variant& operator=(const variant&);
50    variant& operator=(variant&&) noexcept(see below);
51
52    template <class T> variant& operator=(T&&) noexcept(see below);
53
54    // 20.7.2.4, modifiers
55    template <class T, class... Args>
56    T& emplace(Args&&...);
57
58    template <class T, class U, class... Args>
59    T& emplace(initializer_list<U>, Args&&...);
60
61    template <size_t I, class... Args>
62    variant_alternative_t<I, variant>& emplace(Args&&...);
63
64    template <size_t I, class U, class...  Args>
65    variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...);
66
67    // 20.7.2.5, value status
68    constexpr bool valueless_by_exception() const noexcept;
69    constexpr size_t index() const noexcept;
70
71    // 20.7.2.6, swap
72    void swap(variant&) noexcept(see below);
73  };
74
75  // 20.7.3, variant helper classes
76  template <class T> struct variant_size; // undefined
77
78  template <class T>
79  inline constexpr size_t variant_size_v = variant_size<T>::value;
80
81  template <class T> struct variant_size<const T>;
82  template <class T> struct variant_size<volatile T>;
83  template <class T> struct variant_size<const volatile T>;
84
85  template <class... Types>
86  struct variant_size<variant<Types...>>;
87
88  template <size_t I, class T> struct variant_alternative; // undefined
89
90  template <size_t I, class T>
91  using variant_alternative_t = typename variant_alternative<I, T>::type;
92
93  template <size_t I, class T> struct variant_alternative<I, const T>;
94  template <size_t I, class T> struct variant_alternative<I, volatile T>;
95  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
96
97  template <size_t I, class... Types>
98  struct variant_alternative<I, variant<Types...>>;
99
100  inline constexpr size_t variant_npos = -1;
101
102  // 20.7.4, value access
103  template <class T, class... Types>
104  constexpr bool holds_alternative(const variant<Types...>&) noexcept;
105
106  template <size_t I, class... Types>
107  constexpr variant_alternative_t<I, variant<Types...>>&
108  get(variant<Types...>&);
109
110  template <size_t I, class... Types>
111  constexpr variant_alternative_t<I, variant<Types...>>&&
112  get(variant<Types...>&&);
113
114  template <size_t I, class... Types>
115  constexpr variant_alternative_t<I, variant<Types...>> const&
116  get(const variant<Types...>&);
117
118  template <size_t I, class... Types>
119  constexpr variant_alternative_t<I, variant<Types...>> const&&
120  get(const variant<Types...>&&);
121
122  template <class T, class...  Types>
123  constexpr T& get(variant<Types...>&);
124
125  template <class T, class... Types>
126  constexpr T&& get(variant<Types...>&&);
127
128  template <class T, class... Types>
129  constexpr const T& get(const variant<Types...>&);
130
131  template <class T, class... Types>
132  constexpr const T&& get(const variant<Types...>&&);
133
134  template <size_t I, class... Types>
135  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
136  get_if(variant<Types...>*) noexcept;
137
138  template <size_t I, class... Types>
139  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
140  get_if(const variant<Types...>*) noexcept;
141
142  template <class T, class... Types>
143  constexpr add_pointer_t<T>
144  get_if(variant<Types...>*) noexcept;
145
146  template <class T, class... Types>
147  constexpr add_pointer_t<const T>
148  get_if(const variant<Types...>*) noexcept;
149
150  // 20.7.5, relational operators
151  template <class... Types>
152  constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
153
154  template <class... Types>
155  constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
156
157  template <class... Types>
158  constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
159
160  template <class... Types>
161  constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
162
163  template <class... Types>
164  constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
165
166  template <class... Types>
167  constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
168
169  // 20.7.6, visitation
170  template <class Visitor, class... Variants>
171  constexpr see below visit(Visitor&&, Variants&&...);
172
173  // 20.7.7, class monostate
174  struct monostate;
175
176  // 20.7.8, monostate relational operators
177  constexpr bool operator<(monostate, monostate) noexcept;
178  constexpr bool operator>(monostate, monostate) noexcept;
179  constexpr bool operator<=(monostate, monostate) noexcept;
180  constexpr bool operator>=(monostate, monostate) noexcept;
181  constexpr bool operator==(monostate, monostate) noexcept;
182  constexpr bool operator!=(monostate, monostate) noexcept;
183
184  // 20.7.9, specialized algorithms
185  template <class... Types>
186  void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
187
188  // 20.7.10, class bad_variant_access
189  class bad_variant_access;
190
191  // 20.7.11, hash support
192  template <class T> struct hash;
193  template <class... Types> struct hash<variant<Types...>>;
194  template <> struct hash<monostate>;
195
196} // namespace std
197
198*/
199
200#include <__config>
201#include <__tuple>
202#include <array>
203#include <exception>
204#include <functional>
205#include <initializer_list>
206#include <new>
207#include <tuple>
208#include <type_traits>
209#include <utility>
210#include <limits>
211
212#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
213#pragma GCC system_header
214#endif
215
216_LIBCPP_PUSH_MACROS
217#include <__undef_macros>
218
219namespace std { // explicitly not using versioning namespace
220
221class _LIBCPP_EXCEPTION_ABI bad_variant_access : public exception {
222public:
223  virtual const char* what() const _NOEXCEPT;
224};
225
226} // namespace std
227
228_LIBCPP_BEGIN_NAMESPACE_STD
229
230#if _LIBCPP_STD_VER > 14
231
232_LIBCPP_NORETURN
233inline _LIBCPP_INLINE_VISIBILITY
234void __throw_bad_variant_access() {
235#ifndef _LIBCPP_NO_EXCEPTIONS
236        throw bad_variant_access();
237#else
238        _VSTD::abort();
239#endif
240}
241
242template <class... _Types>
243class _LIBCPP_TEMPLATE_VIS variant;
244
245template <class _Tp>
246struct _LIBCPP_TEMPLATE_VIS variant_size;
247
248template <class _Tp>
249_LIBCPP_INLINE_VAR constexpr size_t variant_size_v = variant_size<_Tp>::value;
250
251template <class _Tp>
252struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {};
253
254template <class _Tp>
255struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {};
256
257template <class _Tp>
258struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp>
259    : variant_size<_Tp> {};
260
261template <class... _Types>
262struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>>
263    : integral_constant<size_t, sizeof...(_Types)> {};
264
265template <size_t _Ip, class _Tp>
266struct _LIBCPP_TEMPLATE_VIS variant_alternative;
267
268template <size_t _Ip, class _Tp>
269using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
270
271template <size_t _Ip, class _Tp>
272struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp>
273    : add_const<variant_alternative_t<_Ip, _Tp>> {};
274
275template <size_t _Ip, class _Tp>
276struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp>
277    : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
278
279template <size_t _Ip, class _Tp>
280struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp>
281    : add_cv<variant_alternative_t<_Ip, _Tp>> {};
282
283template <size_t _Ip, class... _Types>
284struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
285  static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>");
286  using type = __type_pack_element<_Ip, _Types...>;
287};
288
289_LIBCPP_INLINE_VAR constexpr size_t variant_npos = static_cast<size_t>(-1);
290
291constexpr int __choose_index_type(unsigned int __num_elem) {
292  if (__num_elem < std::numeric_limits<unsigned char>::max())
293    return 0;
294  if (__num_elem < std::numeric_limits<unsigned short>::max())
295    return 1;
296  return 2;
297}
298
299template <size_t _NumAlts>
300using __variant_index_t =
301#ifndef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
302  unsigned int;
303#else
304  std::tuple_element_t<
305      __choose_index_type(_NumAlts),
306      std::tuple<unsigned char, unsigned short, unsigned int>
307  >;
308#endif
309
310template <class _IndexType>
311constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1);
312
313namespace __find_detail {
314
315template <class _Tp, class... _Types>
316inline _LIBCPP_INLINE_VISIBILITY
317constexpr size_t __find_index() {
318  constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
319  size_t __result = __not_found;
320  for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
321    if (__matches[__i]) {
322      if (__result != __not_found) {
323        return __ambiguous;
324      }
325      __result = __i;
326    }
327  }
328  return __result;
329}
330
331template <size_t _Index>
332struct __find_unambiguous_index_sfinae_impl
333    : integral_constant<size_t, _Index> {};
334
335template <>
336struct __find_unambiguous_index_sfinae_impl<__not_found> {};
337
338template <>
339struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};
340
341template <class _Tp, class... _Types>
342struct __find_unambiguous_index_sfinae
343    : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
344
345} // namespace __find_detail
346
347namespace __variant_detail {
348
349struct __valueless_t {};
350
351enum class _Trait { _TriviallyAvailable, _Available, _Unavailable };
352
353template <typename _Tp,
354          template <typename> class _IsTriviallyAvailable,
355          template <typename> class _IsAvailable>
356constexpr _Trait __trait =
357    _IsTriviallyAvailable<_Tp>::value
358        ? _Trait::_TriviallyAvailable
359        : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;
360
361inline _LIBCPP_INLINE_VISIBILITY
362constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
363  _Trait __result = _Trait::_TriviallyAvailable;
364  for (_Trait __t : __traits) {
365    if (static_cast<int>(__t) > static_cast<int>(__result)) {
366      __result = __t;
367    }
368  }
369  return __result;
370}
371
372template <typename... _Types>
373struct __traits {
374  static constexpr _Trait __copy_constructible_trait =
375      __common_trait({__trait<_Types,
376                              is_trivially_copy_constructible,
377                              is_copy_constructible>...});
378
379  static constexpr _Trait __move_constructible_trait =
380      __common_trait({__trait<_Types,
381                              is_trivially_move_constructible,
382                              is_move_constructible>...});
383
384  static constexpr _Trait __copy_assignable_trait = __common_trait(
385      {__copy_constructible_trait,
386       __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});
387
388  static constexpr _Trait __move_assignable_trait = __common_trait(
389      {__move_constructible_trait,
390       __trait<_Types, is_trivially_move_assignable, is_move_assignable>...});
391
392  static constexpr _Trait __destructible_trait = __common_trait(
393      {__trait<_Types, is_trivially_destructible, is_destructible>...});
394};
395
396namespace __access {
397
398struct __union {
399  template <class _Vp>
400  inline _LIBCPP_INLINE_VISIBILITY
401  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
402    return _VSTD::forward<_Vp>(__v).__head;
403  }
404
405  template <class _Vp, size_t _Ip>
406  inline _LIBCPP_INLINE_VISIBILITY
407  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
408    return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
409  }
410};
411
412struct __base {
413  template <size_t _Ip, class _Vp>
414  inline _LIBCPP_INLINE_VISIBILITY
415  static constexpr auto&& __get_alt(_Vp&& __v) {
416    return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
417                              in_place_index<_Ip>);
418  }
419};
420
421struct __variant {
422  template <size_t _Ip, class _Vp>
423  inline _LIBCPP_INLINE_VISIBILITY
424  static constexpr auto&& __get_alt(_Vp&& __v) {
425    return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
426  }
427};
428
429} // namespace __access
430
431namespace __visitation {
432
433struct __base {
434  template <class _Visitor, class... _Vs>
435  inline _LIBCPP_INLINE_VISIBILITY
436  static constexpr decltype(auto)
437  __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
438    constexpr auto __fdiagonal =
439        __make_fdiagonal<_Visitor&&,
440                         decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
441    return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
442                                _VSTD::forward<_Vs>(__vs).__as_base()...);
443  }
444
445  template <class _Visitor, class... _Vs>
446  inline _LIBCPP_INLINE_VISIBILITY
447  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
448                                              _Vs&&... __vs) {
449    constexpr auto __fmatrix =
450        __make_fmatrix<_Visitor&&,
451                       decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
452    return __at(__fmatrix, __vs.index()...)(
453        _VSTD::forward<_Visitor>(__visitor),
454        _VSTD::forward<_Vs>(__vs).__as_base()...);
455  }
456
457private:
458  template <class _Tp>
459  inline _LIBCPP_INLINE_VISIBILITY
460  static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }
461
462  template <class _Tp, size_t _Np, typename... _Indices>
463  inline _LIBCPP_INLINE_VISIBILITY
464  static constexpr auto&& __at(const array<_Tp, _Np>& __elems,
465                               size_t __index, _Indices... __indices) {
466    return __at(__elems[__index], __indices...);
467  }
468
469  template <class _Fp, class... _Fs>
470  static constexpr void __std_visit_visitor_return_type_check() {
471    static_assert(
472        __all<is_same_v<_Fp, _Fs>...>::value,
473        "`std::visit` requires the visitor to have a single return type.");
474  }
475
476  template <class... _Fs>
477  inline _LIBCPP_INLINE_VISIBILITY
478  static constexpr auto __make_farray(_Fs&&... __fs) {
479    __std_visit_visitor_return_type_check<decay_t<_Fs>...>();
480    using __result = array<common_type_t<decay_t<_Fs>...>, sizeof...(_Fs)>;
481    return __result{{_VSTD::forward<_Fs>(__fs)...}};
482  }
483
484  template <std::size_t... _Is>
485  struct __dispatcher {
486    template <class _Fp, class... _Vs>
487    inline _LIBCPP_INLINE_VISIBILITY
488    static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
489        return __invoke_constexpr(
490            static_cast<_Fp>(__f),
491            __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
492    }
493  };
494
495  template <class _Fp, class... _Vs, size_t... _Is>
496  inline _LIBCPP_INLINE_VISIBILITY
497  static constexpr auto __make_dispatch(index_sequence<_Is...>) {
498    return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
499  }
500
501  template <size_t _Ip, class _Fp, class... _Vs>
502  inline _LIBCPP_INLINE_VISIBILITY
503  static constexpr auto __make_fdiagonal_impl() {
504    return __make_dispatch<_Fp, _Vs...>(
505        index_sequence<(__identity<_Vs>{}, _Ip)...>{});
506  }
507
508  template <class _Fp, class... _Vs, size_t... _Is>
509  inline _LIBCPP_INLINE_VISIBILITY
510  static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
511    return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
512  }
513
514  template <class _Fp, class _Vp, class... _Vs>
515  inline _LIBCPP_INLINE_VISIBILITY
516  static constexpr auto __make_fdiagonal() {
517    constexpr size_t _Np = decay_t<_Vp>::__size();
518    static_assert(__all<(_Np == decay_t<_Vs>::__size())...>::value);
519    return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
520  }
521
522  template <class _Fp, class... _Vs, size_t... _Is>
523  inline _LIBCPP_INLINE_VISIBILITY
524  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
525    return __make_dispatch<_Fp, _Vs...>(__is);
526  }
527
528  template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
529  inline _LIBCPP_INLINE_VISIBILITY
530  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
531                                            index_sequence<_Js...>,
532                                            _Ls... __ls) {
533    return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
534        index_sequence<_Is..., _Js>{}, __ls...)...);
535  }
536
537  template <class _Fp, class... _Vs>
538  inline _LIBCPP_INLINE_VISIBILITY
539  static constexpr auto __make_fmatrix() {
540    return __make_fmatrix_impl<_Fp, _Vs...>(
541        index_sequence<>{}, make_index_sequence<decay_t<_Vs>::__size()>{}...);
542  }
543};
544
545struct __variant {
546  template <class _Visitor, class... _Vs>
547  inline _LIBCPP_INLINE_VISIBILITY
548  static constexpr decltype(auto)
549  __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
550    return __base::__visit_alt_at(__index,
551                                  _VSTD::forward<_Visitor>(__visitor),
552                                  _VSTD::forward<_Vs>(__vs).__impl...);
553  }
554
555  template <class _Visitor, class... _Vs>
556  inline _LIBCPP_INLINE_VISIBILITY
557  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
558                                              _Vs&&... __vs) {
559    return __base::__visit_alt(_VSTD::forward<_Visitor>(__visitor),
560                               _VSTD::forward<_Vs>(__vs).__impl...);
561  }
562
563  template <class _Visitor, class... _Vs>
564  inline _LIBCPP_INLINE_VISIBILITY
565  static constexpr decltype(auto)
566  __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
567    return __visit_alt_at(
568        __index,
569        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
570        _VSTD::forward<_Vs>(__vs)...);
571  }
572
573  template <class _Visitor, class... _Vs>
574  inline _LIBCPP_INLINE_VISIBILITY
575  static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
576                                                _Vs&&... __vs) {
577    return __visit_alt(
578        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
579        _VSTD::forward<_Vs>(__vs)...);
580  }
581
582private:
583  template <class _Visitor, class... _Values>
584  static constexpr void __std_visit_exhaustive_visitor_check() {
585    static_assert(is_invocable_v<_Visitor, _Values...>,
586                  "`std::visit` requires the visitor to be exhaustive.");
587  }
588
589  template <class _Visitor>
590  struct __value_visitor {
591    template <class... _Alts>
592    inline _LIBCPP_INLINE_VISIBILITY
593    constexpr decltype(auto) operator()(_Alts&&... __alts) const {
594      __std_visit_exhaustive_visitor_check<
595          _Visitor,
596          decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
597      return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
598                                _VSTD::forward<_Alts>(__alts).__value...);
599    }
600    _Visitor&& __visitor;
601  };
602
603  template <class _Visitor>
604  inline _LIBCPP_INLINE_VISIBILITY
605  static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
606    return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
607  }
608};
609
610} // namespace __visitation
611
612template <size_t _Index, class _Tp>
613struct _LIBCPP_TEMPLATE_VIS __alt {
614  using __value_type = _Tp;
615
616  template <class... _Args>
617  inline _LIBCPP_INLINE_VISIBILITY
618  explicit constexpr __alt(in_place_t, _Args&&... __args)
619      : __value(_VSTD::forward<_Args>(__args)...) {}
620
621  __value_type __value;
622};
623
624template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
625union _LIBCPP_TEMPLATE_VIS __union;
626
627template <_Trait _DestructibleTrait, size_t _Index>
628union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
629
630#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor)                  \
631  template <size_t _Index, class _Tp, class... _Types>                         \
632  union _LIBCPP_TEMPLATE_VIS __union<destructible_trait,                      \
633                                      _Index,                                  \
634                                      _Tp,                                     \
635                                      _Types...> {                             \
636  public:                                                                      \
637    inline _LIBCPP_INLINE_VISIBILITY                                           \
638    explicit constexpr __union(__valueless_t) noexcept : __dummy{} {}          \
639                                                                               \
640    template <class... _Args>                                                  \
641    inline _LIBCPP_INLINE_VISIBILITY                                           \
642    explicit constexpr __union(in_place_index_t<0>, _Args&&... __args)         \
643        : __head(in_place, _VSTD::forward<_Args>(__args)...) {}                \
644                                                                               \
645    template <size_t _Ip, class... _Args>                                      \
646    inline _LIBCPP_INLINE_VISIBILITY                                           \
647    explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args)       \
648        : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
649                                                                               \
650    __union(const __union&) = default;                                         \
651    __union(__union&&) = default;                                              \
652                                                                               \
653    destructor                                                                 \
654                                                                               \
655    __union& operator=(const __union&) = default;                              \
656    __union& operator=(__union&&) = default;                                   \
657                                                                               \
658  private:                                                                     \
659    char __dummy;                                                              \
660    __alt<_Index, _Tp> __head;                                                 \
661    __union<destructible_trait, _Index + 1, _Types...> __tail;                 \
662                                                                               \
663    friend struct __access::__union;                                           \
664  }
665
666_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
667_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {});
668_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
669
670#undef _LIBCPP_VARIANT_UNION
671
672template <_Trait _DestructibleTrait, class... _Types>
673class _LIBCPP_TEMPLATE_VIS __base {
674public:
675  using __index_t = __variant_index_t<sizeof...(_Types)>;
676
677  inline _LIBCPP_INLINE_VISIBILITY
678  explicit constexpr __base(__valueless_t tag) noexcept
679      : __data(tag), __index(__variant_npos<__index_t>) {}
680
681  template <size_t _Ip, class... _Args>
682  inline _LIBCPP_INLINE_VISIBILITY
683  explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
684      :
685        __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
686        __index(_Ip) {}
687
688  inline _LIBCPP_INLINE_VISIBILITY
689  constexpr bool valueless_by_exception() const noexcept {
690    return index() == variant_npos;
691  }
692
693  inline _LIBCPP_INLINE_VISIBILITY
694  constexpr size_t index() const noexcept {
695    return __index == __variant_npos<__index_t> ? variant_npos : __index;
696  }
697
698protected:
699  inline _LIBCPP_INLINE_VISIBILITY
700  constexpr auto&& __as_base() & { return *this; }
701
702  inline _LIBCPP_INLINE_VISIBILITY
703  constexpr auto&& __as_base() && { return _VSTD::move(*this); }
704
705  inline _LIBCPP_INLINE_VISIBILITY
706  constexpr auto&& __as_base() const & { return *this; }
707
708  inline _LIBCPP_INLINE_VISIBILITY
709  constexpr auto&& __as_base() const && { return _VSTD::move(*this); }
710
711  inline _LIBCPP_INLINE_VISIBILITY
712  static constexpr size_t __size() { return sizeof...(_Types); }
713
714  __union<_DestructibleTrait, 0, _Types...> __data;
715  __index_t __index;
716
717  friend struct __access::__base;
718  friend struct __visitation::__base;
719};
720
721template <class _Traits, _Trait = _Traits::__destructible_trait>
722class _LIBCPP_TEMPLATE_VIS __destructor;
723
724#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy)    \
725  template <class... _Types>                                                   \
726  class _LIBCPP_TEMPLATE_VIS __destructor<__traits<_Types...>,                 \
727                                           destructible_trait>                 \
728      : public __base<destructible_trait, _Types...> {                         \
729    using __base_type = __base<destructible_trait, _Types...>;                 \
730    using __index_t = typename __base_type::__index_t;                         \
731                                                                               \
732  public:                                                                      \
733    using __base_type::__base_type;                                            \
734    using __base_type::operator=;                                              \
735                                                                               \
736    __destructor(const __destructor&) = default;                               \
737    __destructor(__destructor&&) = default;                                    \
738    destructor                                                                 \
739    __destructor& operator=(const __destructor&) = default;                    \
740    __destructor& operator=(__destructor&&) = default;                         \
741                                                                               \
742  protected:                                                                   \
743    inline _LIBCPP_INLINE_VISIBILITY                                           \
744    destroy                                                                    \
745  }
746
747_LIBCPP_VARIANT_DESTRUCTOR(
748    _Trait::_TriviallyAvailable,
749    ~__destructor() = default;,
750    void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
751
752_LIBCPP_VARIANT_DESTRUCTOR(
753    _Trait::_Available,
754    ~__destructor() { __destroy(); },
755    void __destroy() noexcept {
756      if (!this->valueless_by_exception()) {
757        __visitation::__base::__visit_alt(
758            [](auto& __alt) noexcept {
759              using __alt_type = decay_t<decltype(__alt)>;
760              __alt.~__alt_type();
761            },
762            *this);
763      }
764      this->__index = __variant_npos<__index_t>;
765    });
766
767_LIBCPP_VARIANT_DESTRUCTOR(
768    _Trait::_Unavailable,
769    ~__destructor() = delete;,
770    void __destroy() noexcept = delete;);
771
772#undef _LIBCPP_VARIANT_DESTRUCTOR
773
774template <class _Traits>
775class _LIBCPP_TEMPLATE_VIS __constructor : public __destructor<_Traits> {
776  using __base_type = __destructor<_Traits>;
777
778public:
779  using __base_type::__base_type;
780  using __base_type::operator=;
781
782protected:
783  template <size_t _Ip, class _Tp, class... _Args>
784  inline _LIBCPP_INLINE_VISIBILITY
785  static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
786    ::new ((void*)_VSTD::addressof(__a))
787        __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
788    return __a.__value;
789  }
790
791  template <class _Rhs>
792  inline _LIBCPP_INLINE_VISIBILITY
793  static void __generic_construct(__constructor& __lhs, _Rhs&& __rhs) {
794    __lhs.__destroy();
795    if (!__rhs.valueless_by_exception()) {
796      __visitation::__base::__visit_alt_at(
797          __rhs.index(),
798          [](auto& __lhs_alt, auto&& __rhs_alt) {
799            __construct_alt(
800                __lhs_alt,
801                _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
802          },
803          __lhs, _VSTD::forward<_Rhs>(__rhs));
804      __lhs.__index = __rhs.index();
805    }
806  }
807};
808
809template <class _Traits, _Trait = _Traits::__move_constructible_trait>
810class _LIBCPP_TEMPLATE_VIS __move_constructor;
811
812#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait,             \
813                                         move_constructor)                     \
814  template <class... _Types>                                                   \
815  class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>,          \
816                                                 move_constructible_trait>     \
817      : public __constructor<__traits<_Types...>> {                            \
818    using __base_type = __constructor<__traits<_Types...>>;                    \
819                                                                               \
820  public:                                                                      \
821    using __base_type::__base_type;                                            \
822    using __base_type::operator=;                                              \
823                                                                               \
824    __move_constructor(const __move_constructor&) = default;                   \
825    move_constructor                                                           \
826    ~__move_constructor() = default;                                           \
827    __move_constructor& operator=(const __move_constructor&) = default;        \
828    __move_constructor& operator=(__move_constructor&&) = default;             \
829  }
830
831_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
832    _Trait::_TriviallyAvailable,
833    __move_constructor(__move_constructor&& __that) = default;);
834
835_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
836    _Trait::_Available,
837    __move_constructor(__move_constructor&& __that) noexcept(
838        __all<is_nothrow_move_constructible_v<_Types>...>::value)
839        : __move_constructor(__valueless_t{}) {
840      this->__generic_construct(*this, _VSTD::move(__that));
841    });
842
843_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
844    _Trait::_Unavailable,
845    __move_constructor(__move_constructor&&) = delete;);
846
847#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
848
849template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
850class _LIBCPP_TEMPLATE_VIS __copy_constructor;
851
852#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait,             \
853                                         copy_constructor)                     \
854  template <class... _Types>                                                   \
855  class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>,          \
856                                                 copy_constructible_trait>     \
857      : public __move_constructor<__traits<_Types...>> {                       \
858    using __base_type = __move_constructor<__traits<_Types...>>;               \
859                                                                               \
860  public:                                                                      \
861    using __base_type::__base_type;                                            \
862    using __base_type::operator=;                                              \
863                                                                               \
864    copy_constructor                                                           \
865    __copy_constructor(__copy_constructor&&) = default;                        \
866    ~__copy_constructor() = default;                                           \
867    __copy_constructor& operator=(const __copy_constructor&) = default;        \
868    __copy_constructor& operator=(__copy_constructor&&) = default;             \
869  }
870
871_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
872    _Trait::_TriviallyAvailable,
873    __copy_constructor(const __copy_constructor& __that) = default;);
874
875_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
876    _Trait::_Available,
877    __copy_constructor(const __copy_constructor& __that)
878        : __copy_constructor(__valueless_t{}) {
879      this->__generic_construct(*this, __that);
880    });
881
882_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
883    _Trait::_Unavailable,
884    __copy_constructor(const __copy_constructor&) = delete;);
885
886#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
887
888template <class _Traits>
889class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
890  using __base_type = __copy_constructor<_Traits>;
891
892public:
893  using __base_type::__base_type;
894  using __base_type::operator=;
895
896  template <size_t _Ip, class... _Args>
897  inline _LIBCPP_INLINE_VISIBILITY
898  auto& __emplace(_Args&&... __args) {
899    this->__destroy();
900    auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
901                          _VSTD::forward<_Args>(__args)...);
902    this->__index = _Ip;
903    return __res;
904  }
905
906protected:
907  template <size_t _Ip, class _Tp, class _Arg>
908  inline _LIBCPP_INLINE_VISIBILITY
909  void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
910    if (this->index() == _Ip) {
911      __a.__value = _VSTD::forward<_Arg>(__arg);
912    } else {
913      struct {
914        void operator()(true_type) const {
915          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
916        }
917        void operator()(false_type) const {
918          __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
919        }
920        __assignment* __this;
921        _Arg&& __arg;
922      } __impl{this, _VSTD::forward<_Arg>(__arg)};
923      __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> ||
924                           !is_nothrow_move_constructible_v<_Tp>>{});
925    }
926  }
927
928  template <class _That>
929  inline _LIBCPP_INLINE_VISIBILITY
930  void __generic_assign(_That&& __that) {
931    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
932      // do nothing.
933    } else if (__that.valueless_by_exception()) {
934      this->__destroy();
935    } else {
936      __visitation::__base::__visit_alt_at(
937          __that.index(),
938          [this](auto& __this_alt, auto&& __that_alt) {
939            this->__assign_alt(
940                __this_alt,
941                _VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
942          },
943          *this, _VSTD::forward<_That>(__that));
944    }
945  }
946};
947
948template <class _Traits, _Trait = _Traits::__move_assignable_trait>
949class _LIBCPP_TEMPLATE_VIS __move_assignment;
950
951#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait,                 \
952                                        move_assignment)                       \
953  template <class... _Types>                                                   \
954  class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>,           \
955                                                move_assignable_trait>         \
956      : public __assignment<__traits<_Types...>> {                             \
957    using __base_type = __assignment<__traits<_Types...>>;                     \
958                                                                               \
959  public:                                                                      \
960    using __base_type::__base_type;                                            \
961    using __base_type::operator=;                                              \
962                                                                               \
963    __move_assignment(const __move_assignment&) = default;                     \
964    __move_assignment(__move_assignment&&) = default;                          \
965    ~__move_assignment() = default;                                            \
966    __move_assignment& operator=(const __move_assignment&) = default;          \
967    move_assignment                                                            \
968  }
969
970_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
971    _Trait::_TriviallyAvailable,
972    __move_assignment& operator=(__move_assignment&& __that) = default;);
973
974_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
975    _Trait::_Available,
976    __move_assignment& operator=(__move_assignment&& __that) noexcept(
977        __all<(is_nothrow_move_constructible_v<_Types> &&
978               is_nothrow_move_assignable_v<_Types>)...>::value) {
979      this->__generic_assign(_VSTD::move(__that));
980      return *this;
981    });
982
983_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
984    _Trait::_Unavailable,
985    __move_assignment& operator=(__move_assignment&&) = delete;);
986
987#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
988
989template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
990class _LIBCPP_TEMPLATE_VIS __copy_assignment;
991
992#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait,                 \
993                                        copy_assignment)                       \
994  template <class... _Types>                                                   \
995  class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>,           \
996                                                copy_assignable_trait>         \
997      : public __move_assignment<__traits<_Types...>> {                        \
998    using __base_type = __move_assignment<__traits<_Types...>>;                \
999                                                                               \
1000  public:                                                                      \
1001    using __base_type::__base_type;                                            \
1002    using __base_type::operator=;                                              \
1003                                                                               \
1004    __copy_assignment(const __copy_assignment&) = default;                     \
1005    __copy_assignment(__copy_assignment&&) = default;                          \
1006    ~__copy_assignment() = default;                                            \
1007    copy_assignment                                                            \
1008    __copy_assignment& operator=(__copy_assignment&&) = default;               \
1009  }
1010
1011_LIBCPP_VARIANT_COPY_ASSIGNMENT(
1012    _Trait::_TriviallyAvailable,
1013    __copy_assignment& operator=(const __copy_assignment& __that) = default;);
1014
1015_LIBCPP_VARIANT_COPY_ASSIGNMENT(
1016    _Trait::_Available,
1017    __copy_assignment& operator=(const __copy_assignment& __that) {
1018      this->__generic_assign(__that);
1019      return *this;
1020    });
1021
1022_LIBCPP_VARIANT_COPY_ASSIGNMENT(
1023    _Trait::_Unavailable,
1024    __copy_assignment& operator=(const __copy_assignment&) = delete;);
1025
1026#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
1027
1028template <class... _Types>
1029class _LIBCPP_TEMPLATE_VIS __impl
1030    : public __copy_assignment<__traits<_Types...>> {
1031  using __base_type = __copy_assignment<__traits<_Types...>>;
1032
1033public:
1034  using __base_type::__base_type;
1035  using __base_type::operator=;
1036
1037  template <size_t _Ip, class _Arg>
1038  inline _LIBCPP_INLINE_VISIBILITY
1039  void __assign(_Arg&& __arg) {
1040    this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
1041                       _VSTD::forward<_Arg>(__arg));
1042  }
1043
1044  inline _LIBCPP_INLINE_VISIBILITY
1045  void __swap(__impl& __that)  {
1046    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
1047      // do nothing.
1048    } else if (this->index() == __that.index()) {
1049      __visitation::__base::__visit_alt_at(
1050          this->index(),
1051          [](auto& __this_alt, auto& __that_alt) {
1052            using _VSTD::swap;
1053            swap(__this_alt.__value, __that_alt.__value);
1054          },
1055          *this,
1056          __that);
1057    } else {
1058      __impl* __lhs = this;
1059      __impl* __rhs = _VSTD::addressof(__that);
1060      if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
1061        _VSTD::swap(__lhs, __rhs);
1062      }
1063      __impl __tmp(_VSTD::move(*__rhs));
1064#ifndef _LIBCPP_NO_EXCEPTIONS
1065      // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
1066      // and `__tmp` is nothrow move constructible then we move `__tmp` back
1067      // into `__rhs` and provide the strong exception safety guarentee.
1068      try {
1069        this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
1070      } catch (...) {
1071        if (__tmp.__move_nothrow()) {
1072          this->__generic_construct(*__rhs, _VSTD::move(__tmp));
1073        }
1074        throw;
1075      }
1076#else
1077      this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
1078#endif
1079      this->__generic_construct(*__lhs, _VSTD::move(__tmp));
1080    }
1081  }
1082
1083private:
1084  inline _LIBCPP_INLINE_VISIBILITY
1085  bool __move_nothrow() const {
1086    constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
1087    return this->valueless_by_exception() || __results[this->index()];
1088  }
1089};
1090
1091template <class... _Types>
1092struct __overload;
1093
1094template <>
1095struct __overload<> { void operator()() const; };
1096
1097template <class _Tp, class... _Types>
1098struct __overload<_Tp, _Types...> : __overload<_Types...> {
1099  using __overload<_Types...>::operator();
1100  __identity<_Tp> operator()(_Tp) const;
1101};
1102
1103template <class _Tp, class... _Types>
1104using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;
1105
1106} // __variant_detail
1107
1108template <class... _Types>
1109class _LIBCPP_TEMPLATE_VIS variant
1110    : private __sfinae_ctor_base<
1111          __all<is_copy_constructible_v<_Types>...>::value,
1112          __all<is_move_constructible_v<_Types>...>::value>,
1113      private __sfinae_assign_base<
1114          __all<(is_copy_constructible_v<_Types> &&
1115                 is_copy_assignable_v<_Types>)...>::value,
1116          __all<(is_move_constructible_v<_Types> &&
1117                 is_move_assignable_v<_Types>)...>::value> {
1118  static_assert(0 < sizeof...(_Types),
1119                "variant must consist of at least one alternative.");
1120
1121  static_assert(__all<!is_array_v<_Types>...>::value,
1122                "variant can not have an array type as an alternative.");
1123
1124  static_assert(__all<!is_reference_v<_Types>...>::value,
1125                "variant can not have a reference type as an alternative.");
1126
1127  static_assert(__all<!is_void_v<_Types>...>::value,
1128                "variant can not have a void type as an alternative.");
1129
1130  using __first_type = variant_alternative_t<0, variant>;
1131
1132public:
1133  template <bool _Dummy = true,
1134            enable_if_t<__dependent_type<is_default_constructible<__first_type>,
1135                                         _Dummy>::value,
1136                        int> = 0>
1137  inline _LIBCPP_INLINE_VISIBILITY
1138  constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
1139      : __impl(in_place_index<0>) {}
1140
1141  variant(const variant&) = default;
1142  variant(variant&&) = default;
1143
1144  template <
1145      class _Arg,
1146      enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
1147      enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0,
1148      enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0,
1149      class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
1150      size_t _Ip =
1151          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1152      enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
1153  inline _LIBCPP_INLINE_VISIBILITY
1154  constexpr variant(_Arg&& __arg) noexcept(
1155      is_nothrow_constructible_v<_Tp, _Arg>)
1156      : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}
1157
1158  template <size_t _Ip, class... _Args,
1159            class = enable_if_t<(_Ip < sizeof...(_Types)), int>,
1160            class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
1161            enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
1162  inline _LIBCPP_INLINE_VISIBILITY
1163  explicit constexpr variant(
1164      in_place_index_t<_Ip>,
1165      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
1166      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
1167
1168  template <
1169      size_t _Ip,
1170      class _Up,
1171      class... _Args,
1172      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
1173      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
1174      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1175                  int> = 0>
1176  inline _LIBCPP_INLINE_VISIBILITY
1177  explicit constexpr variant(
1178      in_place_index_t<_Ip>,
1179      initializer_list<_Up> __il,
1180      _Args&&... __args) noexcept(
1181      is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
1182      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
1183
1184  template <
1185      class _Tp,
1186      class... _Args,
1187      size_t _Ip =
1188          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1189      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
1190  inline _LIBCPP_INLINE_VISIBILITY
1191  explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
1192      is_nothrow_constructible_v<_Tp, _Args...>)
1193      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
1194
1195  template <
1196      class _Tp,
1197      class _Up,
1198      class... _Args,
1199      size_t _Ip =
1200          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1201      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1202                  int> = 0>
1203  inline _LIBCPP_INLINE_VISIBILITY
1204  explicit constexpr variant(
1205      in_place_type_t<_Tp>,
1206      initializer_list<_Up> __il,
1207      _Args&&... __args) noexcept(
1208      is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
1209      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
1210
1211  ~variant() = default;
1212
1213  variant& operator=(const variant&) = default;
1214  variant& operator=(variant&&) = default;
1215
1216  template <
1217      class _Arg,
1218      enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
1219      class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
1220      size_t _Ip =
1221          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1222      enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
1223                  int> = 0>
1224  inline _LIBCPP_INLINE_VISIBILITY
1225  variant& operator=(_Arg&& __arg) noexcept(
1226      is_nothrow_assignable_v<_Tp&, _Arg> &&
1227      is_nothrow_constructible_v<_Tp, _Arg>) {
1228    __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
1229    return *this;
1230  }
1231
1232  template <
1233      size_t _Ip,
1234      class... _Args,
1235      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
1236      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
1237      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
1238  inline _LIBCPP_INLINE_VISIBILITY
1239  _Tp& emplace(_Args&&... __args) {
1240    return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
1241  }
1242
1243  template <
1244      size_t _Ip,
1245      class _Up,
1246      class... _Args,
1247      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
1248      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
1249      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1250                  int> = 0>
1251  inline _LIBCPP_INLINE_VISIBILITY
1252  _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
1253    return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
1254  }
1255
1256  template <
1257      class _Tp,
1258      class... _Args,
1259      size_t _Ip =
1260          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1261      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
1262  inline _LIBCPP_INLINE_VISIBILITY
1263  _Tp& emplace(_Args&&... __args) {
1264    return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
1265  }
1266
1267  template <
1268      class _Tp,
1269      class _Up,
1270      class... _Args,
1271      size_t _Ip =
1272          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
1273      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1274                  int> = 0>
1275  inline _LIBCPP_INLINE_VISIBILITY
1276  _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
1277    return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
1278  }
1279
1280  inline _LIBCPP_INLINE_VISIBILITY
1281  constexpr bool valueless_by_exception() const noexcept {
1282    return __impl.valueless_by_exception();
1283  }
1284
1285  inline _LIBCPP_INLINE_VISIBILITY
1286  constexpr size_t index() const noexcept { return __impl.index(); }
1287
1288  template <
1289      bool _Dummy = true,
1290      enable_if_t<
1291          __all<(
1292              __dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
1293              __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
1294          int> = 0>
1295  inline _LIBCPP_INLINE_VISIBILITY
1296  void swap(variant& __that) noexcept(
1297      __all<(is_nothrow_move_constructible_v<_Types> &&
1298             is_nothrow_swappable_v<_Types>)...>::value) {
1299    __impl.__swap(__that.__impl);
1300  }
1301
1302private:
1303  __variant_detail::__impl<_Types...> __impl;
1304
1305  friend struct __variant_detail::__access::__variant;
1306  friend struct __variant_detail::__visitation::__variant;
1307};
1308
1309template <size_t _Ip, class... _Types>
1310inline _LIBCPP_INLINE_VISIBILITY
1311constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
1312  return __v.index() == _Ip;
1313}
1314
1315template <class _Tp, class... _Types>
1316inline _LIBCPP_INLINE_VISIBILITY
1317constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
1318  return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
1319}
1320
1321template <size_t _Ip, class _Vp>
1322inline _LIBCPP_INLINE_VISIBILITY
1323static constexpr auto&& __generic_get(_Vp&& __v) {
1324  using __variant_detail::__access::__variant;
1325  if (!__holds_alternative<_Ip>(__v)) {
1326    __throw_bad_variant_access();
1327  }
1328  return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
1329}
1330
1331template <size_t _Ip, class... _Types>
1332inline _LIBCPP_INLINE_VISIBILITY
1333constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
1334    variant<_Types...>& __v) {
1335  static_assert(_Ip < sizeof...(_Types));
1336  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1337  return __generic_get<_Ip>(__v);
1338}
1339
1340template <size_t _Ip, class... _Types>
1341inline _LIBCPP_INLINE_VISIBILITY
1342constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
1343    variant<_Types...>&& __v) {
1344  static_assert(_Ip < sizeof...(_Types));
1345  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1346  return __generic_get<_Ip>(_VSTD::move(__v));
1347}
1348
1349template <size_t _Ip, class... _Types>
1350inline _LIBCPP_INLINE_VISIBILITY
1351constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
1352    const variant<_Types...>& __v) {
1353  static_assert(_Ip < sizeof...(_Types));
1354  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1355  return __generic_get<_Ip>(__v);
1356}
1357
1358template <size_t _Ip, class... _Types>
1359inline _LIBCPP_INLINE_VISIBILITY
1360constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
1361    const variant<_Types...>&& __v) {
1362  static_assert(_Ip < sizeof...(_Types));
1363  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1364  return __generic_get<_Ip>(_VSTD::move(__v));
1365}
1366
1367template <class _Tp, class... _Types>
1368inline _LIBCPP_INLINE_VISIBILITY
1369constexpr _Tp& get(variant<_Types...>& __v) {
1370  static_assert(!is_void_v<_Tp>);
1371  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
1372}
1373
1374template <class _Tp, class... _Types>
1375inline _LIBCPP_INLINE_VISIBILITY
1376constexpr _Tp&& get(variant<_Types...>&& __v) {
1377  static_assert(!is_void_v<_Tp>);
1378  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
1379      _VSTD::move(__v));
1380}
1381
1382template <class _Tp, class... _Types>
1383inline _LIBCPP_INLINE_VISIBILITY
1384constexpr const _Tp& get(const variant<_Types...>& __v) {
1385  static_assert(!is_void_v<_Tp>);
1386  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
1387}
1388
1389template <class _Tp, class... _Types>
1390inline _LIBCPP_INLINE_VISIBILITY
1391constexpr const _Tp&& get(const variant<_Types...>&& __v) {
1392  static_assert(!is_void_v<_Tp>);
1393  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
1394      _VSTD::move(__v));
1395}
1396
1397template <size_t _Ip, class _Vp>
1398inline _LIBCPP_INLINE_VISIBILITY
1399constexpr auto* __generic_get_if(_Vp* __v) noexcept {
1400  using __variant_detail::__access::__variant;
1401  return __v && __holds_alternative<_Ip>(*__v)
1402             ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
1403             : nullptr;
1404}
1405
1406template <size_t _Ip, class... _Types>
1407inline _LIBCPP_INLINE_VISIBILITY
1408constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
1409get_if(variant<_Types...>* __v) noexcept {
1410  static_assert(_Ip < sizeof...(_Types));
1411  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1412  return __generic_get_if<_Ip>(__v);
1413}
1414
1415template <size_t _Ip, class... _Types>
1416inline _LIBCPP_INLINE_VISIBILITY
1417constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
1418get_if(const variant<_Types...>* __v) noexcept {
1419  static_assert(_Ip < sizeof...(_Types));
1420  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
1421  return __generic_get_if<_Ip>(__v);
1422}
1423
1424template <class _Tp, class... _Types>
1425inline _LIBCPP_INLINE_VISIBILITY
1426constexpr add_pointer_t<_Tp>
1427get_if(variant<_Types...>* __v) noexcept {
1428  static_assert(!is_void_v<_Tp>);
1429  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
1430}
1431
1432template <class _Tp, class... _Types>
1433inline _LIBCPP_INLINE_VISIBILITY
1434constexpr add_pointer_t<const _Tp>
1435get_if(const variant<_Types...>* __v) noexcept {
1436  static_assert(!is_void_v<_Tp>);
1437  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
1438}
1439
1440template <class... _Types>
1441inline _LIBCPP_INLINE_VISIBILITY
1442constexpr bool operator==(const variant<_Types...>& __lhs,
1443                          const variant<_Types...>& __rhs) {
1444  using __variant_detail::__visitation::__variant;
1445  if (__lhs.index() != __rhs.index()) return false;
1446  if (__lhs.valueless_by_exception()) return true;
1447  return __variant::__visit_value_at(__lhs.index(), equal_to<>{}, __lhs, __rhs);
1448}
1449
1450template <class... _Types>
1451inline _LIBCPP_INLINE_VISIBILITY
1452constexpr bool operator!=(const variant<_Types...>& __lhs,
1453                          const variant<_Types...>& __rhs) {
1454  using __variant_detail::__visitation::__variant;
1455  if (__lhs.index() != __rhs.index()) return true;
1456  if (__lhs.valueless_by_exception()) return false;
1457  return __variant::__visit_value_at(
1458      __lhs.index(), not_equal_to<>{}, __lhs, __rhs);
1459}
1460
1461template <class... _Types>
1462inline _LIBCPP_INLINE_VISIBILITY
1463constexpr bool operator<(const variant<_Types...>& __lhs,
1464                         const variant<_Types...>& __rhs) {
1465  using __variant_detail::__visitation::__variant;
1466  if (__rhs.valueless_by_exception()) return false;
1467  if (__lhs.valueless_by_exception()) return true;
1468  if (__lhs.index() < __rhs.index()) return true;
1469  if (__lhs.index() > __rhs.index()) return false;
1470  return __variant::__visit_value_at(__lhs.index(), less<>{}, __lhs, __rhs);
1471}
1472
1473template <class... _Types>
1474inline _LIBCPP_INLINE_VISIBILITY
1475constexpr bool operator>(const variant<_Types...>& __lhs,
1476                         const variant<_Types...>& __rhs) {
1477  using __variant_detail::__visitation::__variant;
1478  if (__lhs.valueless_by_exception()) return false;
1479  if (__rhs.valueless_by_exception()) return true;
1480  if (__lhs.index() > __rhs.index()) return true;
1481  if (__lhs.index() < __rhs.index()) return false;
1482  return __variant::__visit_value_at(__lhs.index(), greater<>{}, __lhs, __rhs);
1483}
1484
1485template <class... _Types>
1486inline _LIBCPP_INLINE_VISIBILITY
1487constexpr bool operator<=(const variant<_Types...>& __lhs,
1488                          const variant<_Types...>& __rhs) {
1489  using __variant_detail::__visitation::__variant;
1490  if (__lhs.valueless_by_exception()) return true;
1491  if (__rhs.valueless_by_exception()) return false;
1492  if (__lhs.index() < __rhs.index()) return true;
1493  if (__lhs.index() > __rhs.index()) return false;
1494  return __variant::__visit_value_at(
1495      __lhs.index(), less_equal<>{}, __lhs, __rhs);
1496}
1497
1498template <class... _Types>
1499inline _LIBCPP_INLINE_VISIBILITY
1500constexpr bool operator>=(const variant<_Types...>& __lhs,
1501                          const variant<_Types...>& __rhs) {
1502  using __variant_detail::__visitation::__variant;
1503  if (__rhs.valueless_by_exception()) return true;
1504  if (__lhs.valueless_by_exception()) return false;
1505  if (__lhs.index() > __rhs.index()) return true;
1506  if (__lhs.index() < __rhs.index()) return false;
1507  return __variant::__visit_value_at(
1508      __lhs.index(), greater_equal<>{}, __lhs, __rhs);
1509}
1510
1511template <class _Visitor, class... _Vs>
1512inline _LIBCPP_INLINE_VISIBILITY
1513constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
1514  using __variant_detail::__visitation::__variant;
1515  bool __results[] = {__vs.valueless_by_exception()...};
1516  for (bool __result : __results) {
1517    if (__result) {
1518      __throw_bad_variant_access();
1519    }
1520  }
1521  return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
1522                                  _VSTD::forward<_Vs>(__vs)...);
1523}
1524
1525struct _LIBCPP_TEMPLATE_VIS monostate {};
1526
1527inline _LIBCPP_INLINE_VISIBILITY
1528constexpr bool operator<(monostate, monostate) noexcept { return false; }
1529
1530inline _LIBCPP_INLINE_VISIBILITY
1531constexpr bool operator>(monostate, monostate) noexcept { return false; }
1532
1533inline _LIBCPP_INLINE_VISIBILITY
1534constexpr bool operator<=(monostate, monostate) noexcept { return true; }
1535
1536inline _LIBCPP_INLINE_VISIBILITY
1537constexpr bool operator>=(monostate, monostate) noexcept { return true; }
1538
1539inline _LIBCPP_INLINE_VISIBILITY
1540constexpr bool operator==(monostate, monostate) noexcept { return true; }
1541
1542inline _LIBCPP_INLINE_VISIBILITY
1543constexpr bool operator!=(monostate, monostate) noexcept { return false; }
1544
1545template <class... _Types>
1546inline _LIBCPP_INLINE_VISIBILITY
1547auto swap(variant<_Types...>& __lhs,
1548          variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
1549    -> decltype(__lhs.swap(__rhs)) {
1550  __lhs.swap(__rhs);
1551}
1552
1553template <class... _Types>
1554struct _LIBCPP_TEMPLATE_VIS hash<
1555    __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
1556  using argument_type = variant<_Types...>;
1557  using result_type = size_t;
1558
1559  inline _LIBCPP_INLINE_VISIBILITY
1560  result_type operator()(const argument_type& __v) const {
1561    using __variant_detail::__visitation::__variant;
1562    size_t __res =
1563        __v.valueless_by_exception()
1564               ? 299792458 // Random value chosen by the universe upon creation
1565               : __variant::__visit_alt(
1566                     [](const auto& __alt) {
1567                       using __alt_type = decay_t<decltype(__alt)>;
1568                       using __value_type = remove_const_t<
1569                         typename __alt_type::__value_type>;
1570                       return hash<__value_type>{}(__alt.__value);
1571                     },
1572                     __v);
1573    return __hash_combine(__res, hash<size_t>{}(__v.index()));
1574  }
1575};
1576
1577template <>
1578struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
1579  using argument_type = monostate;
1580  using result_type = size_t;
1581
1582  inline _LIBCPP_INLINE_VISIBILITY
1583  result_type operator()(const argument_type&) const _NOEXCEPT {
1584    return 66740831; // return a fundamentally attractive random value.
1585  }
1586};
1587
1588#endif  // _LIBCPP_STD_VER > 14
1589
1590_LIBCPP_END_NAMESPACE_STD
1591
1592_LIBCPP_POP_MACROS
1593
1594#endif  // _LIBCPP_VARIANT
1595