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