blob: 03557239a69e68638faead81007a5bc92ca30727 [file] [log] [blame]
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001// -*- C++ -*-
2//===------------------------------ variant -------------------------------===//
3//
Chandler Carruthd2012102019-01-19 10:56:40 +00004// 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
Eric Fiselier94cdacc2016-12-02 23:00:05 +00007//
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);
Louis Dionnecee59012019-01-10 20:06:11 +000025 variant(const variant&); // constexpr in C++20
26 variant(variant&&) noexcept(see below); // constexpr in C++20
Eric Fiselier94cdacc2016-12-02 23:00:05 +000027
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
Louis Dionnecee59012019-01-10 20:06:11 +000048 variant& operator=(const variant&); // constexpr in C++20
49 variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
Eric Fiselier94cdacc2016-12-02 23:00:05 +000050
51 template <class T> variant& operator=(T&&) noexcept(see below);
52
53 // 20.7.2.4, modifiers
54 template <class T, class... Args>
Eric Fiselier62928442017-04-15 19:32:02 +000055 T& emplace(Args&&...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +000056
57 template <class T, class U, class... Args>
Eric Fiselier62928442017-04-15 19:32:02 +000058 T& emplace(initializer_list<U>, Args&&...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +000059
60 template <size_t I, class... Args>
Eric Fiselier62928442017-04-15 19:32:02 +000061 variant_alternative_t<I, variant>& emplace(Args&&...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +000062
63 template <size_t I, class U, class... Args>
Eric Fiselier62928442017-04-15 19:32:02 +000064 variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +000065
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>
Marshall Clowf1bf62f2018-01-02 17:17:01 +000078 inline constexpr size_t variant_size_v = variant_size<T>::value;
Eric Fiselier94cdacc2016-12-02 23:00:05 +000079
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
Marshall Clowf1bf62f2018-01-02 17:17:01 +000099 inline constexpr size_t variant_npos = -1;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000100
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>
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000209#include <limits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000210#include <version>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000211
212#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
213#pragma GCC system_header
214#endif
215
Eric Fiselier8625d332017-11-19 04:57:22 +0000216_LIBCPP_PUSH_MACROS
217#include <__undef_macros>
218
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000219namespace std { // explicitly not using versioning namespace
220
Louis Dionnecef92e62018-11-19 15:37:04 +0000221class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS bad_variant_access : public exception {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000222public:
Saleem Abdulrasool5ee83382016-12-31 17:34:26 +0000223 virtual const char* what() const _NOEXCEPT;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000224};
225
226} // namespace std
227
228_LIBCPP_BEGIN_NAMESPACE_STD
229
230#if _LIBCPP_STD_VER > 14
231
Eric Fiselier10642ea2016-12-03 01:58:07 +0000232_LIBCPP_NORETURN
233inline _LIBCPP_INLINE_VISIBILITY
Louis Dionnecef92e62018-11-19 15:37:04 +0000234_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier10642ea2016-12-03 01:58:07 +0000235void __throw_bad_variant_access() {
236#ifndef _LIBCPP_NO_EXCEPTIONS
237 throw bad_variant_access();
238#else
239 _VSTD::abort();
240#endif
241}
242
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000243template <class... _Types>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000244class _LIBCPP_TEMPLATE_VIS variant;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000245
246template <class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000247struct _LIBCPP_TEMPLATE_VIS variant_size;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000248
249template <class _Tp>
Marshall Clowf1bf62f2018-01-02 17:17:01 +0000250_LIBCPP_INLINE_VAR constexpr size_t variant_size_v = variant_size<_Tp>::value;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000251
252template <class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000253struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {};
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000254
255template <class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000256struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {};
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000257
258template <class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000259struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000260 : variant_size<_Tp> {};
261
262template <class... _Types>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000263struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000264 : integral_constant<size_t, sizeof...(_Types)> {};
265
266template <size_t _Ip, class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000267struct _LIBCPP_TEMPLATE_VIS variant_alternative;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000268
269template <size_t _Ip, class _Tp>
270using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
271
272template <size_t _Ip, class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000273struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000274 : add_const<variant_alternative_t<_Ip, _Tp>> {};
275
276template <size_t _Ip, class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000277struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000278 : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
279
280template <size_t _Ip, class _Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000281struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000282 : add_cv<variant_alternative_t<_Ip, _Tp>> {};
283
284template <size_t _Ip, class... _Types>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000285struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
Marshall Clow185577f2017-06-12 16:13:17 +0000286 static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>");
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000287 using type = __type_pack_element<_Ip, _Types...>;
288};
289
Marshall Clowf1bf62f2018-01-02 17:17:01 +0000290_LIBCPP_INLINE_VAR constexpr size_t variant_npos = static_cast<size_t>(-1);
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000291
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);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000313
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,
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000387 __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())...>();
Michael Park07157892017-05-11 07:17:12 +0000453 return __at(__fmatrix, __vs.index()...)(
454 _VSTD::forward<_Visitor>(__visitor),
455 _VSTD::forward<_Vs>(__vs).__as_base()...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000456 }
457
458private:
459 template <class _Tp>
460 inline _LIBCPP_INLINE_VISIBILITY
Michael Park07157892017-05-11 07:17:12 +0000461 static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000462
Michael Park07157892017-05-11 07:17:12 +0000463 template <class _Tp, size_t _Np, typename... _Indices>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000464 inline _LIBCPP_INLINE_VISIBILITY
465 static constexpr auto&& __at(const array<_Tp, _Np>& __elems,
Michael Park07157892017-05-11 07:17:12 +0000466 size_t __index, _Indices... __indices) {
467 return __at(__elems[__index], __indices...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000468 }
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) {
Marshall Clowe61ba952018-02-12 15:41:25 +0000480 __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>();
481 using __result = array<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>;
Eric Fiselier2adf0872016-12-02 23:17:33 +0000482 return __result{{_VSTD::forward<_Fs>(__fs)...}};
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000483 }
484
Michael Park52dc9f02017-01-16 08:14:25 +0000485 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) {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000490 return __invoke_constexpr(
491 static_cast<_Fp>(__f),
492 __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
Michael Park52dc9f02017-01-16 08:14:25 +0000493 }
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...>) {
Eric Fiselier0ae996d2017-02-05 20:36:07 +0000499 return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000500 }
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() {
Marshall Clowe61ba952018-02-12 15:41:25 +0000518 constexpr size_t _Np = __uncvref_t<_Vp>::__size();
519 static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000520 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...>(
Marshall Clowe61ba952018-02-12 15:41:25 +0000542 index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000543 }
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() {
Zhihao Yuane2bb8752017-12-12 18:42:04 +0000586 static_assert(is_invocable_v<_Visitor, _Values...>,
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000587 "`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,
Eric Fiselier060c1fe2017-02-09 19:01:22 +0000597 decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000598 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000614struct _LIBCPP_TEMPLATE_VIS __alt {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000615 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000626union _LIBCPP_TEMPLATE_VIS __union;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000627
628template <_Trait _DestructibleTrait, size_t _Index>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000629union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000630
631#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \
632 template <size_t _Index, class _Tp, class... _Types> \
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000633 union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000634 _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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000674class _LIBCPP_TEMPLATE_VIS __base {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000675public:
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000676 using __index_t = __variant_index_t<sizeof...(_Types)>;
677
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000678 inline _LIBCPP_INLINE_VISIBILITY
679 explicit constexpr __base(__valueless_t tag) noexcept
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000680 : __data(tag), __index(__variant_npos<__index_t>) {}
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000681
682 template <size_t _Ip, class... _Args>
683 inline _LIBCPP_INLINE_VISIBILITY
684 explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
Eric Fiselier2adf0872016-12-02 23:17:33 +0000685 :
686 __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
687 __index(_Ip) {}
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000688
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 {
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000696 return __index == __variant_npos<__index_t> ? variant_npos : __index;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000697 }
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;
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000716 __index_t __index;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000717
718 friend struct __access::__base;
719 friend struct __visitation::__base;
720};
721
722template <class _Traits, _Trait = _Traits::__destructible_trait>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000723class _LIBCPP_TEMPLATE_VIS __destructor;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000724
725#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \
726 template <class... _Types> \
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000727 class _LIBCPP_TEMPLATE_VIS __destructor<__traits<_Types...>, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000728 destructible_trait> \
729 : public __base<destructible_trait, _Types...> { \
730 using __base_type = __base<destructible_trait, _Types...>; \
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000731 using __index_t = typename __base_type::__index_t; \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000732 \
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;,
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000751 void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000752
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 {
Marshall Clowe61ba952018-02-12 15:41:25 +0000760 using __alt_type = __uncvref_t<decltype(__alt)>;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000761 __alt.~__alt_type();
762 },
763 *this);
764 }
Eric Fiseliercaccc7b2017-11-19 04:19:44 +0000765 this->__index = __variant_npos<__index_t>;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000766 });
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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000776class _LIBCPP_TEMPLATE_VIS __constructor : public __destructor<_Traits> {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000777 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
Eric Fiselier62928442017-04-15 19:32:02 +0000786 static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
787 ::new ((void*)_VSTD::addressof(__a))
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000788 __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
Eric Fiselier62928442017-04-15 19:32:02 +0000789 return __a.__value;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000790 }
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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000811class _LIBCPP_TEMPLATE_VIS __move_constructor;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000812
813#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \
814 move_constructor) \
815 template <class... _Types> \
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000816 class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000817 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000851class _LIBCPP_TEMPLATE_VIS __copy_constructor;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000852
853#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \
854 copy_constructor) \
855 template <class... _Types> \
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000856 class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000857 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000890class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000891 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
Eric Fiselier62928442017-04-15 19:32:02 +0000899 auto& __emplace(_Args&&... __args) {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000900 this->__destroy();
Eric Fiselier62928442017-04-15 19:32:02 +0000901 auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000902 _VSTD::forward<_Args>(__args)...);
903 this->__index = _Ip;
Eric Fiselier62928442017-04-15 19:32:02 +0000904 return __res;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000905 }
906
907protected:
Michael Park62118352017-06-07 10:22:43 +0000908 template <size_t _Ip, class _Tp, class _Arg>
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000909 inline _LIBCPP_INLINE_VISIBILITY
Michael Park62118352017-06-07 10:22:43 +0000910 void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000911 if (this->index() == _Ip) {
912 __a.__value = _VSTD::forward<_Arg>(__arg);
913 } else {
914 struct {
915 void operator()(true_type) const {
Michael Park62118352017-06-07 10:22:43 +0000916 __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000917 }
918 void operator()(false_type) const {
Michael Park62118352017-06-07 10:22:43 +0000919 __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000920 }
921 __assignment* __this;
922 _Arg&& __arg;
923 } __impl{this, _VSTD::forward<_Arg>(__arg)};
Michael Park62118352017-06-07 10:22:43 +0000924 __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> ||
925 !is_nothrow_move_constructible_v<_Tp>>{});
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000926 }
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,
Michael Park62118352017-06-07 10:22:43 +0000942 _VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000943 },
944 *this, _VSTD::forward<_That>(__that));
945 }
946 }
947};
948
949template <class _Traits, _Trait = _Traits::__move_assignable_trait>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000950class _LIBCPP_TEMPLATE_VIS __move_assignment;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000951
952#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \
953 move_assignment) \
954 template <class... _Types> \
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000955 class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000956 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000991class _LIBCPP_TEMPLATE_VIS __copy_assignment;
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000992
993#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \
994 copy_assignment) \
995 template <class... _Types> \
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000996 class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \
Eric Fiselier94cdacc2016-12-02 23:00:05 +0000997 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>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001030class _LIBCPP_TEMPLATE_VIS __impl
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001031 : 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),
Michael Park62118352017-06-07 10:22:43 +00001042 _VSTD::forward<_Arg>(__arg));
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001043 }
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));
Michael Park5dee7342020-06-16 15:15:10 -07001065#ifndef _LIBCPP_NO_EXCEPTIONS
Michael Park6a9ef642020-07-08 10:46:02 -07001066 if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) {
Michael Park31967aa2020-06-16 13:29:23 -07001067 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 }
Michael Park5dee7342020-06-16 15:15:10 -07001081#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
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001086 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
Eric Fiselier3aaf8a32019-07-14 18:21:15 +00001098struct __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>
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001107 using _Apply _LIBCPP_NODEBUG_TYPE = decltype(__test_impl<_Dest>({std::declval<_Source>()}));
Eric Fiselier3aaf8a32019-07-14 18:21:15 +00001108};
1109
1110template <class _Dest, class _Source>
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001111using __check_for_narrowing _LIBCPP_NODEBUG_TYPE =
1112 typename _If<
Eric Fiselier3aaf8a32019-07-14 18:21:15 +00001113#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
1114 false &&
1115#endif
1116 is_arithmetic<_Dest>::value,
1117 __narrowing_check,
1118 __no_narrowing_check
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001119 >::template _Apply<_Dest, _Source>;
Eric Fiselier3aaf8a32019-07-14 18:21:15 +00001120
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001121template <class _Tp, size_t _Idx>
1122struct __overload {
Zhihao Yuan821efb82019-06-20 22:09:40 +00001123 template <class _Up>
Eric Fiselier80f5dfb2019-07-14 18:31:55 +00001124 auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>;
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001125};
1126
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001127template <class _Tp, size_t>
1128struct __overload_bool {
Zhihao Yuan821efb82019-06-20 22:09:40 +00001129 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
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001134template <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...>;
Zhihao Yuan821efb82019-06-20 22:09:40 +00001161
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001162template <class _Tp, class... _Types>
Zhihao Yuan821efb82019-06-20 22:09:40 +00001163using __best_match_t =
Eric Fiselieraa7cdca2019-07-14 21:29:39 +00001164 typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001165
1166} // __variant_detail
1167
1168template <class... _Types>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001169class _LIBCPP_TEMPLATE_VIS variant
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001170 : 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> &&
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001175 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,
Marshall Clowd5bbc242018-02-06 20:56:55 +00001206 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,
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001209 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,
Eric Fiselier5d2df752018-03-23 23:42:30 +00001219 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>
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001222 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier5d2df752018-03-23 23:42:30 +00001223 explicit constexpr variant(
1224 in_place_index_t<_Ip>,
1225 _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001226 : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
1227
Eric Fiselier5d2df752018-03-23 23:42:30 +00001228 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...>>,
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001234 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1235 int> = 0>
1236 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier5d2df752018-03-23 23:42:30 +00001237 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...>)
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001242 : __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,
Marshall Clowd5bbc242018-02-06 20:56:55 +00001278 enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001279 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
Eric Fiselier62928442017-04-15 19:32:02 +00001299 _Tp& emplace(_Args&&... __args) {
1300 return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001301 }
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
Eric Fiselier62928442017-04-15 19:32:02 +00001312 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
1313 return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001314 }
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
Eric Fiselier62928442017-04-15 19:32:02 +00001323 _Tp& emplace(_Args&&... __args) {
1324 return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001325 }
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
Eric Fiselier62928442017-04-15 19:32:02 +00001336 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
1337 return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001338 }
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
Louis Dionnecef92e62018-11-19 15:37:04 +00001383_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Richard Smith66d1c552018-08-27 21:41:50 +00001384constexpr auto&& __generic_get(_Vp&& __v) {
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001385 using __variant_detail::__access::__variant;
1386 if (!__holds_alternative<_Ip>(__v)) {
Eric Fiselier10642ea2016-12-03 01:58:07 +00001387 __throw_bad_variant_access();
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001388 }
1389 return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
1390}
1391
1392template <size_t _Ip, class... _Types>
1393inline _LIBCPP_INLINE_VISIBILITY
Louis Dionnecef92e62018-11-19 15:37:04 +00001394_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001395constexpr 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
Louis Dionnecef92e62018-11-19 15:37:04 +00001404_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001405constexpr 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
Louis Dionnecef92e62018-11-19 15:37:04 +00001414_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001415constexpr 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
Louis Dionnecef92e62018-11-19 15:37:04 +00001424_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001425constexpr 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
Louis Dionnecef92e62018-11-19 15:37:04 +00001434_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001435constexpr _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
Louis Dionnecef92e62018-11-19 15:37:04 +00001442_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001443constexpr _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
Louis Dionnecef92e62018-11-19 15:37:04 +00001451_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001452constexpr 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
Louis Dionnecef92e62018-11-19 15:37:04 +00001459_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001460constexpr 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
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001509template <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
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001519template <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;
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001526 return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001527}
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(
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001537 __lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001538}
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;
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001549 return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<less<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001550}
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;
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001561 return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<greater<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001562}
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(
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001574 __lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001575}
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(
Eric Fiselierfb6a2bc2018-09-19 17:53:21 +00001587 __lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001588}
1589
1590template <class _Visitor, class... _Vs>
1591inline _LIBCPP_INLINE_VISIBILITY
Louis Dionnecef92e62018-11-19 15:37:04 +00001592_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001593constexpr 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) {
Eric Fiselier10642ea2016-12-03 01:58:07 +00001598 __throw_bad_variant_access();
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001599 }
1600 }
1601 return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
1602 _VSTD::forward<_Vs>(__vs)...);
1603}
1604
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001605struct _LIBCPP_TEMPLATE_VIS monostate {};
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001606
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>
Eric Fiselier698a97b2017-01-21 00:02:12 +00001634struct _LIBCPP_TEMPLATE_VIS hash<
1635 __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001636 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;
Eric Fiselier9a4e3502016-12-02 23:38:31 +00001642 size_t __res =
1643 __v.valueless_by_exception()
Eric Fiselier6b1683c2016-12-04 21:37:37 +00001644 ? 299792458 // Random value chosen by the universe upon creation
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001645 : __variant::__visit_alt(
1646 [](const auto& __alt) {
Marshall Clowe61ba952018-02-12 15:41:25 +00001647 using __alt_type = __uncvref_t<decltype(__alt)>;
Eric Fiselier698a97b2017-01-21 00:02:12 +00001648 using __value_type = remove_const_t<
1649 typename __alt_type::__value_type>;
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001650 return hash<__value_type>{}(__alt.__value);
1651 },
1652 __v);
Eric Fiselier9a4e3502016-12-02 23:38:31 +00001653 return __hash_combine(__res, hash<size_t>{}(__v.index()));
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001654 }
1655};
1656
1657template <>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001658struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001659 using argument_type = monostate;
1660 using result_type = size_t;
1661
1662 inline _LIBCPP_INLINE_VISIBILITY
Marshall Clow49036892017-03-23 02:40:28 +00001663 result_type operator()(const argument_type&) const _NOEXCEPT {
Eric Fiselier6b1683c2016-12-04 21:37:37 +00001664 return 66740831; // return a fundamentally attractive random value.
1665 }
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001666};
1667
1668#endif // _LIBCPP_STD_VER > 14
1669
1670_LIBCPP_END_NAMESPACE_STD
1671
Eric Fiselier8625d332017-11-19 04:57:22 +00001672_LIBCPP_POP_MACROS
1673
Eric Fiselier94cdacc2016-12-02 23:00:05 +00001674#endif // _LIBCPP_VARIANT