]>
Commit | Line | Data |
---|---|---|
197c757c TS |
1 | // <variant> -*- C++ -*- |
2 | ||
83ffe9cd | 3 | // Copyright (C) 2016-2023 Free Software Foundation, Inc. |
197c757c TS |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free | |
6 | // software; you can redistribute it and/or modify it under the | |
7 | // terms of the GNU General Public License as published by the | |
8 | // Free Software Foundation; either version 3, or (at your option) | |
9 | // any later version. | |
10 | ||
11 | // This library is distributed in the hope that it will be useful, | |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | // GNU General Public License for more details. | |
15 | ||
16 | // Under Section 7 of GPL version 3, you are granted additional | |
17 | // permissions described in the GCC Runtime Library Exception, version | |
18 | // 3.1, as published by the Free Software Foundation. | |
19 | ||
20 | // You should have received a copy of the GNU General Public License and | |
21 | // a copy of the GCC Runtime Library Exception along with this program; | |
22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
23 | // <http://www.gnu.org/licenses/>. | |
24 | ||
25 | /** @file variant | |
f0b88346 | 26 | * This is the `<variant>` C++ Library header. |
197c757c TS |
27 | */ |
28 | ||
29 | #ifndef _GLIBCXX_VARIANT | |
30 | #define _GLIBCXX_VARIANT 1 | |
31 | ||
32 | #pragma GCC system_header | |
33 | ||
c6888c62 | 34 | #if __cplusplus >= 201703L |
197c757c | 35 | |
261d5a4a | 36 | #include <initializer_list> |
197c757c | 37 | #include <type_traits> |
197c757c | 38 | #include <bits/enable_special_members.h> |
261d5a4a | 39 | #include <bits/exception_defines.h> |
6964bb3e | 40 | #include <bits/functional_hash.h> |
b01af236 | 41 | #include <bits/invoke.h> |
f3df0b3c | 42 | #include <bits/parse_numbers.h> |
94895bd9 JW |
43 | #include <bits/stl_iterator_base_funcs.h> |
44 | #include <bits/stl_construct.h> | |
261d5a4a | 45 | #include <bits/utility.h> // in_place_index_t |
5b417b35 | 46 | #if __cplusplus >= 202002L |
9e589880 JW |
47 | # include <compare> |
48 | #endif | |
197c757c | 49 | |
164a761a | 50 | #if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L |
ad820b0b JW |
51 | // P2231R1 constexpr needs constexpr unions and constrained destructors. |
52 | # define __cpp_lib_variant 202106L | |
53 | #else | |
164a761a | 54 | # include <ext/aligned_buffer.h> // Use __aligned_membuf instead of union. |
ad820b0b JW |
55 | # define __cpp_lib_variant 202102L |
56 | #endif | |
c6888c62 | 57 | |
164a761a JW |
58 | namespace std _GLIBCXX_VISIBILITY(default) |
59 | { | |
60 | _GLIBCXX_BEGIN_NAMESPACE_VERSION | |
61 | ||
197c757c TS |
62 | template<typename... _Types> class tuple; |
63 | template<typename... _Types> class variant; | |
64 | template <typename> struct hash; | |
65 | ||
66 | template<typename _Variant> | |
67 | struct variant_size; | |
68 | ||
69 | template<typename _Variant> | |
70 | struct variant_size<const _Variant> : variant_size<_Variant> {}; | |
71 | ||
72 | template<typename _Variant> | |
73 | struct variant_size<volatile _Variant> : variant_size<_Variant> {}; | |
74 | ||
75 | template<typename _Variant> | |
76 | struct variant_size<const volatile _Variant> : variant_size<_Variant> {}; | |
77 | ||
78 | template<typename... _Types> | |
79 | struct variant_size<variant<_Types...>> | |
80 | : std::integral_constant<size_t, sizeof...(_Types)> {}; | |
81 | ||
82 | template<typename _Variant> | |
288695f7 | 83 | inline constexpr size_t variant_size_v = variant_size<_Variant>::value; |
197c757c | 84 | |
30ab6d9e JW |
85 | template<typename... _Types> |
86 | inline constexpr size_t | |
87 | variant_size_v<variant<_Types...>> = sizeof...(_Types); | |
88 | ||
89 | template<typename... _Types> | |
90 | inline constexpr size_t | |
91 | variant_size_v<const variant<_Types...>> = sizeof...(_Types); | |
92 | ||
197c757c TS |
93 | template<size_t _Np, typename _Variant> |
94 | struct variant_alternative; | |
95 | ||
30ab6d9e JW |
96 | template<size_t _Np, typename... _Types> |
97 | struct variant_alternative<_Np, variant<_Types...>> | |
98 | { | |
99 | static_assert(_Np < sizeof...(_Types)); | |
197c757c | 100 | |
09aab7e6 | 101 | using type = typename _Nth_type<_Np, _Types...>::type; |
30ab6d9e | 102 | }; |
197c757c TS |
103 | |
104 | template<size_t _Np, typename _Variant> | |
105 | using variant_alternative_t = | |
106 | typename variant_alternative<_Np, _Variant>::type; | |
107 | ||
3203ed5f TS |
108 | template<size_t _Np, typename _Variant> |
109 | struct variant_alternative<_Np, const _Variant> | |
8be17e2a | 110 | { using type = const variant_alternative_t<_Np, _Variant>; }; |
3203ed5f TS |
111 | |
112 | template<size_t _Np, typename _Variant> | |
113 | struct variant_alternative<_Np, volatile _Variant> | |
8be17e2a | 114 | { using type = volatile variant_alternative_t<_Np, _Variant>; }; |
3203ed5f TS |
115 | |
116 | template<size_t _Np, typename _Variant> | |
117 | struct variant_alternative<_Np, const volatile _Variant> | |
8be17e2a | 118 | { using type = const volatile variant_alternative_t<_Np, _Variant>; }; |
3203ed5f | 119 | |
288695f7 | 120 | inline constexpr size_t variant_npos = -1; |
197c757c | 121 | |
b01af236 TS |
122 | template<size_t _Np, typename... _Types> |
123 | constexpr variant_alternative_t<_Np, variant<_Types...>>& | |
124 | get(variant<_Types...>&); | |
125 | ||
126 | template<size_t _Np, typename... _Types> | |
127 | constexpr variant_alternative_t<_Np, variant<_Types...>>&& | |
128 | get(variant<_Types...>&&); | |
129 | ||
130 | template<size_t _Np, typename... _Types> | |
131 | constexpr variant_alternative_t<_Np, variant<_Types...>> const& | |
132 | get(const variant<_Types...>&); | |
133 | ||
134 | template<size_t _Np, typename... _Types> | |
135 | constexpr variant_alternative_t<_Np, variant<_Types...>> const&& | |
136 | get(const variant<_Types...>&&); | |
137 | ||
956a62aa | 138 | template<typename _Result_type, typename _Visitor, typename... _Variants> |
669a6fdc VV |
139 | constexpr decltype(auto) |
140 | __do_visit(_Visitor&& __visitor, _Variants&&... __variants); | |
141 | ||
142 | template <typename... _Types, typename _Tp> | |
ad820b0b | 143 | _GLIBCXX20_CONSTEXPR |
9d89b73c JW |
144 | decltype(auto) |
145 | __variant_cast(_Tp&& __rhs) | |
669a6fdc VV |
146 | { |
147 | if constexpr (is_lvalue_reference_v<_Tp>) | |
148 | { | |
149 | if constexpr (is_const_v<remove_reference_t<_Tp>>) | |
150 | return static_cast<const variant<_Types...>&>(__rhs); | |
151 | else | |
152 | return static_cast<variant<_Types...>&>(__rhs); | |
153 | } | |
154 | else | |
155 | return static_cast<variant<_Types...>&&>(__rhs); | |
156 | } | |
157 | ||
197c757c TS |
158 | namespace __detail |
159 | { | |
160 | namespace __variant | |
161 | { | |
669a6fdc VV |
162 | // used for raw visitation |
163 | struct __variant_cookie {}; | |
f1ba6c5a | 164 | // used for raw visitation with indices passed in |
8701cb5e | 165 | struct __variant_idx_cookie { using type = __variant_idx_cookie; }; |
956a62aa | 166 | // Used to enable deduction (and same-type checking) for std::visit: |
3427e313 | 167 | template<typename _Tp> struct __deduce_visit_result { using type = _Tp; }; |
956a62aa JW |
168 | |
169 | // Visit variants that might be valueless. | |
170 | template<typename _Visitor, typename... _Variants> | |
171 | constexpr void | |
172 | __raw_visit(_Visitor&& __visitor, _Variants&&... __variants) | |
173 | { | |
174 | std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor), | |
175 | std::forward<_Variants>(__variants)...); | |
176 | } | |
177 | ||
178 | // Visit variants that might be valueless, passing indices to the visitor. | |
179 | template<typename _Visitor, typename... _Variants> | |
180 | constexpr void | |
181 | __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants) | |
182 | { | |
183 | std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor), | |
184 | std::forward<_Variants>(__variants)...); | |
185 | } | |
669a6fdc | 186 | |
c46ecb01 JW |
187 | // The __as function templates implement the exposition-only "as-variant" |
188 | ||
189 | template<typename... _Types> | |
190 | constexpr std::variant<_Types...>& | |
728e639d | 191 | __as(std::variant<_Types...>& __v) noexcept |
c46ecb01 JW |
192 | { return __v; } |
193 | ||
194 | template<typename... _Types> | |
195 | constexpr const std::variant<_Types...>& | |
196 | __as(const std::variant<_Types...>& __v) noexcept | |
197 | { return __v; } | |
198 | ||
199 | template<typename... _Types> | |
200 | constexpr std::variant<_Types...>&& | |
201 | __as(std::variant<_Types...>&& __v) noexcept | |
202 | { return std::move(__v); } | |
203 | ||
204 | template<typename... _Types> | |
205 | constexpr const std::variant<_Types...>&& | |
206 | __as(const std::variant<_Types...>&& __v) noexcept | |
207 | { return std::move(__v); } | |
208 | ||
ad820b0b | 209 | // For C++17: |
24b54628 VV |
210 | // _Uninitialized<T> is guaranteed to be a trivially destructible type, |
211 | // even if T is not. | |
ad820b0b JW |
212 | // For C++20: |
213 | // _Uninitialized<T> is trivially destructible iff T is, so _Variant_union | |
214 | // needs a constrained non-trivial destructor. | |
24b54628 | 215 | template<typename _Type, bool = std::is_trivially_destructible_v<_Type>> |
197c757c TS |
216 | struct _Uninitialized; |
217 | ||
218 | template<typename _Type> | |
219 | struct _Uninitialized<_Type, true> | |
220 | { | |
197c757c | 221 | template<typename... _Args> |
9d89b73c JW |
222 | constexpr |
223 | _Uninitialized(in_place_index_t<0>, _Args&&... __args) | |
224 | : _M_storage(std::forward<_Args>(__args)...) | |
225 | { } | |
197c757c | 226 | |
be46043e | 227 | constexpr const _Type& _M_get() const & noexcept |
9189f559 TS |
228 | { return _M_storage; } |
229 | ||
be46043e | 230 | constexpr _Type& _M_get() & noexcept |
9189f559 TS |
231 | { return _M_storage; } |
232 | ||
be46043e | 233 | constexpr const _Type&& _M_get() const && noexcept |
9189f559 TS |
234 | { return std::move(_M_storage); } |
235 | ||
be46043e | 236 | constexpr _Type&& _M_get() && noexcept |
9189f559 TS |
237 | { return std::move(_M_storage); } |
238 | ||
197c757c TS |
239 | _Type _M_storage; |
240 | }; | |
241 | ||
242 | template<typename _Type> | |
243 | struct _Uninitialized<_Type, false> | |
244 | { | |
ad820b0b JW |
245 | #if __cpp_lib_variant >= 202106L |
246 | template<typename... _Args> | |
247 | constexpr | |
248 | _Uninitialized(in_place_index_t<0>, _Args&&... __args) | |
249 | : _M_storage(std::forward<_Args>(__args)...) | |
250 | { } | |
251 | ||
252 | constexpr ~_Uninitialized() { } | |
253 | ||
254 | _Uninitialized(const _Uninitialized&) = default; | |
255 | _Uninitialized(_Uninitialized&&) = default; | |
256 | _Uninitialized& operator=(const _Uninitialized&) = default; | |
257 | _Uninitialized& operator=(_Uninitialized&&) = default; | |
258 | ||
259 | constexpr const _Type& _M_get() const & noexcept | |
260 | { return _M_storage; } | |
261 | ||
262 | constexpr _Type& _M_get() & noexcept | |
263 | { return _M_storage; } | |
264 | ||
265 | constexpr const _Type&& _M_get() const && noexcept | |
266 | { return std::move(_M_storage); } | |
267 | ||
268 | constexpr _Type&& _M_get() && noexcept | |
269 | { return std::move(_M_storage); } | |
270 | ||
5a8832b1 JW |
271 | struct _Empty_byte { }; |
272 | ||
ad820b0b | 273 | union { |
5a8832b1 | 274 | _Empty_byte _M_empty; |
ad820b0b JW |
275 | _Type _M_storage; |
276 | }; | |
277 | #else | |
197c757c | 278 | template<typename... _Args> |
9d89b73c JW |
279 | constexpr |
280 | _Uninitialized(in_place_index_t<0>, _Args&&... __args) | |
281 | { | |
282 | ::new ((void*)std::addressof(_M_storage)) | |
283 | _Type(std::forward<_Args>(__args)...); | |
284 | } | |
197c757c | 285 | |
be46043e | 286 | const _Type& _M_get() const & noexcept |
9189f559 TS |
287 | { return *_M_storage._M_ptr(); } |
288 | ||
be46043e | 289 | _Type& _M_get() & noexcept |
9189f559 TS |
290 | { return *_M_storage._M_ptr(); } |
291 | ||
be46043e | 292 | const _Type&& _M_get() const && noexcept |
9189f559 TS |
293 | { return std::move(*_M_storage._M_ptr()); } |
294 | ||
be46043e | 295 | _Type&& _M_get() && noexcept |
9189f559 TS |
296 | { return std::move(*_M_storage._M_ptr()); } |
297 | ||
298 | __gnu_cxx::__aligned_membuf<_Type> _M_storage; | |
ad820b0b | 299 | #endif |
197c757c TS |
300 | }; |
301 | ||
9189f559 | 302 | template<size_t _Np, typename _Union> |
be46043e | 303 | constexpr decltype(auto) |
4f87d4c5 | 304 | __get_n(_Union&& __u) noexcept |
aafaa325 | 305 | { |
4f87d4c5 JW |
306 | if constexpr (_Np == 0) |
307 | return std::forward<_Union>(__u)._M_first._M_get(); | |
308 | else if constexpr (_Np == 1) | |
309 | return std::forward<_Union>(__u)._M_rest._M_first._M_get(); | |
310 | else if constexpr (_Np == 2) | |
311 | return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get(); | |
312 | else | |
313 | return __variant::__get_n<_Np - 3>( | |
314 | std::forward<_Union>(__u)._M_rest._M_rest._M_rest); | |
aafaa325 | 315 | } |
9189f559 TS |
316 | |
317 | // Returns the typed storage for __v. | |
318 | template<size_t _Np, typename _Variant> | |
be46043e JW |
319 | constexpr decltype(auto) |
320 | __get(_Variant&& __v) noexcept | |
4f87d4c5 | 321 | { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); } |
9189f559 | 322 | |
70503724 TS |
323 | template<typename... _Types> |
324 | struct _Traits | |
325 | { | |
326 | static constexpr bool _S_default_ctor = | |
4a15d842 | 327 | is_default_constructible_v<typename _Nth_type<0, _Types...>::type>; |
70503724 | 328 | static constexpr bool _S_copy_ctor = |
4a15d842 | 329 | (is_copy_constructible_v<_Types> && ...); |
70503724 | 330 | static constexpr bool _S_move_ctor = |
4a15d842 | 331 | (is_move_constructible_v<_Types> && ...); |
70503724 | 332 | static constexpr bool _S_copy_assign = |
5f00d0d5 | 333 | _S_copy_ctor |
4a15d842 | 334 | && (is_copy_assignable_v<_Types> && ...); |
70503724 | 335 | static constexpr bool _S_move_assign = |
4a15d842 FD |
336 | _S_move_ctor |
337 | && (is_move_assignable_v<_Types> && ...); | |
70503724 TS |
338 | |
339 | static constexpr bool _S_trivial_dtor = | |
4a15d842 | 340 | (is_trivially_destructible_v<_Types> && ...); |
70503724 | 341 | static constexpr bool _S_trivial_copy_ctor = |
4a15d842 | 342 | (is_trivially_copy_constructible_v<_Types> && ...); |
70503724 | 343 | static constexpr bool _S_trivial_move_ctor = |
4a15d842 | 344 | (is_trivially_move_constructible_v<_Types> && ...); |
70503724 | 345 | static constexpr bool _S_trivial_copy_assign = |
038bc9bf JW |
346 | _S_trivial_dtor && _S_trivial_copy_ctor |
347 | && (is_trivially_copy_assignable_v<_Types> && ...); | |
70503724 | 348 | static constexpr bool _S_trivial_move_assign = |
038bc9bf JW |
349 | _S_trivial_dtor && _S_trivial_move_ctor |
350 | && (is_trivially_move_assignable_v<_Types> && ...); | |
70503724 TS |
351 | |
352 | // The following nothrow traits are for non-trivial SMFs. Trivial SMFs | |
353 | // are always nothrow. | |
354 | static constexpr bool _S_nothrow_default_ctor = | |
4a15d842 FD |
355 | is_nothrow_default_constructible_v< |
356 | typename _Nth_type<0, _Types...>::type>; | |
70503724 TS |
357 | static constexpr bool _S_nothrow_copy_ctor = false; |
358 | static constexpr bool _S_nothrow_move_ctor = | |
4a15d842 | 359 | (is_nothrow_move_constructible_v<_Types> && ...); |
70503724 TS |
360 | static constexpr bool _S_nothrow_copy_assign = false; |
361 | static constexpr bool _S_nothrow_move_assign = | |
038bc9bf JW |
362 | _S_nothrow_move_ctor |
363 | && (is_nothrow_move_assignable_v<_Types> && ...); | |
70503724 TS |
364 | }; |
365 | ||
9189f559 | 366 | // Defines members and ctors. |
197c757c | 367 | template<typename... _Types> |
30ab6d9e JW |
368 | union _Variadic_union |
369 | { | |
370 | _Variadic_union() = default; | |
371 | ||
372 | template<size_t _Np, typename... _Args> | |
373 | _Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete; | |
374 | }; | |
197c757c | 375 | |
197c757c | 376 | template<typename _First, typename... _Rest> |
9189f559 | 377 | union _Variadic_union<_First, _Rest...> |
197c757c | 378 | { |
9189f559 TS |
379 | constexpr _Variadic_union() : _M_rest() { } |
380 | ||
381 | template<typename... _Args> | |
ad820b0b JW |
382 | constexpr |
383 | _Variadic_union(in_place_index_t<0>, _Args&&... __args) | |
9189f559 TS |
384 | : _M_first(in_place_index<0>, std::forward<_Args>(__args)...) |
385 | { } | |
386 | ||
387 | template<size_t _Np, typename... _Args> | |
ad820b0b JW |
388 | constexpr |
389 | _Variadic_union(in_place_index_t<_Np>, _Args&&... __args) | |
9189f559 TS |
390 | : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...) |
391 | { } | |
392 | ||
ad820b0b JW |
393 | #if __cpp_lib_variant >= 202106L |
394 | _Variadic_union(const _Variadic_union&) = default; | |
395 | _Variadic_union(_Variadic_union&&) = default; | |
396 | _Variadic_union& operator=(const _Variadic_union&) = default; | |
397 | _Variadic_union& operator=(_Variadic_union&&) = default; | |
398 | ||
399 | ~_Variadic_union() = default; | |
400 | ||
401 | constexpr ~_Variadic_union() | |
402 | requires (!__has_trivial_destructor(_First)) | |
403 | || (!__has_trivial_destructor(_Variadic_union<_Rest...>)) | |
404 | { } | |
405 | #endif | |
406 | ||
9189f559 TS |
407 | _Uninitialized<_First> _M_first; |
408 | _Variadic_union<_Rest...> _M_rest; | |
409 | }; | |
410 | ||
10f26de9 JW |
411 | // _Never_valueless_alt is true for variant alternatives that can |
412 | // always be placed in a variant without it becoming valueless. | |
413 | ||
414 | // For suitably-small, trivially copyable types we can create temporaries | |
415 | // on the stack and then memcpy them into place. | |
416 | template<typename _Tp> | |
417 | struct _Never_valueless_alt | |
418 | : __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>> | |
419 | { }; | |
420 | ||
421 | // Specialize _Never_valueless_alt for other types which have a | |
47a468bd JW |
422 | // non-throwing and cheap move construction and move assignment operator, |
423 | // so that emplacing the type will provide the strong exception-safety | |
424 | // guarantee, by creating and moving a temporary. | |
10f26de9 JW |
425 | // Whether _Never_valueless_alt<T> is true or not affects the ABI of a |
426 | // variant using that alternative, so we can't change the value later! | |
427 | ||
428 | // True if every alternative in _Types... can be emplaced in a variant | |
429 | // without it becoming valueless. If this is true, variant<_Types...> | |
430 | // can never be valueless, which enables some minor optimizations. | |
da97b98a | 431 | template <typename... _Types> |
10f26de9 JW |
432 | constexpr bool __never_valueless() |
433 | { | |
47a468bd JW |
434 | return _Traits<_Types...>::_S_move_assign |
435 | && (_Never_valueless_alt<_Types>::value && ...); | |
10f26de9 | 436 | } |
da97b98a | 437 | |
9189f559 TS |
438 | // Defines index and the dtor, possibly trivial. |
439 | template<bool __trivially_destructible, typename... _Types> | |
440 | struct _Variant_storage; | |
441 | ||
f3df0b3c | 442 | template <typename... _Types> |
9d89b73c JW |
443 | using __select_index = |
444 | typename __select_int::_Select_int_base<sizeof...(_Types), | |
445 | unsigned char, | |
446 | unsigned short>::type::value_type; | |
f3df0b3c | 447 | |
9189f559 TS |
448 | template<typename... _Types> |
449 | struct _Variant_storage<false, _Types...> | |
450 | { | |
074436cf JW |
451 | constexpr |
452 | _Variant_storage() | |
453 | : _M_index(static_cast<__index_type>(variant_npos)) | |
454 | { } | |
197c757c | 455 | |
41501d1a | 456 | template<size_t _Np, typename... _Args> |
074436cf JW |
457 | constexpr |
458 | _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) | |
9189f559 | 459 | : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), |
074436cf | 460 | _M_index{_Np} |
197c757c TS |
461 | { } |
462 | ||
ad820b0b JW |
463 | constexpr void |
464 | _M_reset() | |
669a6fdc | 465 | { |
b62dcd16 JW |
466 | if (!_M_valid()) [[unlikely]] |
467 | return; | |
468 | ||
469 | std::__do_visit<void>([](auto&& __this_mem) mutable | |
669a6fdc | 470 | { |
b62dcd16 | 471 | std::_Destroy(std::__addressof(__this_mem)); |
669a6fdc | 472 | }, __variant_cast<_Types...>(*this)); |
197c757c | 473 | |
074436cf | 474 | _M_index = static_cast<__index_type>(variant_npos); |
458ef690 TS |
475 | } |
476 | ||
ad820b0b | 477 | _GLIBCXX20_CONSTEXPR |
9189f559 | 478 | ~_Variant_storage() |
458ef690 | 479 | { _M_reset(); } |
197c757c | 480 | |
70503724 TS |
481 | constexpr bool |
482 | _M_valid() const noexcept | |
483 | { | |
d306dee3 | 484 | if constexpr (__variant::__never_valueless<_Types...>()) |
47a468bd | 485 | return true; |
70503724 TS |
486 | return this->_M_index != __index_type(variant_npos); |
487 | } | |
488 | ||
9189f559 | 489 | _Variadic_union<_Types...> _M_u; |
f3df0b3c VV |
490 | using __index_type = __select_index<_Types...>; |
491 | __index_type _M_index; | |
197c757c TS |
492 | }; |
493 | ||
9189f559 TS |
494 | template<typename... _Types> |
495 | struct _Variant_storage<true, _Types...> | |
197c757c | 496 | { |
074436cf JW |
497 | constexpr |
498 | _Variant_storage() | |
499 | : _M_index(static_cast<__index_type>(variant_npos)) | |
500 | { } | |
197c757c | 501 | |
9189f559 | 502 | template<size_t _Np, typename... _Args> |
074436cf JW |
503 | constexpr |
504 | _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) | |
9189f559 | 505 | : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), |
074436cf | 506 | _M_index{_Np} |
9189f559 TS |
507 | { } |
508 | ||
ad820b0b JW |
509 | constexpr void |
510 | _M_reset() noexcept | |
074436cf | 511 | { _M_index = static_cast<__index_type>(variant_npos); } |
458ef690 | 512 | |
70503724 TS |
513 | constexpr bool |
514 | _M_valid() const noexcept | |
515 | { | |
d306dee3 | 516 | if constexpr (__variant::__never_valueless<_Types...>()) |
16d30bbd | 517 | return true; |
cfb582f6 JW |
518 | // It would be nice if we could just return true for -fno-exceptions. |
519 | // It's possible (but inadvisable) that a std::variant could become | |
520 | // valueless in a translation unit compiled with -fexceptions and then | |
521 | // be passed to functions compiled with -fno-exceptions. We would need | |
522 | // some #ifdef _GLIBCXX_NO_EXCEPTIONS_GLOBALLY property to elide all | |
523 | // checks for valueless_by_exception(). | |
074436cf | 524 | return this->_M_index != static_cast<__index_type>(variant_npos); |
70503724 TS |
525 | } |
526 | ||
9189f559 | 527 | _Variadic_union<_Types...> _M_u; |
f3df0b3c VV |
528 | using __index_type = __select_index<_Types...>; |
529 | __index_type _M_index; | |
197c757c TS |
530 | }; |
531 | ||
a45d577b JW |
532 | // Implementation of v.emplace<N>(args...). |
533 | template<size_t _Np, bool _Triv, typename... _Types, typename... _Args> | |
534 | _GLIBCXX20_CONSTEXPR | |
535 | inline void | |
536 | __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args) | |
537 | { | |
538 | __v._M_reset(); | |
539 | auto* __addr = std::__addressof(__variant::__get_n<_Np>(__v._M_u)); | |
540 | std::_Construct(__addr, std::forward<_Args>(__args)...); | |
541 | // Construction didn't throw, so can set the new index now: | |
542 | __v._M_index = _Np; | |
543 | } | |
544 | ||
197c757c | 545 | template<typename... _Types> |
70503724 | 546 | using _Variant_storage_alias = |
4a15d842 | 547 | _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>; |
197c757c | 548 | |
70503724 TS |
549 | // The following are (Copy|Move) (ctor|assign) layers for forwarding |
550 | // triviality and handling non-trivial SMF behaviors. | |
551 | ||
552 | template<bool, typename... _Types> | |
553 | struct _Copy_ctor_base : _Variant_storage_alias<_Types...> | |
554 | { | |
555 | using _Base = _Variant_storage_alias<_Types...>; | |
556 | using _Base::_Base; | |
197c757c | 557 | |
ad820b0b | 558 | _GLIBCXX20_CONSTEXPR |
70503724 | 559 | _Copy_ctor_base(const _Copy_ctor_base& __rhs) |
4a15d842 | 560 | noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor) |
197c757c | 561 | { |
7551a995 JW |
562 | __variant::__raw_idx_visit( |
563 | [this](auto&& __rhs_mem, auto __rhs_index) mutable | |
564 | { | |
565 | constexpr size_t __j = __rhs_index; | |
566 | if constexpr (__j != variant_npos) | |
567 | std::_Construct(std::__addressof(this->_M_u), | |
568 | in_place_index<__j>, __rhs_mem); | |
569 | }, __variant_cast<_Types...>(__rhs)); | |
570 | this->_M_index = __rhs._M_index; | |
197c757c TS |
571 | } |
572 | ||
70503724 TS |
573 | _Copy_ctor_base(_Copy_ctor_base&&) = default; |
574 | _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default; | |
575 | _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default; | |
576 | }; | |
577 | ||
578 | template<typename... _Types> | |
579 | struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...> | |
580 | { | |
581 | using _Base = _Variant_storage_alias<_Types...>; | |
582 | using _Base::_Base; | |
583 | }; | |
584 | ||
585 | template<typename... _Types> | |
586 | using _Copy_ctor_alias = | |
4a15d842 | 587 | _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>; |
70503724 TS |
588 | |
589 | template<bool, typename... _Types> | |
590 | struct _Move_ctor_base : _Copy_ctor_alias<_Types...> | |
591 | { | |
592 | using _Base = _Copy_ctor_alias<_Types...>; | |
593 | using _Base::_Base; | |
594 | ||
ad820b0b | 595 | _GLIBCXX20_CONSTEXPR |
70503724 | 596 | _Move_ctor_base(_Move_ctor_base&& __rhs) |
4a15d842 | 597 | noexcept(_Traits<_Types...>::_S_nothrow_move_ctor) |
197c757c | 598 | { |
7551a995 JW |
599 | __variant::__raw_idx_visit( |
600 | [this](auto&& __rhs_mem, auto __rhs_index) mutable | |
601 | { | |
602 | constexpr size_t __j = __rhs_index; | |
603 | if constexpr (__j != variant_npos) | |
604 | std::_Construct(std::__addressof(this->_M_u), | |
605 | in_place_index<__j>, | |
606 | std::forward<decltype(__rhs_mem)>(__rhs_mem)); | |
607 | }, __variant_cast<_Types...>(std::move(__rhs))); | |
608 | this->_M_index = __rhs._M_index; | |
669a6fdc | 609 | } |
a45d577b | 610 | |
70503724 TS |
611 | _Move_ctor_base(const _Move_ctor_base&) = default; |
612 | _Move_ctor_base& operator=(const _Move_ctor_base&) = default; | |
613 | _Move_ctor_base& operator=(_Move_ctor_base&&) = default; | |
614 | }; | |
615 | ||
616 | template<typename... _Types> | |
617 | struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...> | |
618 | { | |
619 | using _Base = _Copy_ctor_alias<_Types...>; | |
620 | using _Base::_Base; | |
621 | }; | |
622 | ||
623 | template<typename... _Types> | |
624 | using _Move_ctor_alias = | |
4a15d842 | 625 | _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>; |
70503724 TS |
626 | |
627 | template<bool, typename... _Types> | |
628 | struct _Copy_assign_base : _Move_ctor_alias<_Types...> | |
629 | { | |
630 | using _Base = _Move_ctor_alias<_Types...>; | |
631 | using _Base::_Base; | |
197c757c | 632 | |
ad820b0b | 633 | _GLIBCXX20_CONSTEXPR |
70503724 TS |
634 | _Copy_assign_base& |
635 | operator=(const _Copy_assign_base& __rhs) | |
4a15d842 | 636 | noexcept(_Traits<_Types...>::_S_nothrow_copy_assign) |
197c757c | 637 | { |
956a62aa JW |
638 | __variant::__raw_idx_visit( |
639 | [this](auto&& __rhs_mem, auto __rhs_index) mutable | |
197c757c | 640 | { |
a45d577b JW |
641 | constexpr size_t __j = __rhs_index; |
642 | if constexpr (__j == variant_npos) | |
643 | this->_M_reset(); // Make *this valueless. | |
644 | else if (this->_M_index == __j) | |
645 | __variant::__get<__j>(*this) = __rhs_mem; | |
646 | else | |
197c757c | 647 | { |
a45d577b JW |
648 | using _Tj = typename _Nth_type<__j, _Types...>::type; |
649 | if constexpr (is_nothrow_copy_constructible_v<_Tj> | |
650 | || !is_nothrow_move_constructible_v<_Tj>) | |
651 | __variant::__emplace<__j>(*this, __rhs_mem); | |
f1ba6c5a VV |
652 | else |
653 | { | |
a45d577b JW |
654 | using _Variant = variant<_Types...>; |
655 | _Variant& __self = __variant_cast<_Types...>(*this); | |
656 | __self = _Variant(in_place_index<__j>, __rhs_mem); | |
669a6fdc | 657 | } |
669a6fdc | 658 | } |
f1ba6c5a | 659 | }, __variant_cast<_Types...>(__rhs)); |
197c757c TS |
660 | return *this; |
661 | } | |
662 | ||
70503724 TS |
663 | _Copy_assign_base(const _Copy_assign_base&) = default; |
664 | _Copy_assign_base(_Copy_assign_base&&) = default; | |
665 | _Copy_assign_base& operator=(_Copy_assign_base&&) = default; | |
666 | }; | |
667 | ||
668 | template<typename... _Types> | |
669 | struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...> | |
670 | { | |
671 | using _Base = _Move_ctor_alias<_Types...>; | |
672 | using _Base::_Base; | |
673 | }; | |
674 | ||
675 | template<typename... _Types> | |
676 | using _Copy_assign_alias = | |
038bc9bf | 677 | _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>; |
70503724 TS |
678 | |
679 | template<bool, typename... _Types> | |
680 | struct _Move_assign_base : _Copy_assign_alias<_Types...> | |
681 | { | |
682 | using _Base = _Copy_assign_alias<_Types...>; | |
683 | using _Base::_Base; | |
684 | ||
ad820b0b | 685 | _GLIBCXX20_CONSTEXPR |
70503724 TS |
686 | _Move_assign_base& |
687 | operator=(_Move_assign_base&& __rhs) | |
4a15d842 | 688 | noexcept(_Traits<_Types...>::_S_nothrow_move_assign) |
197c757c | 689 | { |
956a62aa JW |
690 | __variant::__raw_idx_visit( |
691 | [this](auto&& __rhs_mem, auto __rhs_index) mutable | |
197c757c | 692 | { |
a45d577b JW |
693 | constexpr size_t __j = __rhs_index; |
694 | if constexpr (__j != variant_npos) | |
197c757c | 695 | { |
a45d577b JW |
696 | if (this->_M_index == __j) |
697 | __variant::__get<__j>(*this) = std::move(__rhs_mem); | |
f1ba6c5a | 698 | else |
a45d577b JW |
699 | { |
700 | using _Tj = typename _Nth_type<__j, _Types...>::type; | |
701 | if constexpr (is_nothrow_move_constructible_v<_Tj>) | |
702 | __variant::__emplace<__j>(*this, std::move(__rhs_mem)); | |
703 | else | |
704 | { | |
705 | using _Variant = variant<_Types...>; | |
706 | _Variant& __self = __variant_cast<_Types...>(*this); | |
707 | __self.template emplace<__j>(std::move(__rhs_mem)); | |
708 | } | |
709 | } | |
197c757c | 710 | } |
669a6fdc | 711 | else |
f1ba6c5a | 712 | this->_M_reset(); |
f1ba6c5a | 713 | }, __variant_cast<_Types...>(__rhs)); |
197c757c TS |
714 | return *this; |
715 | } | |
716 | ||
70503724 TS |
717 | _Move_assign_base(const _Move_assign_base&) = default; |
718 | _Move_assign_base(_Move_assign_base&&) = default; | |
719 | _Move_assign_base& operator=(const _Move_assign_base&) = default; | |
720 | }; | |
197c757c | 721 | |
70503724 TS |
722 | template<typename... _Types> |
723 | struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...> | |
724 | { | |
725 | using _Base = _Copy_assign_alias<_Types...>; | |
726 | using _Base::_Base; | |
727 | }; | |
728 | ||
729 | template<typename... _Types> | |
730 | using _Move_assign_alias = | |
9d89b73c | 731 | _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>; |
70503724 TS |
732 | |
733 | template<typename... _Types> | |
734 | struct _Variant_base : _Move_assign_alias<_Types...> | |
735 | { | |
736 | using _Base = _Move_assign_alias<_Types...>; | |
737 | ||
738 | constexpr | |
ad820b0b | 739 | _Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor) |
70503724 TS |
740 | : _Variant_base(in_place_index<0>) { } |
741 | ||
742 | template<size_t _Np, typename... _Args> | |
743 | constexpr explicit | |
744 | _Variant_base(in_place_index_t<_Np> __i, _Args&&... __args) | |
745 | : _Base(__i, std::forward<_Args>(__args)...) | |
746 | { } | |
747 | ||
748 | _Variant_base(const _Variant_base&) = default; | |
749 | _Variant_base(_Variant_base&&) = default; | |
750 | _Variant_base& operator=(const _Variant_base&) = default; | |
751 | _Variant_base& operator=(_Variant_base&&) = default; | |
197c757c TS |
752 | }; |
753 | ||
197c757c | 754 | template<typename _Tp, typename... _Types> |
b57899f3 JW |
755 | inline constexpr bool __exactly_once |
756 | = std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types); | |
197c757c | 757 | |
d069df01 JW |
758 | // Helper used to check for valid conversions that don't involve narrowing. |
759 | template<typename _Ti> struct _Arr { _Ti _M_x[1]; }; | |
197c757c | 760 | |
c98fc4eb JW |
761 | // "Build an imaginary function FUN(Ti) for each alternative type Ti" |
762 | template<size_t _Ind, typename _Tp, typename _Ti, typename = void> | |
d069df01 | 763 | struct _Build_FUN |
197c757c | 764 | { |
d069df01 JW |
765 | // This function means 'using _Build_FUN<I, T, Ti>::_S_fun;' is valid, |
766 | // but only static functions will be considered in the call below. | |
da55353e | 767 | void _S_fun() = delete; |
197c757c TS |
768 | }; |
769 | ||
c98fc4eb | 770 | // "... for which Ti x[] = {std::forward<T>(t)}; is well-formed." |
d069df01 | 771 | template<size_t _Ind, typename _Tp, typename _Ti> |
c98fc4eb | 772 | struct _Build_FUN<_Ind, _Tp, _Ti, |
d069df01 | 773 | void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}})>> |
197c757c | 774 | { |
d069df01 JW |
775 | // This is the FUN function for type _Ti, with index _Ind |
776 | static integral_constant<size_t, _Ind> _S_fun(_Ti); | |
197c757c TS |
777 | }; |
778 | ||
d069df01 JW |
779 | template<typename _Tp, typename _Variant, |
780 | typename = make_index_sequence<variant_size_v<_Variant>>> | |
781 | struct _Build_FUNs; | |
782 | ||
783 | template<typename _Tp, typename... _Ti, size_t... _Ind> | |
784 | struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>> | |
785 | : _Build_FUN<_Ind, _Tp, _Ti>... | |
197c757c | 786 | { |
d069df01 | 787 | using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...; |
197c757c TS |
788 | }; |
789 | ||
d069df01 JW |
790 | // The index j of the overload FUN(Tj) selected by overload resolution |
791 | // for FUN(std::forward<_Tp>(t)) | |
792 | template<typename _Tp, typename _Variant> | |
793 | using _FUN_type | |
794 | = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>())); | |
795 | ||
796 | // The index selected for FUN(std::forward<T>(t)), or variant_npos if none. | |
797 | template<typename _Tp, typename _Variant, typename = void> | |
da55353e JW |
798 | inline constexpr size_t |
799 | __accepted_index = variant_npos; | |
d069df01 JW |
800 | |
801 | template<typename _Tp, typename _Variant> | |
da55353e JW |
802 | inline constexpr size_t |
803 | __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>> | |
804 | = _FUN_type<_Tp, _Variant>::value; | |
d069df01 | 805 | |
da55353e JW |
806 | template<typename _Maybe_variant_cookie, typename _Variant, |
807 | typename = __remove_cvref_t<_Variant>> | |
808 | inline constexpr bool | |
809 | __extra_visit_slot_needed = false; | |
da97b98a | 810 | |
da55353e JW |
811 | template<typename _Var, typename... _Types> |
812 | inline constexpr bool | |
813 | __extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>> | |
814 | = !__variant::__never_valueless<_Types...>(); | |
da97b98a | 815 | |
da55353e JW |
816 | template<typename _Var, typename... _Types> |
817 | inline constexpr bool | |
818 | __extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types...>> | |
819 | = !__variant::__never_valueless<_Types...>(); | |
da97b98a | 820 | |
9d89b73c | 821 | // Used for storing a multi-dimensional vtable. |
197c757c | 822 | template<typename _Tp, size_t... _Dimensions> |
9d89b73c JW |
823 | struct _Multi_array; |
824 | ||
825 | // Partial specialization with rank zero, stores a single _Tp element. | |
826 | template<typename _Tp> | |
827 | struct _Multi_array<_Tp> | |
197c757c | 828 | { |
956a62aa JW |
829 | template<typename> |
830 | struct __untag_result | |
831 | : false_type | |
832 | { using element_type = _Tp; }; | |
833 | ||
cf35818a JW |
834 | #pragma GCC diagnostic push |
835 | #pragma GCC diagnostic ignored "-Wignored-qualifiers" | |
956a62aa JW |
836 | template <typename... _Args> |
837 | struct __untag_result<const void(*)(_Args...)> | |
838 | : false_type | |
839 | { using element_type = void(*)(_Args...); }; | |
cf35818a | 840 | #pragma GCC diagnostic pop |
956a62aa JW |
841 | |
842 | template <typename... _Args> | |
843 | struct __untag_result<__variant_cookie(*)(_Args...)> | |
844 | : false_type | |
845 | { using element_type = void(*)(_Args...); }; | |
846 | ||
847 | template <typename... _Args> | |
848 | struct __untag_result<__variant_idx_cookie(*)(_Args...)> | |
849 | : false_type | |
850 | { using element_type = void(*)(_Args...); }; | |
851 | ||
852 | template <typename _Res, typename... _Args> | |
853 | struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)> | |
854 | : true_type | |
855 | { using element_type = _Res(*)(_Args...); }; | |
856 | ||
857 | using __result_is_deduced = __untag_result<_Tp>; | |
858 | ||
859 | constexpr const typename __untag_result<_Tp>::element_type& | |
197c757c TS |
860 | _M_access() const |
861 | { return _M_data; } | |
862 | ||
956a62aa | 863 | typename __untag_result<_Tp>::element_type _M_data; |
197c757c TS |
864 | }; |
865 | ||
9d89b73c | 866 | // Partial specialization with rank >= 1. |
669a6fdc VV |
867 | template<typename _Ret, |
868 | typename _Visitor, | |
869 | typename... _Variants, | |
870 | size_t __first, size_t... __rest> | |
871 | struct _Multi_array<_Ret(*)(_Visitor, _Variants...), __first, __rest...> | |
197c757c | 872 | { |
da97b98a VV |
873 | static constexpr size_t __index = |
874 | sizeof...(_Variants) - sizeof...(__rest) - 1; | |
9d89b73c | 875 | |
da97b98a | 876 | using _Variant = typename _Nth_type<__index, _Variants...>::type; |
9d89b73c | 877 | |
669a6fdc | 878 | static constexpr int __do_cookie = |
da55353e | 879 | __extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0; |
9d89b73c | 880 | |
669a6fdc | 881 | using _Tp = _Ret(*)(_Visitor, _Variants...); |
9d89b73c | 882 | |
197c757c | 883 | template<typename... _Args> |
956a62aa | 884 | constexpr decltype(auto) |
197c757c | 885 | _M_access(size_t __first_index, _Args... __rest_indices) const |
9d89b73c JW |
886 | { |
887 | return _M_arr[__first_index + __do_cookie] | |
888 | ._M_access(__rest_indices...); | |
889 | } | |
197c757c | 890 | |
669a6fdc | 891 | _Multi_array<_Tp, __rest...> _M_arr[__first + __do_cookie]; |
197c757c TS |
892 | }; |
893 | ||
894 | // Creates a multi-dimensional vtable recursively. | |
197c757c TS |
895 | // |
896 | // For example, | |
897 | // visit([](auto, auto){}, | |
b01af236 TS |
898 | // variant<int, char>(), // typedef'ed as V1 |
899 | // variant<float, double, long double>()) // typedef'ed as V2 | |
197c757c | 900 | // will trigger instantiations of: |
956a62aa | 901 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 2, 3>, |
b01af236 | 902 | // tuple<V1&&, V2&&>, std::index_sequence<>> |
956a62aa | 903 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>, |
b01af236 | 904 | // tuple<V1&&, V2&&>, std::index_sequence<0>> |
956a62aa | 905 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 906 | // tuple<V1&&, V2&&>, std::index_sequence<0, 0>> |
956a62aa | 907 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 908 | // tuple<V1&&, V2&&>, std::index_sequence<0, 1>> |
956a62aa | 909 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 910 | // tuple<V1&&, V2&&>, std::index_sequence<0, 2>> |
956a62aa | 911 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>, |
b01af236 | 912 | // tuple<V1&&, V2&&>, std::index_sequence<1>> |
956a62aa | 913 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 914 | // tuple<V1&&, V2&&>, std::index_sequence<1, 0>> |
956a62aa | 915 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 916 | // tuple<V1&&, V2&&>, std::index_sequence<1, 1>> |
956a62aa | 917 | // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>, |
b01af236 | 918 | // tuple<V1&&, V2&&>, std::index_sequence<1, 2>> |
197c757c TS |
919 | // The returned multi-dimensional vtable can be fast accessed by the visitor |
920 | // using index calculation. | |
956a62aa | 921 | template<typename _Array_type, typename _Index_seq> |
197c757c TS |
922 | struct __gen_vtable_impl; |
923 | ||
9d89b73c JW |
924 | // Defines the _S_apply() member that returns a _Multi_array populated |
925 | // with function pointers that perform the visitation expressions e(m) | |
926 | // for each valid pack of indexes into the variant types _Variants. | |
927 | // | |
928 | // This partial specialization builds up the index sequences by recursively | |
929 | // calling _S_apply() on the next specialization of __gen_vtable_impl. | |
930 | // The base case of the recursion defines the actual function pointers. | |
956a62aa | 931 | template<typename _Result_type, typename _Visitor, size_t... __dimensions, |
b01af236 TS |
932 | typename... _Variants, size_t... __indices> |
933 | struct __gen_vtable_impl< | |
0f9cf7ff | 934 | _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>, |
956a62aa | 935 | std::index_sequence<__indices...>> |
197c757c | 936 | { |
b01af236 TS |
937 | using _Next = |
938 | remove_reference_t<typename _Nth_type<sizeof...(__indices), | |
939 | _Variants...>::type>; | |
940 | using _Array_type = | |
0f9cf7ff TS |
941 | _Multi_array<_Result_type (*)(_Visitor, _Variants...), |
942 | __dimensions...>; | |
b01af236 | 943 | |
197c757c TS |
944 | static constexpr _Array_type |
945 | _S_apply() | |
946 | { | |
947 | _Array_type __vtable{}; | |
948 | _S_apply_all_alts( | |
b01af236 | 949 | __vtable, make_index_sequence<variant_size_v<_Next>>()); |
197c757c TS |
950 | return __vtable; |
951 | } | |
952 | ||
b01af236 | 953 | template<size_t... __var_indices> |
197c757c | 954 | static constexpr void |
b01af236 TS |
955 | _S_apply_all_alts(_Array_type& __vtable, |
956 | std::index_sequence<__var_indices...>) | |
957 | { | |
da55353e | 958 | if constexpr (__extra_visit_slot_needed<_Result_type, _Next>) |
669a6fdc VV |
959 | (_S_apply_single_alt<true, __var_indices>( |
960 | __vtable._M_arr[__var_indices + 1], | |
961 | &(__vtable._M_arr[0])), ...); | |
962 | else | |
963 | (_S_apply_single_alt<false, __var_indices>( | |
964 | __vtable._M_arr[__var_indices]), ...); | |
b01af236 | 965 | } |
197c757c | 966 | |
669a6fdc | 967 | template<bool __do_cookie, size_t __index, typename _Tp> |
197c757c | 968 | static constexpr void |
669a6fdc | 969 | _S_apply_single_alt(_Tp& __element, _Tp* __cookie_element = nullptr) |
197c757c | 970 | { |
669a6fdc VV |
971 | if constexpr (__do_cookie) |
972 | { | |
973 | __element = __gen_vtable_impl< | |
974 | _Tp, | |
669a6fdc VV |
975 | std::index_sequence<__indices..., __index>>::_S_apply(); |
976 | *__cookie_element = __gen_vtable_impl< | |
977 | _Tp, | |
669a6fdc VV |
978 | std::index_sequence<__indices..., variant_npos>>::_S_apply(); |
979 | } | |
980 | else | |
981 | { | |
1f65bf2a | 982 | auto __tmp_element = __gen_vtable_impl< |
956a62aa | 983 | remove_reference_t<decltype(__element)>, |
669a6fdc | 984 | std::index_sequence<__indices..., __index>>::_S_apply(); |
1f65bf2a VV |
985 | static_assert(is_same_v<_Tp, decltype(__tmp_element)>, |
986 | "std::visit requires the visitor to have the same " | |
987 | "return type for all alternatives of a variant"); | |
988 | __element = __tmp_element; | |
669a6fdc | 989 | } |
197c757c TS |
990 | } |
991 | }; | |
992 | ||
9d89b73c JW |
993 | // This partial specialization is the base case for the recursion. |
994 | // It populates a _Multi_array element with the address of a function | |
995 | // that invokes the visitor with the alternatives specified by __indices. | |
956a62aa | 996 | template<typename _Result_type, typename _Visitor, typename... _Variants, |
b01af236 | 997 | size_t... __indices> |
197c757c | 998 | struct __gen_vtable_impl< |
b01af236 | 999 | _Multi_array<_Result_type (*)(_Visitor, _Variants...)>, |
956a62aa | 1000 | std::index_sequence<__indices...>> |
197c757c TS |
1001 | { |
1002 | using _Array_type = | |
9d89b73c | 1003 | _Multi_array<_Result_type (*)(_Visitor, _Variants...)>; |
b01af236 | 1004 | |
669a6fdc VV |
1005 | template<size_t __index, typename _Variant> |
1006 | static constexpr decltype(auto) | |
be46043e | 1007 | __element_by_index_or_cookie(_Variant&& __var) noexcept |
669a6fdc VV |
1008 | { |
1009 | if constexpr (__index != variant_npos) | |
1010 | return __variant::__get<__index>(std::forward<_Variant>(__var)); | |
1011 | else | |
1012 | return __variant_cookie{}; | |
1013 | } | |
1014 | ||
469218a3 | 1015 | static constexpr decltype(auto) |
956a62aa | 1016 | __visit_invoke(_Visitor&& __visitor, _Variants... __vars) |
b01af236 | 1017 | { |
9d89b73c | 1018 | if constexpr (is_same_v<_Result_type, __variant_idx_cookie>) |
956a62aa JW |
1019 | // For raw visitation using indices, pass the indices to the visitor |
1020 | // and discard the return value: | |
1021 | std::__invoke(std::forward<_Visitor>(__visitor), | |
9d89b73c JW |
1022 | __element_by_index_or_cookie<__indices>( |
1023 | std::forward<_Variants>(__vars))..., | |
1024 | integral_constant<size_t, __indices>()...); | |
956a62aa JW |
1025 | else if constexpr (is_same_v<_Result_type, __variant_cookie>) |
1026 | // For raw visitation without indices, and discard the return value: | |
1027 | std::__invoke(std::forward<_Visitor>(__visitor), | |
9d89b73c JW |
1028 | __element_by_index_or_cookie<__indices>( |
1029 | std::forward<_Variants>(__vars))...); | |
956a62aa JW |
1030 | else if constexpr (_Array_type::__result_is_deduced::value) |
1031 | // For the usual std::visit case deduce the return value: | |
f1ba6c5a | 1032 | return std::__invoke(std::forward<_Visitor>(__visitor), |
9d89b73c JW |
1033 | __element_by_index_or_cookie<__indices>( |
1034 | std::forward<_Variants>(__vars))...); | |
956a62aa JW |
1035 | else // for std::visit<R> use INVOKE<R> |
1036 | return std::__invoke_r<_Result_type>( | |
1037 | std::forward<_Visitor>(__visitor), | |
1038 | __variant::__get<__indices>(std::forward<_Variants>(__vars))...); | |
3d01c7c2 VV |
1039 | } |
1040 | ||
197c757c TS |
1041 | static constexpr auto |
1042 | _S_apply() | |
3427e313 VV |
1043 | { |
1044 | if constexpr (_Array_type::__result_is_deduced::value) | |
1045 | { | |
1046 | constexpr bool __visit_ret_type_mismatch = | |
1047 | !is_same_v<typename _Result_type::type, | |
1048 | decltype(__visit_invoke(std::declval<_Visitor>(), | |
1049 | std::declval<_Variants>()...))>; | |
1050 | if constexpr (__visit_ret_type_mismatch) | |
1051 | { | |
1f65bf2a VV |
1052 | struct __cannot_match {}; |
1053 | return __cannot_match{}; | |
3427e313 VV |
1054 | } |
1055 | else | |
1056 | return _Array_type{&__visit_invoke}; | |
1057 | } | |
1058 | else | |
1059 | return _Array_type{&__visit_invoke}; | |
1060 | } | |
197c757c TS |
1061 | }; |
1062 | ||
956a62aa | 1063 | template<typename _Result_type, typename _Visitor, typename... _Variants> |
197c757c TS |
1064 | struct __gen_vtable |
1065 | { | |
197c757c | 1066 | using _Array_type = |
9d89b73c | 1067 | _Multi_array<_Result_type (*)(_Visitor, _Variants...), |
11767f80 | 1068 | variant_size_v<remove_reference_t<_Variants>>...>; |
197c757c | 1069 | |
9d89b73c | 1070 | static constexpr _Array_type _S_vtable |
956a62aa | 1071 | = __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply(); |
197c757c TS |
1072 | }; |
1073 | ||
458ef690 TS |
1074 | template<size_t _Np, typename _Tp> |
1075 | struct _Base_dedup : public _Tp { }; | |
1076 | ||
1077 | template<typename _Variant, typename __indices> | |
1078 | struct _Variant_hash_base; | |
1079 | ||
1080 | template<typename... _Types, size_t... __indices> | |
1081 | struct _Variant_hash_base<variant<_Types...>, | |
1082 | std::index_sequence<__indices...>> | |
1083 | : _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { }; | |
1084 | ||
c46ecb01 JW |
1085 | // Equivalent to decltype(get<_Np>(as-variant(declval<_Variant>()))) |
1086 | template<size_t _Np, typename _Variant, | |
1087 | typename _AsV = decltype(__variant::__as(std::declval<_Variant>())), | |
1088 | typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>> | |
1089 | using __get_t | |
a09bb4a8 | 1090 | = __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>; |
af5b2b91 JW |
1091 | |
1092 | // Return type of std::visit. | |
1093 | template<typename _Visitor, typename... _Variants> | |
1094 | using __visit_result_t | |
1095 | = invoke_result_t<_Visitor, __get_t<0, _Variants>...>; | |
1096 | ||
1097 | template<typename _Tp, typename... _Types> | |
1098 | constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...); | |
1099 | ||
1100 | template <typename _Visitor, typename _Variant, size_t... _Idxs> | |
1101 | constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>) | |
1102 | { | |
1103 | return __same_types< | |
1104 | invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>... | |
1105 | >; | |
1106 | } | |
1107 | ||
e27771e5 JW |
1108 | } // namespace __variant |
1109 | } // namespace __detail | |
1110 | ||
197c757c | 1111 | template<typename _Tp, typename... _Types> |
469218a3 JW |
1112 | constexpr bool |
1113 | holds_alternative(const variant<_Types...>& __v) noexcept | |
197c757c TS |
1114 | { |
1115 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1116 | "T must occur exactly once in alternatives"); |
b57899f3 | 1117 | return __v.index() == std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
197c757c TS |
1118 | } |
1119 | ||
197c757c | 1120 | template<typename _Tp, typename... _Types> |
b57899f3 JW |
1121 | constexpr _Tp& |
1122 | get(variant<_Types...>& __v) | |
197c757c TS |
1123 | { |
1124 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1125 | "T must occur exactly once in alternatives"); |
801b2266 | 1126 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1127 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1128 | return std::get<__n>(__v); | |
197c757c TS |
1129 | } |
1130 | ||
1131 | template<typename _Tp, typename... _Types> | |
b57899f3 JW |
1132 | constexpr _Tp&& |
1133 | get(variant<_Types...>&& __v) | |
197c757c TS |
1134 | { |
1135 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1136 | "T must occur exactly once in alternatives"); |
801b2266 | 1137 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1138 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1139 | return std::get<__n>(std::move(__v)); | |
197c757c TS |
1140 | } |
1141 | ||
1142 | template<typename _Tp, typename... _Types> | |
b57899f3 JW |
1143 | constexpr const _Tp& |
1144 | get(const variant<_Types...>& __v) | |
197c757c TS |
1145 | { |
1146 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1147 | "T must occur exactly once in alternatives"); |
801b2266 | 1148 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1149 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1150 | return std::get<__n>(__v); | |
197c757c TS |
1151 | } |
1152 | ||
1153 | template<typename _Tp, typename... _Types> | |
b57899f3 JW |
1154 | constexpr const _Tp&& |
1155 | get(const variant<_Types...>&& __v) | |
197c757c TS |
1156 | { |
1157 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1158 | "T must occur exactly once in alternatives"); |
801b2266 | 1159 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1160 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1161 | return std::get<__n>(std::move(__v)); | |
197c757c TS |
1162 | } |
1163 | ||
1164 | template<size_t _Np, typename... _Types> | |
469218a3 | 1165 | constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>> |
197c757c TS |
1166 | get_if(variant<_Types...>* __ptr) noexcept |
1167 | { | |
1168 | using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>; | |
1169 | static_assert(_Np < sizeof...(_Types), | |
801b2266 JW |
1170 | "The index must be in [0, number of alternatives)"); |
1171 | static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void"); | |
197c757c | 1172 | if (__ptr && __ptr->index() == _Np) |
669a6fdc | 1173 | return std::addressof(__detail::__variant::__get<_Np>(*__ptr)); |
197c757c TS |
1174 | return nullptr; |
1175 | } | |
1176 | ||
1177 | template<size_t _Np, typename... _Types> | |
469218a3 | 1178 | constexpr |
9189f559 | 1179 | add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>> |
197c757c TS |
1180 | get_if(const variant<_Types...>* __ptr) noexcept |
1181 | { | |
1182 | using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>; | |
1183 | static_assert(_Np < sizeof...(_Types), | |
801b2266 JW |
1184 | "The index must be in [0, number of alternatives)"); |
1185 | static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void"); | |
197c757c | 1186 | if (__ptr && __ptr->index() == _Np) |
669a6fdc | 1187 | return std::addressof(__detail::__variant::__get<_Np>(*__ptr)); |
197c757c TS |
1188 | return nullptr; |
1189 | } | |
1190 | ||
1191 | template<typename _Tp, typename... _Types> | |
469218a3 | 1192 | constexpr add_pointer_t<_Tp> |
9189f559 | 1193 | get_if(variant<_Types...>* __ptr) noexcept |
197c757c TS |
1194 | { |
1195 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1196 | "T must occur exactly once in alternatives"); |
801b2266 | 1197 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1198 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1199 | return std::get_if<__n>(__ptr); | |
197c757c TS |
1200 | } |
1201 | ||
1202 | template<typename _Tp, typename... _Types> | |
469218a3 | 1203 | constexpr add_pointer_t<const _Tp> |
be46043e | 1204 | get_if(const variant<_Types...>* __ptr) noexcept |
197c757c TS |
1205 | { |
1206 | static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, | |
c43c3af2 | 1207 | "T must occur exactly once in alternatives"); |
801b2266 | 1208 | static_assert(!is_void_v<_Tp>, "_Tp must not be void"); |
b57899f3 JW |
1209 | constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); |
1210 | return std::get_if<__n>(__ptr); | |
197c757c TS |
1211 | } |
1212 | ||
d255829b | 1213 | struct monostate { }; |
197c757c | 1214 | |
d255829b TS |
1215 | #define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \ |
1216 | template<typename... _Types> \ | |
1217 | constexpr bool operator __OP(const variant<_Types...>& __lhs, \ | |
1218 | const variant<_Types...>& __rhs) \ | |
1219 | { \ | |
669a6fdc | 1220 | bool __ret = true; \ |
956a62aa JW |
1221 | __detail::__variant::__raw_idx_visit( \ |
1222 | [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable \ | |
669a6fdc | 1223 | { \ |
f1ba6c5a VV |
1224 | if constexpr (__rhs_index != variant_npos) \ |
1225 | { \ | |
1226 | if (__lhs.index() == __rhs_index) \ | |
1227 | { \ | |
1228 | auto& __this_mem = std::get<__rhs_index>(__lhs); \ | |
1229 | __ret = __this_mem __OP __rhs_mem; \ | |
1230 | } \ | |
1231 | else \ | |
1232 | __ret = (__lhs.index() + 1) __OP (__rhs_index + 1); \ | |
1233 | } \ | |
1234 | else \ | |
1235 | __ret = (__lhs.index() + 1) __OP (__rhs_index + 1); \ | |
f1ba6c5a | 1236 | }, __rhs); \ |
669a6fdc | 1237 | return __ret; \ |
9e589880 | 1238 | } |
d255829b TS |
1239 | |
1240 | _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less) | |
1241 | _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal) | |
1242 | _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal) | |
1243 | _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal) | |
1244 | _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal) | |
1245 | _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater) | |
1246 | ||
1247 | #undef _VARIANT_RELATION_FUNCTION_TEMPLATE | |
197c757c | 1248 | |
9e589880 JW |
1249 | constexpr bool operator==(monostate, monostate) noexcept { return true; } |
1250 | ||
1251 | #ifdef __cpp_lib_three_way_comparison | |
1252 | template<typename... _Types> | |
1253 | requires (three_way_comparable<_Types> && ...) | |
1254 | constexpr | |
1255 | common_comparison_category_t<compare_three_way_result_t<_Types>...> | |
1256 | operator<=>(const variant<_Types...>& __v, const variant<_Types...>& __w) | |
1257 | { | |
1258 | common_comparison_category_t<compare_three_way_result_t<_Types>...> __ret | |
1259 | = strong_ordering::equal; | |
1260 | ||
1261 | __detail::__variant::__raw_idx_visit( | |
1262 | [&__ret, &__v] (auto&& __w_mem, auto __w_index) mutable | |
1263 | { | |
1264 | if constexpr (__w_index != variant_npos) | |
1265 | { | |
1266 | if (__v.index() == __w_index) | |
1267 | { | |
1268 | auto& __this_mem = std::get<__w_index>(__v); | |
1269 | __ret = __this_mem <=> __w_mem; | |
1270 | return; | |
1271 | } | |
1272 | } | |
1273 | __ret = (__v.index() + 1) <=> (__w_index + 1); | |
1274 | }, __w); | |
1275 | return __ret; | |
1276 | } | |
1277 | ||
1278 | constexpr strong_ordering | |
1279 | operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; } | |
1280 | #else | |
1281 | constexpr bool operator!=(monostate, monostate) noexcept { return false; } | |
1282 | constexpr bool operator<(monostate, monostate) noexcept { return false; } | |
1283 | constexpr bool operator>(monostate, monostate) noexcept { return false; } | |
1284 | constexpr bool operator<=(monostate, monostate) noexcept { return true; } | |
1285 | constexpr bool operator>=(monostate, monostate) noexcept { return true; } | |
1286 | #endif | |
1287 | ||
197c757c | 1288 | template<typename _Visitor, typename... _Variants> |
af5b2b91 JW |
1289 | constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...> |
1290 | visit(_Visitor&&, _Variants&&...); | |
197c757c | 1291 | |
197c757c | 1292 | template<typename... _Types> |
ad820b0b | 1293 | _GLIBCXX20_CONSTEXPR |
458ef690 TS |
1294 | inline enable_if_t<(is_move_constructible_v<_Types> && ...) |
1295 | && (is_swappable_v<_Types> && ...)> | |
a2863bde VV |
1296 | swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) |
1297 | noexcept(noexcept(__lhs.swap(__rhs))) | |
197c757c TS |
1298 | { __lhs.swap(__rhs); } |
1299 | ||
a2863bde | 1300 | template<typename... _Types> |
258ee761 BA |
1301 | enable_if_t<!((is_move_constructible_v<_Types> && ...) |
1302 | && (is_swappable_v<_Types> && ...))> | |
a2863bde VV |
1303 | swap(variant<_Types...>&, variant<_Types...>&) = delete; |
1304 | ||
197c757c TS |
1305 | class bad_variant_access : public exception |
1306 | { | |
1307 | public: | |
c43c3af2 JW |
1308 | bad_variant_access() noexcept { } |
1309 | ||
197c757c TS |
1310 | const char* what() const noexcept override |
1311 | { return _M_reason; } | |
1312 | ||
1313 | private: | |
c43c3af2 | 1314 | bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) { } |
197c757c | 1315 | |
c43c3af2 JW |
1316 | // Must point to a string with static storage duration: |
1317 | const char* _M_reason = "bad variant access"; | |
197c757c TS |
1318 | |
1319 | friend void __throw_bad_variant_access(const char* __what); | |
1320 | }; | |
1321 | ||
c43c3af2 | 1322 | // Must only be called with a string literal |
197c757c TS |
1323 | inline void |
1324 | __throw_bad_variant_access(const char* __what) | |
1325 | { _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__what)); } | |
1326 | ||
c43c3af2 JW |
1327 | inline void |
1328 | __throw_bad_variant_access(bool __valueless) | |
1329 | { | |
1330 | if (__valueless) [[__unlikely__]] | |
1331 | __throw_bad_variant_access("std::get: variant is valueless"); | |
1332 | else | |
1333 | __throw_bad_variant_access("std::get: wrong index for variant"); | |
1334 | } | |
1335 | ||
197c757c TS |
1336 | template<typename... _Types> |
1337 | class variant | |
1338 | : private __detail::__variant::_Variant_base<_Types...>, | |
1339 | private _Enable_default_constructor< | |
4a15d842 | 1340 | __detail::__variant::_Traits<_Types...>::_S_default_ctor, |
70503724 | 1341 | variant<_Types...>>, |
197c757c | 1342 | private _Enable_copy_move< |
4a15d842 FD |
1343 | __detail::__variant::_Traits<_Types...>::_S_copy_ctor, |
1344 | __detail::__variant::_Traits<_Types...>::_S_copy_assign, | |
1345 | __detail::__variant::_Traits<_Types...>::_S_move_ctor, | |
1346 | __detail::__variant::_Traits<_Types...>::_S_move_assign, | |
197c757c TS |
1347 | variant<_Types...>> |
1348 | { | |
1349 | private: | |
669a6fdc | 1350 | template <typename... _UTypes, typename _Tp> |
ad820b0b JW |
1351 | friend _GLIBCXX20_CONSTEXPR decltype(auto) |
1352 | __variant_cast(_Tp&&); | |
1353 | ||
7b277e8b TS |
1354 | static_assert(sizeof...(_Types) > 0, |
1355 | "variant must have at least one alternative"); | |
1356 | static_assert(!(std::is_reference_v<_Types> || ...), | |
1357 | "variant must have no reference alternative"); | |
1358 | static_assert(!(std::is_void_v<_Types> || ...), | |
1359 | "variant must have no void alternative"); | |
1360 | ||
197c757c TS |
1361 | using _Base = __detail::__variant::_Variant_base<_Types...>; |
1362 | using _Default_ctor_enabler = | |
4a15d842 FD |
1363 | _Enable_default_constructor< |
1364 | __detail::__variant::_Traits<_Types...>::_S_default_ctor, | |
1365 | variant<_Types...>>; | |
197c757c | 1366 | |
06715e1c JW |
1367 | template<typename _Tp> |
1368 | static constexpr bool __not_self | |
1369 | = !is_same_v<__remove_cvref_t<_Tp>, variant>; | |
1370 | ||
197c757c TS |
1371 | template<typename _Tp> |
1372 | static constexpr bool | |
1373 | __exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>; | |
1374 | ||
1375 | template<typename _Tp> | |
d069df01 | 1376 | static constexpr size_t __accepted_index |
da55353e | 1377 | = __detail::__variant::__accepted_index<_Tp, variant>; |
197c757c | 1378 | |
06715e1c | 1379 | template<size_t _Np, typename = enable_if_t<(_Np < sizeof...(_Types))>> |
09aab7e6 | 1380 | using __to_type = typename _Nth_type<_Np, _Types...>::type; |
197c757c | 1381 | |
06715e1c | 1382 | template<typename _Tp, typename = enable_if_t<__not_self<_Tp>>> |
197c757c TS |
1383 | using __accepted_type = __to_type<__accepted_index<_Tp>>; |
1384 | ||
197c757c | 1385 | template<typename _Tp> |
b57899f3 JW |
1386 | static constexpr size_t __index_of |
1387 | = std::__find_uniq_type_in_pack<_Tp, _Types...>(); | |
197c757c | 1388 | |
70503724 TS |
1389 | using _Traits = __detail::__variant::_Traits<_Types...>; |
1390 | ||
06715e1c JW |
1391 | template<typename _Tp> |
1392 | struct __is_in_place_tag : false_type { }; | |
1393 | template<typename _Tp> | |
1394 | struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { }; | |
1395 | template<size_t _Np> | |
1396 | struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { }; | |
1397 | ||
1398 | template<typename _Tp> | |
1399 | static constexpr bool __not_in_place_tag | |
1400 | = !__is_in_place_tag<__remove_cvref_t<_Tp>>::value; | |
1401 | ||
197c757c | 1402 | public: |
70503724 TS |
1403 | variant() = default; |
1404 | variant(const variant& __rhs) = default; | |
1405 | variant(variant&&) = default; | |
1406 | variant& operator=(const variant&) = default; | |
1407 | variant& operator=(variant&&) = default; | |
ad820b0b | 1408 | _GLIBCXX20_CONSTEXPR ~variant() = default; |
197c757c TS |
1409 | |
1410 | template<typename _Tp, | |
06715e1c JW |
1411 | typename = enable_if_t<sizeof...(_Types) != 0>, |
1412 | typename = enable_if_t<__not_in_place_tag<_Tp>>, | |
1413 | typename _Tj = __accepted_type<_Tp&&>, | |
1414 | typename = enable_if_t<__exactly_once<_Tj> | |
1415 | && is_constructible_v<_Tj, _Tp>>> | |
197c757c TS |
1416 | constexpr |
1417 | variant(_Tp&& __t) | |
06715e1c | 1418 | noexcept(is_nothrow_constructible_v<_Tj, _Tp>) |
d069df01 | 1419 | : variant(in_place_index<__accepted_index<_Tp>>, |
4a15d842 | 1420 | std::forward<_Tp>(__t)) |
59e36c85 | 1421 | { } |
197c757c TS |
1422 | |
1423 | template<typename _Tp, typename... _Args, | |
1424 | typename = enable_if_t<__exactly_once<_Tp> | |
06715e1c | 1425 | && is_constructible_v<_Tp, _Args...>>> |
197c757c TS |
1426 | constexpr explicit |
1427 | variant(in_place_type_t<_Tp>, _Args&&... __args) | |
70503724 | 1428 | : variant(in_place_index<__index_of<_Tp>>, |
4a15d842 | 1429 | std::forward<_Args>(__args)...) |
59e36c85 | 1430 | { } |
197c757c TS |
1431 | |
1432 | template<typename _Tp, typename _Up, typename... _Args, | |
1433 | typename = enable_if_t<__exactly_once<_Tp> | |
06715e1c JW |
1434 | && is_constructible_v<_Tp, |
1435 | initializer_list<_Up>&, _Args...>>> | |
197c757c TS |
1436 | constexpr explicit |
1437 | variant(in_place_type_t<_Tp>, initializer_list<_Up> __il, | |
1438 | _Args&&... __args) | |
627a2f59 | 1439 | : variant(in_place_index<__index_of<_Tp>>, __il, |
64626fca | 1440 | std::forward<_Args>(__args)...) |
59e36c85 | 1441 | { } |
197c757c TS |
1442 | |
1443 | template<size_t _Np, typename... _Args, | |
06715e1c JW |
1444 | typename _Tp = __to_type<_Np>, |
1445 | typename = enable_if_t<is_constructible_v<_Tp, _Args...>>> | |
197c757c TS |
1446 | constexpr explicit |
1447 | variant(in_place_index_t<_Np>, _Args&&... __args) | |
627a2f59 | 1448 | : _Base(in_place_index<_Np>, std::forward<_Args>(__args)...), |
197c757c | 1449 | _Default_ctor_enabler(_Enable_default_constructor_tag{}) |
59e36c85 | 1450 | { } |
197c757c TS |
1451 | |
1452 | template<size_t _Np, typename _Up, typename... _Args, | |
06715e1c JW |
1453 | typename _Tp = __to_type<_Np>, |
1454 | typename = enable_if_t<is_constructible_v<_Tp, | |
1455 | initializer_list<_Up>&, | |
1456 | _Args...>>> | |
197c757c TS |
1457 | constexpr explicit |
1458 | variant(in_place_index_t<_Np>, initializer_list<_Up> __il, | |
1459 | _Args&&... __args) | |
627a2f59 | 1460 | : _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...), |
197c757c | 1461 | _Default_ctor_enabler(_Enable_default_constructor_tag{}) |
59e36c85 | 1462 | { } |
197c757c | 1463 | |
197c757c | 1464 | template<typename _Tp> |
ad820b0b | 1465 | _GLIBCXX20_CONSTEXPR |
197c757c | 1466 | enable_if_t<__exactly_once<__accepted_type<_Tp&&>> |
06715e1c JW |
1467 | && is_constructible_v<__accepted_type<_Tp&&>, _Tp> |
1468 | && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>, | |
1469 | variant&> | |
197c757c | 1470 | operator=(_Tp&& __rhs) |
06715e1c JW |
1471 | noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp> |
1472 | && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>) | |
197c757c | 1473 | { |
d069df01 | 1474 | constexpr auto __index = __accepted_index<_Tp>; |
197c757c | 1475 | if (index() == __index) |
c42bc5d7 | 1476 | std::get<__index>(*this) = std::forward<_Tp>(__rhs); |
197c757c | 1477 | else |
86a57ce1 JW |
1478 | { |
1479 | using _Tj = __accepted_type<_Tp&&>; | |
1480 | if constexpr (is_nothrow_constructible_v<_Tj, _Tp> | |
1481 | || !is_nothrow_move_constructible_v<_Tj>) | |
1482 | this->emplace<__index>(std::forward<_Tp>(__rhs)); | |
1483 | else | |
1484 | operator=(variant(std::forward<_Tp>(__rhs))); | |
1485 | } | |
197c757c TS |
1486 | return *this; |
1487 | } | |
1488 | ||
1489 | template<typename _Tp, typename... _Args> | |
ad820b0b | 1490 | _GLIBCXX20_CONSTEXPR |
df990182 VV |
1491 | enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>, |
1492 | _Tp&> | |
458ef690 | 1493 | emplace(_Args&&... __args) |
197c757c | 1494 | { |
59e36c85 JW |
1495 | constexpr size_t __index = __index_of<_Tp>; |
1496 | return this->emplace<__index>(std::forward<_Args>(__args)...); | |
197c757c TS |
1497 | } |
1498 | ||
1499 | template<typename _Tp, typename _Up, typename... _Args> | |
ad820b0b | 1500 | _GLIBCXX20_CONSTEXPR |
458ef690 | 1501 | enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...> |
df990182 VV |
1502 | && __exactly_once<_Tp>, |
1503 | _Tp&> | |
458ef690 | 1504 | emplace(initializer_list<_Up> __il, _Args&&... __args) |
197c757c | 1505 | { |
59e36c85 JW |
1506 | constexpr size_t __index = __index_of<_Tp>; |
1507 | return this->emplace<__index>(__il, std::forward<_Args>(__args)...); | |
197c757c TS |
1508 | } |
1509 | ||
1510 | template<size_t _Np, typename... _Args> | |
ad820b0b | 1511 | _GLIBCXX20_CONSTEXPR |
30ab6d9e JW |
1512 | enable_if_t<is_constructible_v<__to_type<_Np>, _Args...>, |
1513 | __to_type<_Np>&> | |
458ef690 | 1514 | emplace(_Args&&... __args) |
197c757c | 1515 | { |
e27771e5 | 1516 | namespace __variant = std::__detail::__variant; |
09aab7e6 | 1517 | using type = typename _Nth_type<_Np, _Types...>::type; |
10f26de9 JW |
1518 | // Provide the strong exception-safety guarantee when possible, |
1519 | // to avoid becoming valueless. | |
1520 | if constexpr (is_nothrow_constructible_v<type, _Args...>) | |
1521 | { | |
a45d577b | 1522 | __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...); |
10f26de9 JW |
1523 | } |
1524 | else if constexpr (is_scalar_v<type>) | |
caf80d87 | 1525 | { |
10f26de9 JW |
1526 | // This might invoke a potentially-throwing conversion operator: |
1527 | const type __tmp(std::forward<_Args>(__args)...); | |
a45d577b JW |
1528 | // But this won't throw: |
1529 | __variant::__emplace<_Np>(*this, __tmp); | |
10f26de9 | 1530 | } |
e27771e5 | 1531 | else if constexpr (__variant::_Never_valueless_alt<type>() |
47a468bd | 1532 | && _Traits::_S_move_assign) |
10f26de9 JW |
1533 | { |
1534 | // This construction might throw: | |
caf80d87 JW |
1535 | variant __tmp(in_place_index<_Np>, |
1536 | std::forward<_Args>(__args)...); | |
10f26de9 | 1537 | // But _Never_valueless_alt<type> means this won't: |
caf80d87 | 1538 | *this = std::move(__tmp); |
197c757c | 1539 | } |
10f26de9 | 1540 | else |
197c757c | 1541 | { |
10f26de9 JW |
1542 | // This case only provides the basic exception-safety guarantee, |
1543 | // i.e. the variant can become valueless. | |
a45d577b | 1544 | __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...); |
197c757c | 1545 | } |
df990182 | 1546 | return std::get<_Np>(*this); |
197c757c TS |
1547 | } |
1548 | ||
1549 | template<size_t _Np, typename _Up, typename... _Args> | |
ad820b0b | 1550 | _GLIBCXX20_CONSTEXPR |
30ab6d9e | 1551 | enable_if_t<is_constructible_v<__to_type<_Np>, |
df990182 | 1552 | initializer_list<_Up>&, _Args...>, |
30ab6d9e | 1553 | __to_type<_Np>&> |
458ef690 | 1554 | emplace(initializer_list<_Up> __il, _Args&&... __args) |
197c757c | 1555 | { |
e27771e5 | 1556 | namespace __variant = std::__detail::__variant; |
09aab7e6 | 1557 | using type = typename _Nth_type<_Np, _Types...>::type; |
10f26de9 JW |
1558 | // Provide the strong exception-safety guarantee when possible, |
1559 | // to avoid becoming valueless. | |
1560 | if constexpr (is_nothrow_constructible_v<type, | |
1561 | initializer_list<_Up>&, | |
1562 | _Args...>) | |
caf80d87 | 1563 | { |
a45d577b JW |
1564 | __variant::__emplace<_Np>(*this, __il, |
1565 | std::forward<_Args>(__args)...); | |
10f26de9 | 1566 | } |
e27771e5 | 1567 | else if constexpr (__variant::_Never_valueless_alt<type>() |
47a468bd | 1568 | && _Traits::_S_move_assign) |
10f26de9 JW |
1569 | { |
1570 | // This construction might throw: | |
caf80d87 JW |
1571 | variant __tmp(in_place_index<_Np>, __il, |
1572 | std::forward<_Args>(__args)...); | |
10f26de9 | 1573 | // But _Never_valueless_alt<type> means this won't: |
caf80d87 | 1574 | *this = std::move(__tmp); |
197c757c | 1575 | } |
10f26de9 | 1576 | else |
197c757c | 1577 | { |
10f26de9 JW |
1578 | // This case only provides the basic exception-safety guarantee, |
1579 | // i.e. the variant can become valueless. | |
a45d577b JW |
1580 | __variant::__emplace<_Np>(*this, __il, |
1581 | std::forward<_Args>(__args)...); | |
197c757c | 1582 | } |
df990182 | 1583 | return std::get<_Np>(*this); |
197c757c TS |
1584 | } |
1585 | ||
30ab6d9e JW |
1586 | template<size_t _Np, typename... _Args> |
1587 | enable_if_t<!(_Np < sizeof...(_Types))> emplace(_Args&&...) = delete; | |
1588 | ||
1589 | template<typename _Tp, typename... _Args> | |
1590 | enable_if_t<!__exactly_once<_Tp>> emplace(_Args&&...) = delete; | |
1591 | ||
197c757c TS |
1592 | constexpr bool valueless_by_exception() const noexcept |
1593 | { return !this->_M_valid(); } | |
1594 | ||
1595 | constexpr size_t index() const noexcept | |
1e8822d3 JW |
1596 | { |
1597 | using __index_type = typename _Base::__index_type; | |
fe69bee3 | 1598 | if constexpr (__detail::__variant::__never_valueless<_Types...>()) |
1e8822d3 JW |
1599 | return this->_M_index; |
1600 | else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2) | |
1601 | return make_signed_t<__index_type>(this->_M_index); | |
1602 | else | |
1603 | return size_t(__index_type(this->_M_index + 1)) - 1; | |
1604 | } | |
197c757c | 1605 | |
ad820b0b | 1606 | _GLIBCXX20_CONSTEXPR |
197c757c TS |
1607 | void |
1608 | swap(variant& __rhs) | |
258ee761 | 1609 | noexcept((__is_nothrow_swappable<_Types>::value && ...) |
458ef690 | 1610 | && is_nothrow_move_constructible_v<variant>) |
197c757c | 1611 | { |
a45d577b JW |
1612 | static_assert((is_move_constructible_v<_Types> && ...)); |
1613 | ||
1614 | // Handle this here to simplify the visitation. | |
1615 | if (__rhs.valueless_by_exception()) [[__unlikely__]] | |
1616 | { | |
1617 | if (!this->valueless_by_exception()) [[__likely__]] | |
1618 | __rhs.swap(*this); | |
1619 | return; | |
1620 | } | |
1621 | ||
1622 | namespace __variant = __detail::__variant; | |
1623 | ||
1624 | __variant::__raw_idx_visit( | |
956a62aa | 1625 | [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable |
197c757c | 1626 | { |
a45d577b JW |
1627 | constexpr size_t __j = __rhs_index; |
1628 | if constexpr (__j != variant_npos) | |
197c757c | 1629 | { |
a45d577b | 1630 | if (this->index() == __j) |
669a6fdc VV |
1631 | { |
1632 | using std::swap; | |
a45d577b | 1633 | swap(std::get<__j>(*this), __rhs_mem); |
669a6fdc | 1634 | } |
f1ba6c5a VV |
1635 | else |
1636 | { | |
a45d577b JW |
1637 | auto __tmp(std::move(__rhs_mem)); |
1638 | ||
1639 | if constexpr (_Traits::_S_trivial_move_assign) | |
1640 | __rhs = std::move(*this); | |
f1ba6c5a | 1641 | else |
a45d577b JW |
1642 | __variant::__raw_idx_visit( |
1643 | [&__rhs](auto&& __this_mem, auto __this_index) mutable | |
1644 | { | |
1645 | constexpr size_t __k = __this_index; | |
1646 | if constexpr (__k != variant_npos) | |
1647 | __variant::__emplace<__k>(__rhs, | |
1648 | std::move(__this_mem)); | |
1649 | }, *this); | |
1650 | ||
1651 | __variant::__emplace<__j>(*this, std::move(__tmp)); | |
669a6fdc | 1652 | } |
669a6fdc | 1653 | } |
f1ba6c5a | 1654 | }, __rhs); |
197c757c TS |
1655 | } |
1656 | ||
08233f0d | 1657 | #if defined(__clang__) && __clang_major__ <= 7 |
aafaa325 JW |
1658 | public: |
1659 | using _Base::_M_u; // See https://bugs.llvm.org/show_bug.cgi?id=31852 | |
aafaa325 JW |
1660 | #endif |
1661 | ||
a45d577b | 1662 | private: |
9189f559 | 1663 | template<size_t _Np, typename _Vp> |
4b7a3ab8 JW |
1664 | friend constexpr decltype(auto) |
1665 | __detail::__variant::__get(_Vp&& __v) noexcept; | |
9189f559 | 1666 | |
d255829b TS |
1667 | #define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP) \ |
1668 | template<typename... _Tp> \ | |
1669 | friend constexpr bool \ | |
1670 | operator __OP(const variant<_Tp...>& __lhs, \ | |
1671 | const variant<_Tp...>& __rhs); | |
1672 | ||
1673 | _VARIANT_RELATION_FUNCTION_TEMPLATE(<) | |
1674 | _VARIANT_RELATION_FUNCTION_TEMPLATE(<=) | |
1675 | _VARIANT_RELATION_FUNCTION_TEMPLATE(==) | |
1676 | _VARIANT_RELATION_FUNCTION_TEMPLATE(!=) | |
1677 | _VARIANT_RELATION_FUNCTION_TEMPLATE(>=) | |
1678 | _VARIANT_RELATION_FUNCTION_TEMPLATE(>) | |
9189f559 | 1679 | |
d255829b | 1680 | #undef _VARIANT_RELATION_FUNCTION_TEMPLATE |
197c757c TS |
1681 | }; |
1682 | ||
197c757c | 1683 | template<size_t _Np, typename... _Types> |
9189f559 | 1684 | constexpr variant_alternative_t<_Np, variant<_Types...>>& |
197c757c TS |
1685 | get(variant<_Types...>& __v) |
1686 | { | |
1687 | static_assert(_Np < sizeof...(_Types), | |
801b2266 | 1688 | "The index must be in [0, number of alternatives)"); |
197c757c | 1689 | if (__v.index() != _Np) |
c43c3af2 | 1690 | __throw_bad_variant_access(__v.valueless_by_exception()); |
9189f559 | 1691 | return __detail::__variant::__get<_Np>(__v); |
197c757c TS |
1692 | } |
1693 | ||
1694 | template<size_t _Np, typename... _Types> | |
9189f559 | 1695 | constexpr variant_alternative_t<_Np, variant<_Types...>>&& |
197c757c TS |
1696 | get(variant<_Types...>&& __v) |
1697 | { | |
1698 | static_assert(_Np < sizeof...(_Types), | |
801b2266 | 1699 | "The index must be in [0, number of alternatives)"); |
197c757c | 1700 | if (__v.index() != _Np) |
c43c3af2 | 1701 | __throw_bad_variant_access(__v.valueless_by_exception()); |
9189f559 | 1702 | return __detail::__variant::__get<_Np>(std::move(__v)); |
197c757c TS |
1703 | } |
1704 | ||
1705 | template<size_t _Np, typename... _Types> | |
9189f559 | 1706 | constexpr const variant_alternative_t<_Np, variant<_Types...>>& |
197c757c TS |
1707 | get(const variant<_Types...>& __v) |
1708 | { | |
1709 | static_assert(_Np < sizeof...(_Types), | |
801b2266 | 1710 | "The index must be in [0, number of alternatives)"); |
197c757c | 1711 | if (__v.index() != _Np) |
c43c3af2 | 1712 | __throw_bad_variant_access(__v.valueless_by_exception()); |
9189f559 | 1713 | return __detail::__variant::__get<_Np>(__v); |
197c757c TS |
1714 | } |
1715 | ||
1716 | template<size_t _Np, typename... _Types> | |
9189f559 | 1717 | constexpr const variant_alternative_t<_Np, variant<_Types...>>&& |
197c757c TS |
1718 | get(const variant<_Types...>&& __v) |
1719 | { | |
1720 | static_assert(_Np < sizeof...(_Types), | |
801b2266 | 1721 | "The index must be in [0, number of alternatives)"); |
197c757c | 1722 | if (__v.index() != _Np) |
c43c3af2 | 1723 | __throw_bad_variant_access(__v.valueless_by_exception()); |
9189f559 | 1724 | return __detail::__variant::__get<_Np>(std::move(__v)); |
197c757c TS |
1725 | } |
1726 | ||
6963c3b9 | 1727 | /// @cond undocumented |
956a62aa | 1728 | template<typename _Result_type, typename _Visitor, typename... _Variants> |
b01af236 | 1729 | constexpr decltype(auto) |
669a6fdc | 1730 | __do_visit(_Visitor&& __visitor, _Variants&&... __variants) |
197c757c | 1731 | { |
cfb582f6 JW |
1732 | // Get the silly case of visiting no variants out of the way first. |
1733 | if constexpr (sizeof...(_Variants) == 0) | |
e85bb188 JW |
1734 | { |
1735 | if constexpr (is_void_v<_Result_type>) | |
1736 | return (void) std::forward<_Visitor>(__visitor)(); | |
1737 | else | |
1738 | return std::forward<_Visitor>(__visitor)(); | |
1739 | } | |
cfb582f6 JW |
1740 | else |
1741 | { | |
1742 | constexpr size_t __max = 11; // "These go to eleven." | |
1743 | ||
1744 | // The type of the first variant in the pack. | |
09aab7e6 | 1745 | using _V0 = typename _Nth_type<0, _Variants...>::type; |
cfb582f6 JW |
1746 | // The number of alternatives in that first variant. |
1747 | constexpr auto __n = variant_size_v<remove_reference_t<_V0>>; | |
1748 | ||
1749 | if constexpr (sizeof...(_Variants) > 1 || __n > __max) | |
1750 | { | |
1751 | // Use a jump table for the general case. | |
1752 | constexpr auto& __vtable = __detail::__variant::__gen_vtable< | |
1753 | _Result_type, _Visitor&&, _Variants&&...>::_S_vtable; | |
1754 | ||
1755 | auto __func_ptr = __vtable._M_access(__variants.index()...); | |
1756 | return (*__func_ptr)(std::forward<_Visitor>(__visitor), | |
1757 | std::forward<_Variants>(__variants)...); | |
1758 | } | |
1759 | else // We have a single variant with a small number of alternatives. | |
1760 | { | |
1761 | // A name for the first variant in the pack. | |
1762 | _V0& __v0 | |
1763 | = [](_V0& __v, ...) -> _V0& { return __v; }(__variants...); | |
1764 | ||
1765 | using __detail::__variant::_Multi_array; | |
1766 | using __detail::__variant::__gen_vtable_impl; | |
1767 | using _Ma = _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>; | |
b01af236 | 1768 | |
cfb582f6 JW |
1769 | #ifdef _GLIBCXX_DEBUG |
1770 | # define _GLIBCXX_VISIT_UNREACHABLE __builtin_trap | |
1771 | #else | |
1772 | # define _GLIBCXX_VISIT_UNREACHABLE __builtin_unreachable | |
1773 | #endif | |
1774 | ||
1775 | #define _GLIBCXX_VISIT_CASE(N) \ | |
1776 | case N: \ | |
1777 | { \ | |
1778 | if constexpr (N < __n) \ | |
1779 | { \ | |
1780 | return __gen_vtable_impl<_Ma, index_sequence<N>>:: \ | |
1781 | __visit_invoke(std::forward<_Visitor>(__visitor), \ | |
1782 | std::forward<_V0>(__v0)); \ | |
1783 | } \ | |
1784 | else _GLIBCXX_VISIT_UNREACHABLE(); \ | |
1785 | } | |
1786 | ||
1787 | switch (__v0.index()) | |
1788 | { | |
1789 | _GLIBCXX_VISIT_CASE(0) | |
1790 | _GLIBCXX_VISIT_CASE(1) | |
1791 | _GLIBCXX_VISIT_CASE(2) | |
1792 | _GLIBCXX_VISIT_CASE(3) | |
1793 | _GLIBCXX_VISIT_CASE(4) | |
1794 | _GLIBCXX_VISIT_CASE(5) | |
1795 | _GLIBCXX_VISIT_CASE(6) | |
1796 | _GLIBCXX_VISIT_CASE(7) | |
1797 | _GLIBCXX_VISIT_CASE(8) | |
1798 | _GLIBCXX_VISIT_CASE(9) | |
1799 | _GLIBCXX_VISIT_CASE(10) | |
1800 | case variant_npos: | |
1801 | using __detail::__variant::__variant_idx_cookie; | |
1802 | using __detail::__variant::__variant_cookie; | |
1803 | if constexpr (is_same_v<_Result_type, __variant_idx_cookie> | |
1804 | || is_same_v<_Result_type, __variant_cookie>) | |
1805 | { | |
dc1b2950 JW |
1806 | using _Npos = index_sequence<variant_npos>; |
1807 | return __gen_vtable_impl<_Ma, _Npos>:: | |
cfb582f6 JW |
1808 | __visit_invoke(std::forward<_Visitor>(__visitor), |
1809 | std::forward<_V0>(__v0)); | |
1810 | } | |
1811 | else | |
1812 | _GLIBCXX_VISIT_UNREACHABLE(); | |
1813 | default: | |
1814 | _GLIBCXX_VISIT_UNREACHABLE(); | |
1815 | } | |
1816 | #undef _GLIBCXX_VISIT_CASE | |
1817 | #undef _GLIBCXX_VISIT_UNREACHABLE | |
1818 | } | |
1819 | } | |
197c757c | 1820 | } |
6963c3b9 | 1821 | /// @endcond |
197c757c | 1822 | |
669a6fdc | 1823 | template<typename _Visitor, typename... _Variants> |
af5b2b91 | 1824 | constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...> |
669a6fdc VV |
1825 | visit(_Visitor&& __visitor, _Variants&&... __variants) |
1826 | { | |
c46ecb01 JW |
1827 | namespace __variant = std::__detail::__variant; |
1828 | ||
1829 | if ((__variant::__as(__variants).valueless_by_exception() || ...)) | |
c43c3af2 | 1830 | __throw_bad_variant_access("std::visit: variant is valueless"); |
669a6fdc | 1831 | |
af5b2b91 JW |
1832 | using _Result_type |
1833 | = __detail::__variant::__visit_result_t<_Visitor, _Variants...>; | |
956a62aa JW |
1834 | |
1835 | using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>; | |
1836 | ||
3427e313 VV |
1837 | if constexpr (sizeof...(_Variants) == 1) |
1838 | { | |
c46ecb01 JW |
1839 | using _Vp = decltype(__variant::__as(std::declval<_Variants>()...)); |
1840 | ||
af5b2b91 | 1841 | constexpr bool __visit_rettypes_match = __detail::__variant:: |
c46ecb01 JW |
1842 | __check_visitor_results<_Visitor, _Vp>( |
1843 | make_index_sequence<variant_size_v<remove_reference_t<_Vp>>>()); | |
3427e313 VV |
1844 | if constexpr (!__visit_rettypes_match) |
1845 | { | |
1846 | static_assert(__visit_rettypes_match, | |
1847 | "std::visit requires the visitor to have the same " | |
1848 | "return type for all alternatives of a variant"); | |
1849 | return; | |
1850 | } | |
1851 | else | |
1852 | return std::__do_visit<_Tag>( | |
1853 | std::forward<_Visitor>(__visitor), | |
c46ecb01 | 1854 | static_cast<_Vp>(__variants)...); |
3427e313 VV |
1855 | } |
1856 | else | |
1857 | return std::__do_visit<_Tag>( | |
1858 | std::forward<_Visitor>(__visitor), | |
c46ecb01 | 1859 | __variant::__as(std::forward<_Variants>(__variants))...); |
669a6fdc VV |
1860 | } |
1861 | ||
199b20e3 JW |
1862 | #if __cplusplus > 201703L |
1863 | template<typename _Res, typename _Visitor, typename... _Variants> | |
1864 | constexpr _Res | |
1865 | visit(_Visitor&& __visitor, _Variants&&... __variants) | |
1866 | { | |
c46ecb01 JW |
1867 | namespace __variant = std::__detail::__variant; |
1868 | ||
1869 | if ((__variant::__as(__variants).valueless_by_exception() || ...)) | |
c43c3af2 | 1870 | __throw_bad_variant_access("std::visit<R>: variant is valueless"); |
199b20e3 | 1871 | |
e5d7010b | 1872 | return std::__do_visit<_Res>(std::forward<_Visitor>(__visitor), |
c46ecb01 | 1873 | __variant::__as(std::forward<_Variants>(__variants))...); |
199b20e3 JW |
1874 | } |
1875 | #endif | |
1876 | ||
6963c3b9 | 1877 | /// @cond undocumented |
509912a6 VV |
1878 | template<bool, typename... _Types> |
1879 | struct __variant_hash_call_base_impl | |
197c757c | 1880 | { |
197c757c TS |
1881 | size_t |
1882 | operator()(const variant<_Types...>& __t) const | |
7dcc645c | 1883 | noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...)) |
197c757c | 1884 | { |
669a6fdc | 1885 | size_t __ret; |
956a62aa JW |
1886 | __detail::__variant::__raw_visit( |
1887 | [&__t, &__ret](auto&& __t_mem) mutable | |
197c757c | 1888 | { |
669a6fdc VV |
1889 | using _Type = __remove_cvref_t<decltype(__t_mem)>; |
1890 | if constexpr (!is_same_v<_Type, | |
1891 | __detail::__variant::__variant_cookie>) | |
1892 | __ret = std::hash<size_t>{}(__t.index()) | |
1893 | + std::hash<_Type>{}(__t_mem); | |
1894 | else | |
1895 | __ret = std::hash<size_t>{}(__t.index()); | |
669a6fdc VV |
1896 | }, __t); |
1897 | return __ret; | |
197c757c TS |
1898 | } |
1899 | }; | |
1900 | ||
509912a6 VV |
1901 | template<typename... _Types> |
1902 | struct __variant_hash_call_base_impl<false, _Types...> {}; | |
1903 | ||
1904 | template<typename... _Types> | |
1905 | using __variant_hash_call_base = | |
1906 | __variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>:: | |
1907 | __enable_hash_call &&...), _Types...>; | |
6963c3b9 | 1908 | /// @endcond |
509912a6 VV |
1909 | |
1910 | template<typename... _Types> | |
1911 | struct hash<variant<_Types...>> | |
1912 | : private __detail::__variant::_Variant_hash_base< | |
4a15d842 | 1913 | variant<_Types...>, std::index_sequence_for<_Types...>>, |
509912a6 VV |
1914 | public __variant_hash_call_base<_Types...> |
1915 | { | |
f78958c9 JW |
1916 | using result_type [[__deprecated__]] = size_t; |
1917 | using argument_type [[__deprecated__]] = variant<_Types...>; | |
509912a6 VV |
1918 | }; |
1919 | ||
197c757c TS |
1920 | template<> |
1921 | struct hash<monostate> | |
1922 | { | |
f78958c9 JW |
1923 | using result_type [[__deprecated__]] = size_t; |
1924 | using argument_type [[__deprecated__]] = monostate; | |
197c757c TS |
1925 | |
1926 | size_t | |
801b2266 | 1927 | operator()(const monostate&) const noexcept |
197c757c TS |
1928 | { |
1929 | constexpr size_t __magic_monostate_hash = -7777; | |
1930 | return __magic_monostate_hash; | |
1931 | } | |
1932 | }; | |
1933 | ||
f78958c9 JW |
1934 | template<typename... _Types> |
1935 | struct __is_fast_hash<hash<variant<_Types...>>> | |
1936 | : bool_constant<(__is_fast_hash<_Types>::value && ...)> | |
1937 | { }; | |
1938 | ||
197c757c TS |
1939 | _GLIBCXX_END_NAMESPACE_VERSION |
1940 | } // namespace std | |
1941 | ||
1942 | #endif // C++17 | |
1943 | ||
1944 | #endif // _GLIBCXX_VARIANT |