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