1 | // <tuple> -*- C++ -*- |
2 | |
3 | // Copyright (C) 2007-2024 Free Software Foundation, Inc. |
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 include/tuple |
26 | * This is a Standard C++ Library header. |
27 | */ |
28 | |
29 | #ifndef _GLIBCXX_TUPLE |
30 | #define _GLIBCXX_TUPLE 1 |
31 | |
32 | #pragma GCC system_header |
33 | |
34 | #if __cplusplus < 201103L |
35 | # include <bits/c++0x_warning.h> |
36 | #else |
37 | |
38 | #include <bits/stl_pair.h> // for std::pair |
39 | #include <bits/uses_allocator.h> // for std::allocator_arg_t |
40 | #include <bits/utility.h> // for std::tuple_size etc. |
41 | #include <bits/invoke.h> // for std::__invoke |
42 | #if __cplusplus > 201703L |
43 | # include <compare> |
44 | # include <bits/ranges_util.h> // for std::ranges::subrange |
45 | #endif |
46 | |
47 | #define __glibcxx_want_constexpr_tuple |
48 | #define __glibcxx_want_tuple_element_t |
49 | #define __glibcxx_want_tuples_by_type |
50 | #define __glibcxx_want_apply |
51 | #define __glibcxx_want_make_from_tuple |
52 | #define __glibcxx_want_ranges_zip |
53 | #define __glibcxx_want_tuple_like |
54 | #include <bits/version.h> |
55 | |
56 | namespace std _GLIBCXX_VISIBILITY(default) |
57 | { |
58 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
59 | |
60 | /** |
61 | * @addtogroup utilities |
62 | * @{ |
63 | */ |
64 | |
65 | template<typename... _Elements> |
66 | class tuple; |
67 | |
68 | template<typename _Tp> |
69 | struct __is_empty_non_tuple : is_empty<_Tp> { }; |
70 | |
71 | // Using EBO for elements that are tuples causes ambiguous base errors. |
72 | template<typename _El0, typename... _El> |
73 | struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { }; |
74 | |
75 | // Use the Empty Base-class Optimization for empty, non-final types. |
76 | template<typename _Tp> |
77 | using __empty_not_final |
78 | = __conditional_t<__is_final(_Tp), false_type, |
79 | __is_empty_non_tuple<_Tp>>; |
80 | |
81 | template<size_t _Idx, typename _Head, |
82 | bool = __empty_not_final<_Head>::value> |
83 | struct _Head_base; |
84 | |
85 | #if __has_cpp_attribute(__no_unique_address__) |
86 | template<size_t _Idx, typename _Head> |
87 | struct _Head_base<_Idx, _Head, true> |
88 | { |
89 | constexpr _Head_base() |
90 | : _M_head_impl() { } |
91 | |
92 | constexpr _Head_base(const _Head& __h) |
93 | : _M_head_impl(__h) { } |
94 | |
95 | constexpr _Head_base(const _Head_base&) = default; |
96 | constexpr _Head_base(_Head_base&&) = default; |
97 | |
98 | template<typename _UHead> |
99 | constexpr _Head_base(_UHead&& __h) |
100 | : _M_head_impl(std::forward<_UHead>(__h)) { } |
101 | |
102 | _GLIBCXX20_CONSTEXPR |
103 | _Head_base(allocator_arg_t, __uses_alloc0) |
104 | : _M_head_impl() { } |
105 | |
106 | template<typename _Alloc> |
107 | _GLIBCXX20_CONSTEXPR |
108 | _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) |
109 | : _M_head_impl(allocator_arg, *__a._M_a) { } |
110 | |
111 | template<typename _Alloc> |
112 | _GLIBCXX20_CONSTEXPR |
113 | _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) |
114 | : _M_head_impl(*__a._M_a) { } |
115 | |
116 | template<typename _UHead> |
117 | _GLIBCXX20_CONSTEXPR |
118 | _Head_base(__uses_alloc0, _UHead&& __uhead) |
119 | : _M_head_impl(std::forward<_UHead>(__uhead)) { } |
120 | |
121 | template<typename _Alloc, typename _UHead> |
122 | _GLIBCXX20_CONSTEXPR |
123 | _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) |
124 | : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) |
125 | { } |
126 | |
127 | template<typename _Alloc, typename _UHead> |
128 | _GLIBCXX20_CONSTEXPR |
129 | _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) |
130 | : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } |
131 | |
132 | static constexpr _Head& |
133 | (_Head_base& __b) noexcept { return __b._M_head_impl; } |
134 | |
135 | static constexpr const _Head& |
136 | (const _Head_base& __b) noexcept { return __b._M_head_impl; } |
137 | |
138 | [[__no_unique_address__]] _Head _M_head_impl; |
139 | }; |
140 | #else |
141 | template<size_t _Idx, typename _Head> |
142 | struct _Head_base<_Idx, _Head, true> |
143 | : public _Head |
144 | { |
145 | constexpr _Head_base() |
146 | : _Head() { } |
147 | |
148 | constexpr _Head_base(const _Head& __h) |
149 | : _Head(__h) { } |
150 | |
151 | constexpr _Head_base(const _Head_base&) = default; |
152 | constexpr _Head_base(_Head_base&&) = default; |
153 | |
154 | template<typename _UHead> |
155 | constexpr _Head_base(_UHead&& __h) |
156 | : _Head(std::forward<_UHead>(__h)) { } |
157 | |
158 | _GLIBCXX20_CONSTEXPR |
159 | _Head_base(allocator_arg_t, __uses_alloc0) |
160 | : _Head() { } |
161 | |
162 | template<typename _Alloc> |
163 | _GLIBCXX20_CONSTEXPR |
164 | _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) |
165 | : _Head(allocator_arg, *__a._M_a) { } |
166 | |
167 | template<typename _Alloc> |
168 | _GLIBCXX20_CONSTEXPR |
169 | _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) |
170 | : _Head(*__a._M_a) { } |
171 | |
172 | template<typename _UHead> |
173 | _GLIBCXX20_CONSTEXPR |
174 | _Head_base(__uses_alloc0, _UHead&& __uhead) |
175 | : _Head(std::forward<_UHead>(__uhead)) { } |
176 | |
177 | template<typename _Alloc, typename _UHead> |
178 | _GLIBCXX20_CONSTEXPR |
179 | _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) |
180 | : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } |
181 | |
182 | template<typename _Alloc, typename _UHead> |
183 | _GLIBCXX20_CONSTEXPR |
184 | _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) |
185 | : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } |
186 | |
187 | static constexpr _Head& |
188 | _M_head(_Head_base& __b) noexcept { return __b; } |
189 | |
190 | static constexpr const _Head& |
191 | _M_head(const _Head_base& __b) noexcept { return __b; } |
192 | }; |
193 | #endif |
194 | |
195 | template<size_t _Idx, typename _Head> |
196 | struct _Head_base<_Idx, _Head, false> |
197 | { |
198 | constexpr _Head_base() |
199 | : _M_head_impl() { } |
200 | |
201 | constexpr _Head_base(const _Head& __h) |
202 | : _M_head_impl(__h) { } |
203 | |
204 | constexpr _Head_base(const _Head_base&) = default; |
205 | constexpr _Head_base(_Head_base&&) = default; |
206 | |
207 | template<typename _UHead> |
208 | constexpr _Head_base(_UHead&& __h) |
209 | : _M_head_impl(std::forward<_UHead>(__h)) { } |
210 | |
211 | _GLIBCXX20_CONSTEXPR |
212 | _Head_base(allocator_arg_t, __uses_alloc0) |
213 | : _M_head_impl() { } |
214 | |
215 | template<typename _Alloc> |
216 | _GLIBCXX20_CONSTEXPR |
217 | _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) |
218 | : _M_head_impl(allocator_arg, *__a._M_a) { } |
219 | |
220 | template<typename _Alloc> |
221 | _GLIBCXX20_CONSTEXPR |
222 | _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) |
223 | : _M_head_impl(*__a._M_a) { } |
224 | |
225 | template<typename _UHead> |
226 | _GLIBCXX20_CONSTEXPR |
227 | _Head_base(__uses_alloc0, _UHead&& __uhead) |
228 | : _M_head_impl(std::forward<_UHead>(__uhead)) { } |
229 | |
230 | template<typename _Alloc, typename _UHead> |
231 | _GLIBCXX20_CONSTEXPR |
232 | _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) |
233 | : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) |
234 | { } |
235 | |
236 | template<typename _Alloc, typename _UHead> |
237 | _GLIBCXX20_CONSTEXPR |
238 | _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) |
239 | : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } |
240 | |
241 | static constexpr _Head& |
242 | (_Head_base& __b) noexcept { return __b._M_head_impl; } |
243 | |
244 | static constexpr const _Head& |
245 | (const _Head_base& __b) noexcept { return __b._M_head_impl; } |
246 | |
247 | _Head _M_head_impl; |
248 | }; |
249 | |
250 | #if __cpp_lib_tuple_like // >= C++23 |
251 | struct __tuple_like_tag_t { explicit __tuple_like_tag_t() = default; }; |
252 | |
253 | // These forward declarations are used by the operator<=> overload for |
254 | // tuple-like types. |
255 | template<typename _Cat, typename _Tp, typename _Up> |
256 | constexpr _Cat |
257 | __tuple_cmp(const _Tp&, const _Up&, index_sequence<>); |
258 | |
259 | template<typename _Cat, typename _Tp, typename _Up, |
260 | size_t _Idx0, size_t... _Idxs> |
261 | constexpr _Cat |
262 | __tuple_cmp(const _Tp& __t, const _Up& __u, |
263 | index_sequence<_Idx0, _Idxs...>); |
264 | #endif // C++23 |
265 | |
266 | /** |
267 | * Contains the actual implementation of the @c tuple template, stored |
268 | * as a recursive inheritance hierarchy from the first element (most |
269 | * derived class) to the last (least derived class). The @c Idx |
270 | * parameter gives the 0-based index of the element stored at this |
271 | * point in the hierarchy; we use it to implement a constant-time |
272 | * get() operation. |
273 | */ |
274 | template<size_t _Idx, typename... _Elements> |
275 | struct _Tuple_impl; |
276 | |
277 | /** |
278 | * Recursive tuple implementation. Here we store the @c Head element |
279 | * and derive from a @c Tuple_impl containing the remaining elements |
280 | * (which contains the @c Tail). |
281 | */ |
282 | template<size_t _Idx, typename _Head, typename... _Tail> |
283 | struct _Tuple_impl<_Idx, _Head, _Tail...> |
284 | : public _Tuple_impl<_Idx + 1, _Tail...>, |
285 | private _Head_base<_Idx, _Head> |
286 | { |
287 | template<size_t, typename...> friend struct _Tuple_impl; |
288 | |
289 | typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; |
290 | typedef _Head_base<_Idx, _Head> _Base; |
291 | |
292 | static constexpr _Head& |
293 | (_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } |
294 | |
295 | static constexpr const _Head& |
296 | (const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } |
297 | |
298 | static constexpr _Inherited& |
299 | _M_tail(_Tuple_impl& __t) noexcept { return __t; } |
300 | |
301 | static constexpr const _Inherited& |
302 | _M_tail(const _Tuple_impl& __t) noexcept { return __t; } |
303 | |
304 | constexpr _Tuple_impl() |
305 | : _Inherited(), _Base() { } |
306 | |
307 | explicit constexpr |
308 | _Tuple_impl(const _Head& __head, const _Tail&... __tail) |
309 | : _Inherited(__tail...), _Base(__head) |
310 | { } |
311 | |
312 | template<typename _UHead, typename... _UTail, |
313 | typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>> |
314 | explicit constexpr |
315 | _Tuple_impl(_UHead&& __head, _UTail&&... __tail) |
316 | : _Inherited(std::forward<_UTail>(__tail)...), |
317 | _Base(std::forward<_UHead>(__head)) |
318 | { } |
319 | |
320 | constexpr _Tuple_impl(const _Tuple_impl&) = default; |
321 | |
322 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
323 | // 2729. Missing SFINAE on std::pair::operator= |
324 | _Tuple_impl& operator=(const _Tuple_impl&) = delete; |
325 | |
326 | _Tuple_impl(_Tuple_impl&&) = default; |
327 | |
328 | template<typename... _UElements> |
329 | constexpr |
330 | _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) |
331 | : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), |
332 | _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) |
333 | { } |
334 | |
335 | template<typename _UHead, typename... _UTails> |
336 | constexpr |
337 | _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) |
338 | : _Inherited(std::move |
339 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), |
340 | _Base(std::forward<_UHead> |
341 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) |
342 | { } |
343 | |
344 | #if __cpp_lib_ranges_zip // >= C++23 |
345 | template<typename... _UElements> |
346 | constexpr |
347 | _Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in) |
348 | : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), |
349 | _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) |
350 | { } |
351 | |
352 | template<typename _UHead, typename... _UTails> |
353 | constexpr |
354 | _Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) |
355 | : _Inherited(std::move |
356 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), |
357 | _Base(std::forward<const _UHead> |
358 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) |
359 | { } |
360 | #endif // C++23 |
361 | |
362 | #if __cpp_lib_tuple_like // >= C++23 |
363 | template<typename _UTuple, size_t... _Is> |
364 | constexpr |
365 | _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<_Is...>) |
366 | : _Tuple_impl(std::get<_Is>(std::forward<_UTuple>(__u))...) |
367 | { } |
368 | #endif // C++23 |
369 | |
370 | template<typename _Alloc> |
371 | _GLIBCXX20_CONSTEXPR |
372 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) |
373 | : _Inherited(__tag, __a), |
374 | _Base(__tag, __use_alloc<_Head>(__a)) |
375 | { } |
376 | |
377 | template<typename _Alloc> |
378 | _GLIBCXX20_CONSTEXPR |
379 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
380 | const _Head& __head, const _Tail&... __tail) |
381 | : _Inherited(__tag, __a, __tail...), |
382 | _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) |
383 | { } |
384 | |
385 | template<typename _Alloc, typename _UHead, typename... _UTail, |
386 | typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>> |
387 | _GLIBCXX20_CONSTEXPR |
388 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
389 | _UHead&& __head, _UTail&&... __tail) |
390 | : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), |
391 | _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), |
392 | std::forward<_UHead>(__head)) |
393 | { } |
394 | |
395 | template<typename _Alloc> |
396 | _GLIBCXX20_CONSTEXPR |
397 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
398 | const _Tuple_impl& __in) |
399 | : _Inherited(__tag, __a, _M_tail(__in)), |
400 | _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) |
401 | { } |
402 | |
403 | template<typename _Alloc> |
404 | _GLIBCXX20_CONSTEXPR |
405 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
406 | _Tuple_impl&& __in) |
407 | : _Inherited(__tag, __a, std::move(_M_tail(__in))), |
408 | _Base(__use_alloc<_Head, _Alloc, _Head>(__a), |
409 | std::forward<_Head>(_M_head(__in))) |
410 | { } |
411 | |
412 | template<typename _Alloc, typename _UHead, typename... _UTails> |
413 | _GLIBCXX20_CONSTEXPR |
414 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
415 | const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) |
416 | : _Inherited(__tag, __a, |
417 | _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), |
418 | _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), |
419 | _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) |
420 | { } |
421 | |
422 | template<typename _Alloc, typename _UHead, typename... _UTails> |
423 | _GLIBCXX20_CONSTEXPR |
424 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
425 | _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) |
426 | : _Inherited(__tag, __a, std::move |
427 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), |
428 | _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), |
429 | std::forward<_UHead> |
430 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) |
431 | { } |
432 | |
433 | #if __cpp_lib_ranges_zip // >= C++23 |
434 | template<typename _Alloc, typename _UHead, typename... _UTails> |
435 | constexpr |
436 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
437 | _Tuple_impl<_Idx, _UHead, _UTails...>& __in) |
438 | : _Inherited(__tag, __a, |
439 | _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), |
440 | _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a), |
441 | _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) |
442 | { } |
443 | |
444 | template<typename _Alloc, typename _UHead, typename... _UTails> |
445 | constexpr |
446 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, |
447 | const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) |
448 | : _Inherited(__tag, __a, std::move |
449 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), |
450 | _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a), |
451 | std::forward<const _UHead> |
452 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) |
453 | { } |
454 | #endif // C++23 |
455 | |
456 | #if __cpp_lib_tuple_like // >= C++23 |
457 | template<typename _Alloc, typename _UTuple, size_t... _Is> |
458 | constexpr |
459 | _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a, |
460 | _UTuple&& __u, index_sequence<_Is...>) |
461 | : _Tuple_impl(__tag, __a, std::get<_Is>(std::forward<_UTuple>(__u))...) |
462 | { } |
463 | #endif // C++23 |
464 | |
465 | template<typename... _UElements> |
466 | _GLIBCXX20_CONSTEXPR |
467 | void |
468 | _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) |
469 | { |
470 | _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); |
471 | _M_tail(*this)._M_assign( |
472 | _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); |
473 | } |
474 | |
475 | template<typename _UHead, typename... _UTails> |
476 | _GLIBCXX20_CONSTEXPR |
477 | void |
478 | _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) |
479 | { |
480 | _M_head(*this) = std::forward<_UHead> |
481 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); |
482 | _M_tail(*this)._M_assign( |
483 | std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); |
484 | } |
485 | |
486 | #if __cpp_lib_ranges_zip // >= C++23 |
487 | template<typename... _UElements> |
488 | constexpr void |
489 | _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) const |
490 | { |
491 | _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); |
492 | _M_tail(*this)._M_assign( |
493 | _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); |
494 | } |
495 | |
496 | template<typename _UHead, typename... _UTails> |
497 | constexpr void |
498 | _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) const |
499 | { |
500 | _M_head(*this) = std::forward<_UHead> |
501 | (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); |
502 | _M_tail(*this)._M_assign( |
503 | std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); |
504 | } |
505 | #endif // C++23 |
506 | |
507 | #if __cpp_lib_tuple_like // >= C++23 |
508 | template<typename _UTuple> |
509 | constexpr void |
510 | _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u) |
511 | { |
512 | _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); |
513 | _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u)); |
514 | } |
515 | |
516 | template<typename _UTuple> |
517 | constexpr void |
518 | _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u) const |
519 | { |
520 | _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); |
521 | _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u)); |
522 | } |
523 | #endif // C++23 |
524 | |
525 | protected: |
526 | _GLIBCXX20_CONSTEXPR |
527 | void |
528 | _M_swap(_Tuple_impl& __in) |
529 | { |
530 | using std::swap; |
531 | swap(_M_head(*this), _M_head(__in)); |
532 | _Inherited::_M_swap(_M_tail(__in)); |
533 | } |
534 | |
535 | #if __cpp_lib_ranges_zip // >= C++23 |
536 | constexpr void |
537 | _M_swap(const _Tuple_impl& __in) const |
538 | { |
539 | using std::swap; |
540 | swap(_M_head(*this), _M_head(__in)); |
541 | _Inherited::_M_swap(_M_tail(__in)); |
542 | } |
543 | #endif // C++23 |
544 | }; |
545 | |
546 | // Basis case of inheritance recursion. |
547 | template<size_t _Idx, typename _Head> |
548 | struct _Tuple_impl<_Idx, _Head> |
549 | : private _Head_base<_Idx, _Head> |
550 | { |
551 | template<size_t, typename...> friend struct _Tuple_impl; |
552 | |
553 | typedef _Head_base<_Idx, _Head> _Base; |
554 | |
555 | static constexpr _Head& |
556 | (_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } |
557 | |
558 | static constexpr const _Head& |
559 | (const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } |
560 | |
561 | constexpr |
562 | _Tuple_impl() |
563 | : _Base() { } |
564 | |
565 | explicit constexpr |
566 | _Tuple_impl(const _Head& __head) |
567 | : _Base(__head) |
568 | { } |
569 | |
570 | template<typename _UHead> |
571 | explicit constexpr |
572 | _Tuple_impl(_UHead&& __head) |
573 | : _Base(std::forward<_UHead>(__head)) |
574 | { } |
575 | |
576 | constexpr _Tuple_impl(const _Tuple_impl&) = default; |
577 | |
578 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
579 | // 2729. Missing SFINAE on std::pair::operator= |
580 | _Tuple_impl& operator=(const _Tuple_impl&) = delete; |
581 | |
582 | #if _GLIBCXX_INLINE_VERSION |
583 | _Tuple_impl(_Tuple_impl&&) = default; |
584 | #else |
585 | constexpr |
586 | _Tuple_impl(_Tuple_impl&& __in) |
587 | noexcept(is_nothrow_move_constructible<_Head>::value) |
588 | : _Base(static_cast<_Base&&>(__in)) |
589 | { } |
590 | #endif |
591 | |
592 | template<typename _UHead> |
593 | constexpr |
594 | _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) |
595 | : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) |
596 | { } |
597 | |
598 | template<typename _UHead> |
599 | constexpr |
600 | _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) |
601 | : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) |
602 | { } |
603 | |
604 | #if __cpp_lib_ranges_zip // >= C++23 |
605 | template<typename _UHead> |
606 | constexpr |
607 | _Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in) |
608 | : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) |
609 | { } |
610 | |
611 | template<typename _UHead> |
612 | constexpr |
613 | _Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in) |
614 | : _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) |
615 | { } |
616 | #endif // C++23 |
617 | |
618 | #if __cpp_lib_tuple_like // >= C++23 |
619 | template<typename _UTuple> |
620 | constexpr |
621 | _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<0>) |
622 | : _Tuple_impl(std::get<0>(std::forward<_UTuple>(__u))) |
623 | { } |
624 | #endif // C++23 |
625 | |
626 | template<typename _Alloc> |
627 | _GLIBCXX20_CONSTEXPR |
628 | _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) |
629 | : _Base(__tag, __use_alloc<_Head>(__a)) |
630 | { } |
631 | |
632 | template<typename _Alloc> |
633 | _GLIBCXX20_CONSTEXPR |
634 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
635 | const _Head& __head) |
636 | : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) |
637 | { } |
638 | |
639 | template<typename _Alloc, typename _UHead> |
640 | _GLIBCXX20_CONSTEXPR |
641 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
642 | _UHead&& __head) |
643 | : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), |
644 | std::forward<_UHead>(__head)) |
645 | { } |
646 | |
647 | template<typename _Alloc> |
648 | _GLIBCXX20_CONSTEXPR |
649 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
650 | const _Tuple_impl& __in) |
651 | : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) |
652 | { } |
653 | |
654 | template<typename _Alloc> |
655 | _GLIBCXX20_CONSTEXPR |
656 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
657 | _Tuple_impl&& __in) |
658 | : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), |
659 | std::forward<_Head>(_M_head(__in))) |
660 | { } |
661 | |
662 | template<typename _Alloc, typename _UHead> |
663 | _GLIBCXX20_CONSTEXPR |
664 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
665 | const _Tuple_impl<_Idx, _UHead>& __in) |
666 | : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), |
667 | _Tuple_impl<_Idx, _UHead>::_M_head(__in)) |
668 | { } |
669 | |
670 | template<typename _Alloc, typename _UHead> |
671 | _GLIBCXX20_CONSTEXPR |
672 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
673 | _Tuple_impl<_Idx, _UHead>&& __in) |
674 | : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), |
675 | std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) |
676 | { } |
677 | |
678 | #if __cpp_lib_ranges_zip // >= C++23 |
679 | template<typename _Alloc, typename _UHead> |
680 | constexpr |
681 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
682 | _Tuple_impl<_Idx, _UHead>& __in) |
683 | : _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a), |
684 | _Tuple_impl<_Idx, _UHead>::_M_head(__in)) |
685 | { } |
686 | |
687 | template<typename _Alloc, typename _UHead> |
688 | constexpr |
689 | _Tuple_impl(allocator_arg_t, const _Alloc& __a, |
690 | const _Tuple_impl<_Idx, _UHead>&& __in) |
691 | : _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a), |
692 | std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) |
693 | { } |
694 | #endif // C++23 |
695 | |
696 | #if __cpp_lib_tuple_like // >= C++23 |
697 | template<typename _Alloc, typename _UTuple> |
698 | constexpr |
699 | _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a, |
700 | _UTuple&& __u, index_sequence<0>) |
701 | : _Tuple_impl(__tag, __a, std::get<0>(std::forward<_UTuple>(__u))) |
702 | { } |
703 | #endif // C++23 |
704 | |
705 | template<typename _UHead> |
706 | _GLIBCXX20_CONSTEXPR |
707 | void |
708 | _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) |
709 | { |
710 | _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); |
711 | } |
712 | |
713 | template<typename _UHead> |
714 | _GLIBCXX20_CONSTEXPR |
715 | void |
716 | _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) |
717 | { |
718 | _M_head(*this) |
719 | = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); |
720 | } |
721 | |
722 | #if __cpp_lib_ranges_zip // >= C++23 |
723 | template<typename _UHead> |
724 | constexpr void |
725 | _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) const |
726 | { |
727 | _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); |
728 | } |
729 | |
730 | template<typename _UHead> |
731 | constexpr void |
732 | _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) const |
733 | { |
734 | _M_head(*this) |
735 | = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); |
736 | } |
737 | #endif // C++23 |
738 | |
739 | #if __cpp_lib_tuple_like // >= C++23 |
740 | template<typename _UTuple> |
741 | constexpr void |
742 | _M_assign(__tuple_like_tag_t, _UTuple&& __u) |
743 | { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); } |
744 | |
745 | template<typename _UTuple> |
746 | constexpr void |
747 | _M_assign(__tuple_like_tag_t, _UTuple&& __u) const |
748 | { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); } |
749 | #endif // C++23 |
750 | |
751 | protected: |
752 | _GLIBCXX20_CONSTEXPR |
753 | void |
754 | _M_swap(_Tuple_impl& __in) |
755 | { |
756 | using std::swap; |
757 | swap(_M_head(*this), _M_head(__in)); |
758 | } |
759 | |
760 | #if __cpp_lib_ranges_zip // >= C++23 |
761 | constexpr void |
762 | _M_swap(const _Tuple_impl& __in) const |
763 | { |
764 | using std::swap; |
765 | swap(_M_head(*this), _M_head(__in)); |
766 | } |
767 | #endif // C++23 |
768 | }; |
769 | |
770 | // Concept utility functions, reused in conditionally-explicit |
771 | // constructors. |
772 | template<bool, typename... _Types> |
773 | struct _TupleConstraints |
774 | { |
775 | template<typename... _UTypes> |
776 | using __constructible = __and_<is_constructible<_Types, _UTypes>...>; |
777 | |
778 | template<typename... _UTypes> |
779 | using __convertible = __and_<is_convertible<_UTypes, _Types>...>; |
780 | |
781 | // Constraint for a non-explicit constructor. |
782 | // True iff each Ti in _Types... can be constructed from Ui in _UTypes... |
783 | // and every Ui is implicitly convertible to Ti. |
784 | template<typename... _UTypes> |
785 | static constexpr bool __is_implicitly_constructible() |
786 | { |
787 | return __and_<__constructible<_UTypes...>, |
788 | __convertible<_UTypes...> |
789 | >::value; |
790 | } |
791 | |
792 | // Constraint for a non-explicit constructor. |
793 | // True iff each Ti in _Types... can be constructed from Ui in _UTypes... |
794 | // but not every Ui is implicitly convertible to Ti. |
795 | template<typename... _UTypes> |
796 | static constexpr bool __is_explicitly_constructible() |
797 | { |
798 | return __and_<__constructible<_UTypes...>, |
799 | __not_<__convertible<_UTypes...>> |
800 | >::value; |
801 | } |
802 | |
803 | static constexpr bool __is_implicitly_default_constructible() |
804 | { |
805 | return __and_<std::__is_implicitly_default_constructible<_Types>... |
806 | >::value; |
807 | } |
808 | |
809 | static constexpr bool __is_explicitly_default_constructible() |
810 | { |
811 | return __and_<is_default_constructible<_Types>..., |
812 | __not_<__and_< |
813 | std::__is_implicitly_default_constructible<_Types>...> |
814 | >>::value; |
815 | } |
816 | }; |
817 | |
818 | // Partial specialization used when a required precondition isn't met, |
819 | // e.g. when sizeof...(_Types) != sizeof...(_UTypes). |
820 | template<typename... _Types> |
821 | struct _TupleConstraints<false, _Types...> |
822 | { |
823 | template<typename... _UTypes> |
824 | static constexpr bool __is_implicitly_constructible() |
825 | { return false; } |
826 | |
827 | template<typename... _UTypes> |
828 | static constexpr bool __is_explicitly_constructible() |
829 | { return false; } |
830 | }; |
831 | |
832 | /// Primary class template, tuple |
833 | template<typename... _Elements> |
834 | class tuple : public _Tuple_impl<0, _Elements...> |
835 | { |
836 | using _Inherited = _Tuple_impl<0, _Elements...>; |
837 | |
838 | #if __cpp_concepts && __cpp_consteval && __cpp_conditional_explicit // >= C++20 |
839 | template<typename... _UTypes> |
840 | static consteval bool |
841 | __constructible() |
842 | { |
843 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
844 | return __and_v<is_constructible<_Elements, _UTypes>...>; |
845 | else |
846 | return false; |
847 | } |
848 | |
849 | template<typename... _UTypes> |
850 | static consteval bool |
851 | __nothrow_constructible() |
852 | { |
853 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
854 | return __and_v<is_nothrow_constructible<_Elements, _UTypes>...>; |
855 | else |
856 | return false; |
857 | } |
858 | |
859 | template<typename... _UTypes> |
860 | static consteval bool |
861 | __convertible() |
862 | { |
863 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
864 | return __and_v<is_convertible<_UTypes, _Elements>...>; |
865 | else |
866 | return false; |
867 | } |
868 | |
869 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
870 | // 3121. tuple constructor constraints for UTypes&&... overloads |
871 | template<typename... _UTypes> |
872 | static consteval bool |
873 | __disambiguating_constraint() |
874 | { |
875 | if constexpr (sizeof...(_Elements) != sizeof...(_UTypes)) |
876 | return false; |
877 | else if constexpr (sizeof...(_Elements) == 1) |
878 | { |
879 | using _U0 = typename _Nth_type<0, _UTypes...>::type; |
880 | return !is_same_v<remove_cvref_t<_U0>, tuple>; |
881 | } |
882 | else if constexpr (sizeof...(_Elements) < 4) |
883 | { |
884 | using _U0 = typename _Nth_type<0, _UTypes...>::type; |
885 | if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>) |
886 | return true; |
887 | else |
888 | { |
889 | using _T0 = typename _Nth_type<0, _Elements...>::type; |
890 | return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>; |
891 | } |
892 | } |
893 | return true; |
894 | } |
895 | |
896 | // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1 |
897 | // and the single element in Types can be initialized from TUPLE, |
898 | // or is the same type as tuple_element_t<0, TUPLE>. |
899 | template<typename _Tuple> |
900 | static consteval bool |
901 | __use_other_ctor() |
902 | { |
903 | if constexpr (sizeof...(_Elements) != 1) |
904 | return false; |
905 | else if constexpr (is_same_v<remove_cvref_t<_Tuple>, tuple>) |
906 | return true; // Should use a copy/move constructor instead. |
907 | else |
908 | { |
909 | using _Tp = typename _Nth_type<0, _Elements...>::type; |
910 | if constexpr (is_convertible_v<_Tuple, _Tp>) |
911 | return true; |
912 | else if constexpr (is_constructible_v<_Tp, _Tuple>) |
913 | return true; |
914 | } |
915 | return false; |
916 | } |
917 | |
918 | template<typename... _Up> |
919 | static consteval bool |
920 | __dangles() |
921 | { |
922 | #if __has_builtin(__reference_constructs_from_temporary) |
923 | return (__reference_constructs_from_temporary(_Elements, _Up&&) |
924 | || ...); |
925 | #else |
926 | return false; |
927 | #endif |
928 | } |
929 | |
930 | #if __cpp_lib_tuple_like // >= C++23 |
931 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
932 | // 4045. tuple can create dangling references from tuple-like |
933 | template<typename _UTuple> |
934 | static consteval bool |
935 | __dangles_from_tuple_like() |
936 | { |
937 | return []<size_t... _Is>(index_sequence<_Is...>) { |
938 | return __dangles<decltype(std::get<_Is>(std::declval<_UTuple>()))...>(); |
939 | }(index_sequence_for<_Elements...>{}); |
940 | } |
941 | |
942 | template<typename _UTuple> |
943 | static consteval bool |
944 | __constructible_from_tuple_like() |
945 | { |
946 | return []<size_t... _Is>(index_sequence<_Is...>) { |
947 | return __constructible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>(); |
948 | }(index_sequence_for<_Elements...>{}); |
949 | } |
950 | |
951 | template<typename _UTuple> |
952 | static consteval bool |
953 | __convertible_from_tuple_like() |
954 | { |
955 | return []<size_t... _Is>(index_sequence<_Is...>) { |
956 | return __convertible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>(); |
957 | }(index_sequence_for<_Elements...>{}); |
958 | } |
959 | #endif // C++23 |
960 | |
961 | public: |
962 | constexpr |
963 | explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...)) |
964 | tuple() |
965 | noexcept((is_nothrow_default_constructible_v<_Elements> && ...)) |
966 | requires (is_default_constructible_v<_Elements> && ...) |
967 | : _Inherited() |
968 | { } |
969 | |
970 | constexpr explicit(!__convertible<const _Elements&...>()) |
971 | tuple(const _Elements&... __elements) |
972 | noexcept(__nothrow_constructible<const _Elements&...>()) |
973 | requires (__constructible<const _Elements&...>()) |
974 | : _Inherited(__elements...) |
975 | { } |
976 | |
977 | template<typename... _UTypes> |
978 | requires (__disambiguating_constraint<_UTypes...>()) |
979 | && (__constructible<_UTypes...>()) |
980 | && (!__dangles<_UTypes...>()) |
981 | constexpr explicit(!__convertible<_UTypes...>()) |
982 | tuple(_UTypes&&... __u) |
983 | noexcept(__nothrow_constructible<_UTypes...>()) |
984 | : _Inherited(std::forward<_UTypes>(__u)...) |
985 | { } |
986 | |
987 | template<typename... _UTypes> |
988 | requires (__disambiguating_constraint<_UTypes...>()) |
989 | && (__constructible<_UTypes...>()) |
990 | && (__dangles<_UTypes...>()) |
991 | tuple(_UTypes&&...) = delete; |
992 | |
993 | constexpr tuple(const tuple&) = default; |
994 | |
995 | constexpr tuple(tuple&&) = default; |
996 | |
997 | template<typename... _UTypes> |
998 | requires (__constructible<const _UTypes&...>()) |
999 | && (!__use_other_ctor<const tuple<_UTypes...>&>()) |
1000 | && (!__dangles<const _UTypes&...>()) |
1001 | constexpr explicit(!__convertible<const _UTypes&...>()) |
1002 | tuple(const tuple<_UTypes...>& __u) |
1003 | noexcept(__nothrow_constructible<const _UTypes&...>()) |
1004 | : _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&>(__u)) |
1005 | { } |
1006 | |
1007 | template<typename... _UTypes> |
1008 | requires (__constructible<const _UTypes&...>()) |
1009 | && (!__use_other_ctor<const tuple<_UTypes...>&>()) |
1010 | && (__dangles<const _UTypes&...>()) |
1011 | tuple(const tuple<_UTypes...>&) = delete; |
1012 | |
1013 | template<typename... _UTypes> |
1014 | requires (__constructible<_UTypes...>()) |
1015 | && (!__use_other_ctor<tuple<_UTypes...>>()) |
1016 | && (!__dangles<_UTypes...>()) |
1017 | constexpr explicit(!__convertible<_UTypes...>()) |
1018 | tuple(tuple<_UTypes...>&& __u) |
1019 | noexcept(__nothrow_constructible<_UTypes...>()) |
1020 | : _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&&>(__u)) |
1021 | { } |
1022 | |
1023 | template<typename... _UTypes> |
1024 | requires (__constructible<_UTypes...>()) |
1025 | && (!__use_other_ctor<tuple<_UTypes...>>()) |
1026 | && (__dangles<_UTypes...>()) |
1027 | tuple(tuple<_UTypes...>&&) = delete; |
1028 | |
1029 | #if __cpp_lib_ranges_zip // >= C++23 |
1030 | template<typename... _UTypes> |
1031 | requires (__constructible<_UTypes&...>()) |
1032 | && (!__use_other_ctor<tuple<_UTypes...>&>()) |
1033 | && (!__dangles<_UTypes&...>()) |
1034 | constexpr explicit(!__convertible<_UTypes&...>()) |
1035 | tuple(tuple<_UTypes...>& __u) |
1036 | noexcept(__nothrow_constructible<_UTypes&...>()) |
1037 | : _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&>(__u)) |
1038 | { } |
1039 | |
1040 | template<typename... _UTypes> |
1041 | requires (__constructible<_UTypes&...>()) |
1042 | && (!__use_other_ctor<tuple<_UTypes...>&>()) |
1043 | && (__dangles<_UTypes&...>()) |
1044 | tuple(tuple<_UTypes...>&) = delete; |
1045 | |
1046 | template<typename... _UTypes> |
1047 | requires (__constructible<const _UTypes...>()) |
1048 | && (!__use_other_ctor<const tuple<_UTypes...>>()) |
1049 | && (!__dangles<const _UTypes...>()) |
1050 | constexpr explicit(!__convertible<const _UTypes...>()) |
1051 | tuple(const tuple<_UTypes...>&& __u) |
1052 | noexcept(__nothrow_constructible<const _UTypes...>()) |
1053 | : _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u)) |
1054 | { } |
1055 | |
1056 | template<typename... _UTypes> |
1057 | requires (__constructible<const _UTypes...>()) |
1058 | && (!__use_other_ctor<const tuple<_UTypes...>>()) |
1059 | && (__dangles<const _UTypes...>()) |
1060 | tuple(const tuple<_UTypes...>&&) = delete; |
1061 | #endif // C++23 |
1062 | |
1063 | template<typename _U1, typename _U2> |
1064 | requires (sizeof...(_Elements) == 2) |
1065 | && (__constructible<const _U1&, const _U2&>()) |
1066 | && (!__dangles<const _U1&, const _U2&>()) |
1067 | constexpr explicit(!__convertible<const _U1&, const _U2&>()) |
1068 | tuple(const pair<_U1, _U2>& __u) |
1069 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
1070 | : _Inherited(__u.first, __u.second) |
1071 | { } |
1072 | |
1073 | template<typename _U1, typename _U2> |
1074 | requires (sizeof...(_Elements) == 2) |
1075 | && (__constructible<const _U1&, const _U2&>()) |
1076 | && (__dangles<const _U1&, const _U2&>()) |
1077 | tuple(const pair<_U1, _U2>&) = delete; |
1078 | |
1079 | template<typename _U1, typename _U2> |
1080 | requires (sizeof...(_Elements) == 2) |
1081 | && (__constructible<_U1, _U2>()) |
1082 | && (!__dangles<_U1, _U2>()) |
1083 | constexpr explicit(!__convertible<_U1, _U2>()) |
1084 | tuple(pair<_U1, _U2>&& __u) |
1085 | noexcept(__nothrow_constructible<_U1, _U2>()) |
1086 | : _Inherited(std::forward<_U1>(__u.first), |
1087 | std::forward<_U2>(__u.second)) |
1088 | { } |
1089 | |
1090 | template<typename _U1, typename _U2> |
1091 | requires (sizeof...(_Elements) == 2) |
1092 | && (__constructible<_U1, _U2>()) |
1093 | && (__dangles<_U1, _U2>()) |
1094 | tuple(pair<_U1, _U2>&&) = delete; |
1095 | |
1096 | #if __cpp_lib_ranges_zip // >= C++23 |
1097 | template<typename _U1, typename _U2> |
1098 | requires (sizeof...(_Elements) == 2) |
1099 | && (__constructible<_U1&, _U2&>()) |
1100 | && (!__dangles<_U1&, _U2&>()) |
1101 | constexpr explicit(!__convertible<_U1&, _U2&>()) |
1102 | tuple(pair<_U1, _U2>& __u) |
1103 | noexcept(__nothrow_constructible<_U1&, _U2&>()) |
1104 | : _Inherited(__u.first, __u.second) |
1105 | { } |
1106 | |
1107 | template<typename _U1, typename _U2> |
1108 | requires (sizeof...(_Elements) == 2) |
1109 | && (__constructible<_U1&, _U2&>()) |
1110 | && (__dangles<_U1&, _U2&>()) |
1111 | tuple(pair<_U1, _U2>&) = delete; |
1112 | |
1113 | template<typename _U1, typename _U2> |
1114 | requires (sizeof...(_Elements) == 2) |
1115 | && (__constructible<const _U1, const _U2>()) |
1116 | && (!__dangles<const _U1, const _U2>()) |
1117 | constexpr explicit(!__convertible<const _U1, const _U2>()) |
1118 | tuple(const pair<_U1, _U2>&& __u) |
1119 | noexcept(__nothrow_constructible<const _U1, const _U2>()) |
1120 | : _Inherited(std::forward<const _U1>(__u.first), |
1121 | std::forward<const _U2>(__u.second)) |
1122 | { } |
1123 | |
1124 | template<typename _U1, typename _U2> |
1125 | requires (sizeof...(_Elements) == 2) |
1126 | && (__constructible<const _U1, const _U2>()) |
1127 | && (__dangles<const _U1, const _U2>()) |
1128 | tuple(const pair<_U1, _U2>&&) = delete; |
1129 | #endif // C++23 |
1130 | |
1131 | #if __cpp_lib_tuple_like // >= C++23 |
1132 | template<__eligible_tuple_like<tuple> _UTuple> |
1133 | requires (__constructible_from_tuple_like<_UTuple>()) |
1134 | && (!__use_other_ctor<_UTuple>()) |
1135 | && (!__dangles_from_tuple_like<_UTuple>()) |
1136 | constexpr explicit(!__convertible_from_tuple_like<_UTuple>()) |
1137 | tuple(_UTuple&& __u) |
1138 | : _Inherited(__tuple_like_tag_t{}, |
1139 | std::forward<_UTuple>(__u), |
1140 | index_sequence_for<_Elements...>{}) |
1141 | { } |
1142 | |
1143 | template<__eligible_tuple_like<tuple> _UTuple> |
1144 | requires (__constructible_from_tuple_like<_UTuple>()) |
1145 | && (!__use_other_ctor<_UTuple>()) |
1146 | && (__dangles_from_tuple_like<_UTuple>()) |
1147 | tuple(_UTuple&&) = delete; |
1148 | #endif // C++23 |
1149 | |
1150 | // Allocator-extended constructors. |
1151 | |
1152 | template<typename _Alloc> |
1153 | constexpr |
1154 | explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...)) |
1155 | tuple(allocator_arg_t __tag, const _Alloc& __a) |
1156 | requires (is_default_constructible_v<_Elements> && ...) |
1157 | : _Inherited(__tag, __a) |
1158 | { } |
1159 | |
1160 | template<typename _Alloc> |
1161 | constexpr explicit(!__convertible<const _Elements&...>()) |
1162 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1163 | const _Elements&... __elements) |
1164 | requires (__constructible<const _Elements&...>()) |
1165 | : _Inherited(__tag, __a, __elements...) |
1166 | { } |
1167 | |
1168 | template<typename _Alloc, typename... _UTypes> |
1169 | requires (__disambiguating_constraint<_UTypes...>()) |
1170 | && (__constructible<_UTypes...>()) |
1171 | && (!__dangles<_UTypes...>()) |
1172 | constexpr explicit(!__convertible<_UTypes...>()) |
1173 | tuple(allocator_arg_t __tag, const _Alloc& __a, _UTypes&&... __u) |
1174 | : _Inherited(__tag, __a, std::forward<_UTypes>(__u)...) |
1175 | { } |
1176 | |
1177 | template<typename _Alloc, typename... _UTypes> |
1178 | requires (__disambiguating_constraint<_UTypes...>()) |
1179 | && (__constructible<_UTypes...>()) |
1180 | && (__dangles<_UTypes...>()) |
1181 | tuple(allocator_arg_t, const _Alloc&, _UTypes&&...) = delete; |
1182 | |
1183 | template<typename _Alloc> |
1184 | constexpr |
1185 | tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __u) |
1186 | : _Inherited(__tag, __a, static_cast<const _Inherited&>(__u)) |
1187 | { } |
1188 | |
1189 | template<typename _Alloc> |
1190 | requires (__constructible<_Elements...>()) |
1191 | constexpr |
1192 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __u) |
1193 | : _Inherited(__tag, __a, static_cast<_Inherited&&>(__u)) |
1194 | { } |
1195 | |
1196 | template<typename _Alloc, typename... _UTypes> |
1197 | requires (__constructible<const _UTypes&...>()) |
1198 | && (!__use_other_ctor<const tuple<_UTypes...>&>()) |
1199 | && (!__dangles<const _UTypes&...>()) |
1200 | constexpr explicit(!__convertible<const _UTypes&...>()) |
1201 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1202 | const tuple<_UTypes...>& __u) |
1203 | : _Inherited(__tag, __a, |
1204 | static_cast<const _Tuple_impl<0, _UTypes...>&>(__u)) |
1205 | { } |
1206 | |
1207 | template<typename _Alloc, typename... _UTypes> |
1208 | requires (__constructible<const _UTypes&...>()) |
1209 | && (!__use_other_ctor<const tuple<_UTypes...>&>()) |
1210 | && (__dangles<const _UTypes&...>()) |
1211 | tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&) = delete; |
1212 | |
1213 | template<typename _Alloc, typename... _UTypes> |
1214 | requires (__constructible<_UTypes...>()) |
1215 | && (!__use_other_ctor<tuple<_UTypes...>>()) |
1216 | && (!__dangles<_UTypes...>()) |
1217 | constexpr explicit(!__use_other_ctor<tuple<_UTypes...>>()) |
1218 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>&& __u) |
1219 | : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&&>(__u)) |
1220 | { } |
1221 | |
1222 | template<typename _Alloc, typename... _UTypes> |
1223 | requires (__constructible<_UTypes...>()) |
1224 | && (!__use_other_ctor<tuple<_UTypes...>>()) |
1225 | && (__dangles<_UTypes...>()) |
1226 | tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&&) = delete; |
1227 | |
1228 | #if __cpp_lib_ranges_zip // >= C++23 |
1229 | template<typename _Alloc, typename... _UTypes> |
1230 | requires (__constructible<_UTypes&...>()) |
1231 | && (!__use_other_ctor<tuple<_UTypes...>&>()) |
1232 | && (!__dangles<_UTypes&...>()) |
1233 | constexpr explicit(!__convertible<_UTypes&...>()) |
1234 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>& __u) |
1235 | : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&>(__u)) |
1236 | { } |
1237 | |
1238 | template<typename _Alloc, typename... _UTypes> |
1239 | requires (__constructible<_UTypes&...>()) |
1240 | && (!__use_other_ctor<tuple<_UTypes...>&>()) |
1241 | && (__dangles<_UTypes&...>()) |
1242 | tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&) = delete; |
1243 | |
1244 | template<typename _Alloc, typename... _UTypes> |
1245 | requires (__constructible<const _UTypes...>()) |
1246 | && (!__use_other_ctor<const tuple<_UTypes...>>()) |
1247 | && (!__dangles<const _UTypes...>()) |
1248 | constexpr explicit(!__convertible<const _UTypes...>()) |
1249 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1250 | const tuple<_UTypes...>&& __u) |
1251 | : _Inherited(__tag, __a, |
1252 | static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u)) |
1253 | { } |
1254 | |
1255 | template<typename _Alloc, typename... _UTypes> |
1256 | requires (__constructible<const _UTypes...>()) |
1257 | && (!__use_other_ctor<const tuple<_UTypes...>>()) |
1258 | && (__dangles<const _UTypes...>()) |
1259 | tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&&) = delete; |
1260 | #endif // C++23 |
1261 | |
1262 | template<typename _Alloc, typename _U1, typename _U2> |
1263 | requires (sizeof...(_Elements) == 2) |
1264 | && (__constructible<const _U1&, const _U2&>()) |
1265 | && (!__dangles<const _U1&, const _U2&>()) |
1266 | constexpr explicit(!__convertible<const _U1&, const _U2&>()) |
1267 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1268 | const pair<_U1, _U2>& __u) |
1269 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
1270 | : _Inherited(__tag, __a, __u.first, __u.second) |
1271 | { } |
1272 | |
1273 | template<typename _Alloc, typename _U1, typename _U2> |
1274 | requires (sizeof...(_Elements) == 2) |
1275 | && (__constructible<const _U1&, const _U2&>()) |
1276 | && (__dangles<const _U1&, const _U2&>()) |
1277 | tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&) = delete; |
1278 | |
1279 | template<typename _Alloc, typename _U1, typename _U2> |
1280 | requires (sizeof...(_Elements) == 2) |
1281 | && (__constructible<_U1, _U2>()) |
1282 | && (!__dangles<_U1, _U2>()) |
1283 | constexpr explicit(!__convertible<_U1, _U2>()) |
1284 | tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __u) |
1285 | noexcept(__nothrow_constructible<_U1, _U2>()) |
1286 | : _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second)) |
1287 | { } |
1288 | |
1289 | template<typename _Alloc, typename _U1, typename _U2> |
1290 | requires (sizeof...(_Elements) == 2) |
1291 | && (__constructible<_U1, _U2>()) |
1292 | && (__dangles<_U1, _U2>()) |
1293 | tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&&) = delete; |
1294 | |
1295 | #if __cpp_lib_ranges_zip // >= C++23 |
1296 | template<typename _Alloc, typename _U1, typename _U2> |
1297 | requires (sizeof...(_Elements) == 2) |
1298 | && (__constructible<_U1&, _U2&>()) |
1299 | && (!__dangles<_U1&, _U2&>()) |
1300 | constexpr explicit(!__convertible<_U1&, _U2&>()) |
1301 | tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>& __u) |
1302 | noexcept(__nothrow_constructible<_U1&, _U2&>()) |
1303 | : _Inherited(__tag, __a, __u.first, __u.second) |
1304 | { } |
1305 | |
1306 | template<typename _Alloc, typename _U1, typename _U2> |
1307 | requires (sizeof...(_Elements) == 2) |
1308 | && (__constructible<_U1&, _U2&>()) |
1309 | && (__dangles<_U1&, _U2&>()) |
1310 | tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&) = delete; |
1311 | |
1312 | template<typename _Alloc, typename _U1, typename _U2> |
1313 | requires (sizeof...(_Elements) == 2) |
1314 | && (__constructible<const _U1, const _U2>()) |
1315 | && (!__dangles<const _U1, const _U2>()) |
1316 | constexpr explicit(!__convertible<const _U1, const _U2>()) |
1317 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1318 | const pair<_U1, _U2>&& __u) |
1319 | noexcept(__nothrow_constructible<const _U1, const _U2>()) |
1320 | : _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second)) |
1321 | { } |
1322 | |
1323 | template<typename _Alloc, typename _U1, typename _U2> |
1324 | requires (sizeof...(_Elements) == 2) |
1325 | && (__constructible<const _U1, const _U2>()) |
1326 | && (__dangles<const _U1, const _U2>()) |
1327 | tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&&) = delete; |
1328 | #endif // C++23 |
1329 | |
1330 | #if __cpp_lib_tuple_like // >= C++23 |
1331 | template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple> |
1332 | requires (__constructible_from_tuple_like<_UTuple>()) |
1333 | && (!__use_other_ctor<_UTuple>()) |
1334 | && (!__dangles_from_tuple_like<_UTuple>()) |
1335 | constexpr explicit(!__convertible_from_tuple_like<_UTuple>()) |
1336 | tuple(allocator_arg_t __tag, const _Alloc& __a, _UTuple&& __u) |
1337 | : _Inherited(__tuple_like_tag_t{}, |
1338 | __tag, __a, std::forward<_UTuple>(__u), |
1339 | index_sequence_for<_Elements...>{}) |
1340 | { } |
1341 | |
1342 | template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple> |
1343 | requires (__constructible_from_tuple_like<_UTuple>()) |
1344 | && (!__use_other_ctor<_UTuple>()) |
1345 | && (__dangles_from_tuple_like<_UTuple>()) |
1346 | tuple(allocator_arg_t, const _Alloc&, _UTuple&&) = delete; |
1347 | #endif // C++23 |
1348 | |
1349 | #else // !(concepts && conditional_explicit) |
1350 | |
1351 | template<bool _Cond> |
1352 | using _TCC = _TupleConstraints<_Cond, _Elements...>; |
1353 | |
1354 | // Constraint for non-explicit default constructor |
1355 | template<bool _Dummy> |
1356 | using _ImplicitDefaultCtor = __enable_if_t< |
1357 | _TCC<_Dummy>::__is_implicitly_default_constructible(), |
1358 | bool>; |
1359 | |
1360 | // Constraint for explicit default constructor |
1361 | template<bool _Dummy> |
1362 | using _ExplicitDefaultCtor = __enable_if_t< |
1363 | _TCC<_Dummy>::__is_explicitly_default_constructible(), |
1364 | bool>; |
1365 | |
1366 | // Constraint for non-explicit constructors |
1367 | template<bool _Cond, typename... _Args> |
1368 | using _ImplicitCtor = __enable_if_t< |
1369 | _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), |
1370 | bool>; |
1371 | |
1372 | // Constraint for non-explicit constructors |
1373 | template<bool _Cond, typename... _Args> |
1374 | using _ExplicitCtor = __enable_if_t< |
1375 | _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), |
1376 | bool>; |
1377 | |
1378 | // Condition for noexcept-specifier of a constructor. |
1379 | template<typename... _UElements> |
1380 | static constexpr bool __nothrow_constructible() |
1381 | { |
1382 | return |
1383 | __and_<is_nothrow_constructible<_Elements, _UElements>...>::value; |
1384 | } |
1385 | |
1386 | // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) == 1. |
1387 | template<typename _Up> |
1388 | static constexpr bool __valid_args() |
1389 | { |
1390 | return sizeof...(_Elements) == 1 |
1391 | && !is_same<tuple, __remove_cvref_t<_Up>>::value; |
1392 | } |
1393 | |
1394 | // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) > 1. |
1395 | template<typename, typename, typename... _Tail> |
1396 | static constexpr bool __valid_args() |
1397 | { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } |
1398 | |
1399 | /* Constraint for constructors with a tuple<UTypes...> parameter ensures |
1400 | * that the constructor is only viable when it would not interfere with |
1401 | * tuple(UTypes&&...) or tuple(const tuple&) or tuple(tuple&&). |
1402 | * Such constructors are only viable if: |
1403 | * either sizeof...(Types) != 1, |
1404 | * or (when Types... expands to T and UTypes... expands to U) |
1405 | * is_convertible_v<TUPLE, T>, is_constructible_v<T, TUPLE>, |
1406 | * and is_same_v<T, U> are all false. |
1407 | */ |
1408 | template<typename _Tuple, typename = tuple, |
1409 | typename = __remove_cvref_t<_Tuple>> |
1410 | struct _UseOtherCtor |
1411 | : false_type |
1412 | { }; |
1413 | // If TUPLE is convertible to the single element in *this, |
1414 | // then TUPLE should match tuple(UTypes&&...) instead. |
1415 | template<typename _Tuple, typename _Tp, typename _Up> |
1416 | struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> |
1417 | : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>::type |
1418 | { }; |
1419 | // If TUPLE and *this each have a single element of the same type, |
1420 | // then TUPLE should match a copy/move constructor instead. |
1421 | template<typename _Tuple, typename _Tp> |
1422 | struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> |
1423 | : true_type |
1424 | { }; |
1425 | |
1426 | // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1 |
1427 | // and the single element in Types can be initialized from TUPLE, |
1428 | // or is the same type as tuple_element_t<0, TUPLE>. |
1429 | template<typename _Tuple> |
1430 | static constexpr bool __use_other_ctor() |
1431 | { return _UseOtherCtor<_Tuple>::value; } |
1432 | |
1433 | /// @cond undocumented |
1434 | #undef __glibcxx_no_dangling_refs |
1435 | #if __has_builtin(__reference_constructs_from_temporary) \ |
1436 | && defined _GLIBCXX_DEBUG |
1437 | // Error if construction from U... would create a dangling ref. |
1438 | # if __cpp_fold_expressions |
1439 | # define __glibcxx_dangling_refs(U) \ |
1440 | (__reference_constructs_from_temporary(_Elements, U) || ...) |
1441 | # else |
1442 | # define __glibcxx_dangling_refs(U) \ |
1443 | __or_<__bool_constant<__reference_constructs_from_temporary(_Elements, U) \ |
1444 | >...>::value |
1445 | # endif |
1446 | # define __glibcxx_no_dangling_refs(U) \ |
1447 | static_assert(!__glibcxx_dangling_refs(U), \ |
1448 | "std::tuple constructor creates a dangling reference") |
1449 | #else |
1450 | # define __glibcxx_no_dangling_refs(U) |
1451 | #endif |
1452 | /// @endcond |
1453 | |
1454 | public: |
1455 | template<typename _Dummy = void, |
1456 | _ImplicitDefaultCtor<is_void<_Dummy>::value> = true> |
1457 | constexpr |
1458 | tuple() |
1459 | noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value) |
1460 | : _Inherited() { } |
1461 | |
1462 | template<typename _Dummy = void, |
1463 | _ExplicitDefaultCtor<is_void<_Dummy>::value> = false> |
1464 | explicit constexpr |
1465 | tuple() |
1466 | noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value) |
1467 | : _Inherited() { } |
1468 | |
1469 | template<bool _NotEmpty = (sizeof...(_Elements) >= 1), |
1470 | _ImplicitCtor<_NotEmpty, const _Elements&...> = true> |
1471 | constexpr |
1472 | tuple(const _Elements&... __elements) |
1473 | noexcept(__nothrow_constructible<const _Elements&...>()) |
1474 | : _Inherited(__elements...) { } |
1475 | |
1476 | template<bool _NotEmpty = (sizeof...(_Elements) >= 1), |
1477 | _ExplicitCtor<_NotEmpty, const _Elements&...> = false> |
1478 | explicit constexpr |
1479 | tuple(const _Elements&... __elements) |
1480 | noexcept(__nothrow_constructible<const _Elements&...>()) |
1481 | : _Inherited(__elements...) { } |
1482 | |
1483 | template<typename... _UElements, |
1484 | bool _Valid = __valid_args<_UElements...>(), |
1485 | _ImplicitCtor<_Valid, _UElements...> = true> |
1486 | constexpr |
1487 | tuple(_UElements&&... __elements) |
1488 | noexcept(__nothrow_constructible<_UElements...>()) |
1489 | : _Inherited(std::forward<_UElements>(__elements)...) |
1490 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1491 | |
1492 | template<typename... _UElements, |
1493 | bool _Valid = __valid_args<_UElements...>(), |
1494 | _ExplicitCtor<_Valid, _UElements...> = false> |
1495 | explicit constexpr |
1496 | tuple(_UElements&&... __elements) |
1497 | noexcept(__nothrow_constructible<_UElements...>()) |
1498 | : _Inherited(std::forward<_UElements>(__elements)...) |
1499 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1500 | |
1501 | constexpr tuple(const tuple&) = default; |
1502 | |
1503 | constexpr tuple(tuple&&) = default; |
1504 | |
1505 | template<typename... _UElements, |
1506 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1507 | && !__use_other_ctor<const tuple<_UElements...>&>(), |
1508 | _ImplicitCtor<_Valid, const _UElements&...> = true> |
1509 | constexpr |
1510 | tuple(const tuple<_UElements...>& __in) |
1511 | noexcept(__nothrow_constructible<const _UElements&...>()) |
1512 | : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
1513 | { __glibcxx_no_dangling_refs(const _UElements&); } |
1514 | |
1515 | template<typename... _UElements, |
1516 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1517 | && !__use_other_ctor<const tuple<_UElements...>&>(), |
1518 | _ExplicitCtor<_Valid, const _UElements&...> = false> |
1519 | explicit constexpr |
1520 | tuple(const tuple<_UElements...>& __in) |
1521 | noexcept(__nothrow_constructible<const _UElements&...>()) |
1522 | : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
1523 | { __glibcxx_no_dangling_refs(const _UElements&); } |
1524 | |
1525 | template<typename... _UElements, |
1526 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1527 | && !__use_other_ctor<tuple<_UElements...>&&>(), |
1528 | _ImplicitCtor<_Valid, _UElements...> = true> |
1529 | constexpr |
1530 | tuple(tuple<_UElements...>&& __in) |
1531 | noexcept(__nothrow_constructible<_UElements...>()) |
1532 | : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) |
1533 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1534 | |
1535 | template<typename... _UElements, |
1536 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1537 | && !__use_other_ctor<tuple<_UElements...>&&>(), |
1538 | _ExplicitCtor<_Valid, _UElements...> = false> |
1539 | explicit constexpr |
1540 | tuple(tuple<_UElements...>&& __in) |
1541 | noexcept(__nothrow_constructible<_UElements...>()) |
1542 | : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) |
1543 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1544 | |
1545 | // Allocator-extended constructors. |
1546 | |
1547 | template<typename _Alloc, |
1548 | _ImplicitDefaultCtor<is_object<_Alloc>::value> = true> |
1549 | _GLIBCXX20_CONSTEXPR |
1550 | tuple(allocator_arg_t __tag, const _Alloc& __a) |
1551 | : _Inherited(__tag, __a) { } |
1552 | |
1553 | template<typename _Alloc, |
1554 | _ExplicitDefaultCtor<is_object<_Alloc>::value> = false> |
1555 | _GLIBCXX20_CONSTEXPR |
1556 | explicit |
1557 | tuple(allocator_arg_t __tag, const _Alloc& __a) |
1558 | : _Inherited(__tag, __a) { } |
1559 | |
1560 | template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1), |
1561 | _ImplicitCtor<_NotEmpty, const _Elements&...> = true> |
1562 | _GLIBCXX20_CONSTEXPR |
1563 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1564 | const _Elements&... __elements) |
1565 | : _Inherited(__tag, __a, __elements...) { } |
1566 | |
1567 | template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1), |
1568 | _ExplicitCtor<_NotEmpty, const _Elements&...> = false> |
1569 | _GLIBCXX20_CONSTEXPR |
1570 | explicit |
1571 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1572 | const _Elements&... __elements) |
1573 | : _Inherited(__tag, __a, __elements...) { } |
1574 | |
1575 | template<typename _Alloc, typename... _UElements, |
1576 | bool _Valid = __valid_args<_UElements...>(), |
1577 | _ImplicitCtor<_Valid, _UElements...> = true> |
1578 | _GLIBCXX20_CONSTEXPR |
1579 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1580 | _UElements&&... __elements) |
1581 | : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) |
1582 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1583 | |
1584 | template<typename _Alloc, typename... _UElements, |
1585 | bool _Valid = __valid_args<_UElements...>(), |
1586 | _ExplicitCtor<_Valid, _UElements...> = false> |
1587 | _GLIBCXX20_CONSTEXPR |
1588 | explicit |
1589 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1590 | _UElements&&... __elements) |
1591 | : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) |
1592 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1593 | |
1594 | template<typename _Alloc> |
1595 | _GLIBCXX20_CONSTEXPR |
1596 | tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) |
1597 | : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } |
1598 | |
1599 | template<typename _Alloc> |
1600 | _GLIBCXX20_CONSTEXPR |
1601 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) |
1602 | : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } |
1603 | |
1604 | template<typename _Alloc, typename... _UElements, |
1605 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1606 | && !__use_other_ctor<const tuple<_UElements...>&>(), |
1607 | _ImplicitCtor<_Valid, const _UElements&...> = true> |
1608 | _GLIBCXX20_CONSTEXPR |
1609 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1610 | const tuple<_UElements...>& __in) |
1611 | : _Inherited(__tag, __a, |
1612 | static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
1613 | { __glibcxx_no_dangling_refs(const _UElements&); } |
1614 | |
1615 | template<typename _Alloc, typename... _UElements, |
1616 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1617 | && !__use_other_ctor<const tuple<_UElements...>&>(), |
1618 | _ExplicitCtor<_Valid, const _UElements&...> = false> |
1619 | _GLIBCXX20_CONSTEXPR |
1620 | explicit |
1621 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1622 | const tuple<_UElements...>& __in) |
1623 | : _Inherited(__tag, __a, |
1624 | static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
1625 | { __glibcxx_no_dangling_refs(const _UElements&); } |
1626 | |
1627 | template<typename _Alloc, typename... _UElements, |
1628 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1629 | && !__use_other_ctor<tuple<_UElements...>&&>(), |
1630 | _ImplicitCtor<_Valid, _UElements...> = true> |
1631 | _GLIBCXX20_CONSTEXPR |
1632 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1633 | tuple<_UElements...>&& __in) |
1634 | : _Inherited(__tag, __a, |
1635 | static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) |
1636 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1637 | |
1638 | template<typename _Alloc, typename... _UElements, |
1639 | bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) |
1640 | && !__use_other_ctor<tuple<_UElements...>&&>(), |
1641 | _ExplicitCtor<_Valid, _UElements...> = false> |
1642 | _GLIBCXX20_CONSTEXPR |
1643 | explicit |
1644 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
1645 | tuple<_UElements...>&& __in) |
1646 | : _Inherited(__tag, __a, |
1647 | static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) |
1648 | { __glibcxx_no_dangling_refs(_UElements&&); } |
1649 | #endif // concepts && conditional_explicit |
1650 | |
1651 | // tuple assignment |
1652 | |
1653 | #if __cpp_concepts && __cpp_consteval // >= C++20 |
1654 | private: |
1655 | template<typename... _UTypes> |
1656 | static consteval bool |
1657 | __assignable() |
1658 | { |
1659 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
1660 | return __and_v<is_assignable<_Elements&, _UTypes>...>; |
1661 | else |
1662 | return false; |
1663 | } |
1664 | |
1665 | template<typename... _UTypes> |
1666 | static consteval bool |
1667 | __nothrow_assignable() |
1668 | { |
1669 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
1670 | return __and_v<is_nothrow_assignable<_Elements&, _UTypes>...>; |
1671 | else |
1672 | return false; |
1673 | } |
1674 | |
1675 | #if __cpp_lib_ranges_zip // >= C++23 |
1676 | template<typename... _UTypes> |
1677 | static consteval bool |
1678 | __const_assignable() |
1679 | { |
1680 | if constexpr (sizeof...(_UTypes) == sizeof...(_Elements)) |
1681 | return __and_v<is_assignable<const _Elements&, _UTypes>...>; |
1682 | else |
1683 | return false; |
1684 | } |
1685 | #endif // C++23 |
1686 | |
1687 | #if __cpp_lib_tuple_like // >= C++23 |
1688 | template<typename _UTuple> |
1689 | static consteval bool |
1690 | __assignable_from_tuple_like() |
1691 | { |
1692 | return []<size_t... _Is>(index_sequence<_Is...>) { |
1693 | return __assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>(); |
1694 | }(index_sequence_for<_Elements...>{}); |
1695 | } |
1696 | |
1697 | template<typename _UTuple> |
1698 | static consteval bool |
1699 | __const_assignable_from_tuple_like() |
1700 | { |
1701 | return []<size_t... _Is>(index_sequence<_Is...>) { |
1702 | return __const_assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>(); |
1703 | }(index_sequence_for<_Elements...>{}); |
1704 | } |
1705 | #endif // C++23 |
1706 | |
1707 | public: |
1708 | |
1709 | tuple& operator=(const tuple& __u) = delete; |
1710 | |
1711 | constexpr tuple& |
1712 | operator=(const tuple& __u) |
1713 | noexcept(__nothrow_assignable<const _Elements&...>()) |
1714 | requires (__assignable<const _Elements&...>()) |
1715 | { |
1716 | this->_M_assign(__u); |
1717 | return *this; |
1718 | } |
1719 | |
1720 | constexpr tuple& |
1721 | operator=(tuple&& __u) |
1722 | noexcept(__nothrow_assignable<_Elements...>()) |
1723 | requires (__assignable<_Elements...>()) |
1724 | { |
1725 | this->_M_assign(std::move(__u)); |
1726 | return *this; |
1727 | } |
1728 | |
1729 | template<typename... _UTypes> |
1730 | requires (__assignable<const _UTypes&...>()) |
1731 | constexpr tuple& |
1732 | operator=(const tuple<_UTypes...>& __u) |
1733 | noexcept(__nothrow_assignable<const _UTypes&...>()) |
1734 | { |
1735 | this->_M_assign(__u); |
1736 | return *this; |
1737 | } |
1738 | |
1739 | template<typename... _UTypes> |
1740 | requires (__assignable<_UTypes...>()) |
1741 | constexpr tuple& |
1742 | operator=(tuple<_UTypes...>&& __u) |
1743 | noexcept(__nothrow_assignable<_UTypes...>()) |
1744 | { |
1745 | this->_M_assign(std::move(__u)); |
1746 | return *this; |
1747 | } |
1748 | |
1749 | #if __cpp_lib_ranges_zip // >= C++23 |
1750 | constexpr const tuple& |
1751 | operator=(const tuple& __u) const |
1752 | requires (__const_assignable<const _Elements&...>()) |
1753 | { |
1754 | this->_M_assign(__u); |
1755 | return *this; |
1756 | } |
1757 | |
1758 | constexpr const tuple& |
1759 | operator=(tuple&& __u) const |
1760 | requires (__const_assignable<_Elements...>()) |
1761 | { |
1762 | this->_M_assign(std::move(__u)); |
1763 | return *this; |
1764 | } |
1765 | |
1766 | template<typename... _UTypes> |
1767 | constexpr const tuple& |
1768 | operator=(const tuple<_UTypes...>& __u) const |
1769 | requires (__const_assignable<const _UTypes&...>()) |
1770 | { |
1771 | this->_M_assign(__u); |
1772 | return *this; |
1773 | } |
1774 | |
1775 | template<typename... _UTypes> |
1776 | constexpr const tuple& |
1777 | operator=(tuple<_UTypes...>&& __u) const |
1778 | requires (__const_assignable<_UTypes...>()) |
1779 | { |
1780 | this->_M_assign(std::move(__u)); |
1781 | return *this; |
1782 | } |
1783 | #endif // C++23 |
1784 | |
1785 | template<typename _U1, typename _U2> |
1786 | requires (__assignable<const _U1&, const _U2&>()) |
1787 | constexpr tuple& |
1788 | operator=(const pair<_U1, _U2>& __u) |
1789 | noexcept(__nothrow_assignable<const _U1&, const _U2&>()) |
1790 | { |
1791 | this->_M_head(*this) = __u.first; |
1792 | this->_M_tail(*this)._M_head(*this) = __u.second; |
1793 | return *this; |
1794 | } |
1795 | |
1796 | template<typename _U1, typename _U2> |
1797 | requires (__assignable<_U1, _U2>()) |
1798 | constexpr tuple& |
1799 | operator=(pair<_U1, _U2>&& __u) |
1800 | noexcept(__nothrow_assignable<_U1, _U2>()) |
1801 | { |
1802 | this->_M_head(*this) = std::forward<_U1>(__u.first); |
1803 | this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second); |
1804 | return *this; |
1805 | } |
1806 | |
1807 | #if __cpp_lib_ranges_zip // >= C++23 |
1808 | template<typename _U1, typename _U2> |
1809 | requires (__const_assignable<const _U1&, const _U2>()) |
1810 | constexpr const tuple& |
1811 | operator=(const pair<_U1, _U2>& __u) const |
1812 | { |
1813 | this->_M_head(*this) = __u.first; |
1814 | this->_M_tail(*this)._M_head(*this) = __u.second; |
1815 | return *this; |
1816 | } |
1817 | |
1818 | template<typename _U1, typename _U2> |
1819 | requires (__const_assignable<_U1, _U2>()) |
1820 | constexpr const tuple& |
1821 | operator=(pair<_U1, _U2>&& __u) const |
1822 | { |
1823 | this->_M_head(*this) = std::forward<_U1>(__u.first); |
1824 | this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second); |
1825 | return *this; |
1826 | } |
1827 | #endif // C++23 |
1828 | |
1829 | #if __cpp_lib_tuple_like // >= C++23 |
1830 | template<__eligible_tuple_like<tuple> _UTuple> |
1831 | requires (__assignable_from_tuple_like<_UTuple>()) |
1832 | constexpr tuple& |
1833 | operator=(_UTuple&& __u) |
1834 | { |
1835 | this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u)); |
1836 | return *this; |
1837 | } |
1838 | |
1839 | template<__eligible_tuple_like<tuple> _UTuple> |
1840 | requires (__const_assignable_from_tuple_like<_UTuple>()) |
1841 | constexpr const tuple& |
1842 | operator=(_UTuple&& __u) const |
1843 | { |
1844 | this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u)); |
1845 | return *this; |
1846 | } |
1847 | |
1848 | template<__tuple_like _UTuple> |
1849 | requires (!__is_tuple_v<_UTuple>) |
1850 | friend constexpr bool |
1851 | operator==(const tuple& __t, const _UTuple& __u) |
1852 | { |
1853 | static_assert(sizeof...(_Elements) == tuple_size_v<_UTuple>, |
1854 | "tuple objects can only be compared if they have equal sizes." ); |
1855 | return [&]<size_t... _Is>(index_sequence<_Is...>) { |
1856 | return (bool(std::get<_Is>(__t) == std::get<_Is>(__u)) |
1857 | && ...); |
1858 | }(index_sequence_for<_Elements...>{}); |
1859 | } |
1860 | |
1861 | template<__tuple_like _UTuple, |
1862 | typename = make_index_sequence<tuple_size_v<_UTuple>>> |
1863 | struct __tuple_like_common_comparison_category; |
1864 | |
1865 | template<__tuple_like _UTuple, size_t... _Is> |
1866 | requires requires |
1867 | { typename void_t<__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>; } |
1868 | struct __tuple_like_common_comparison_category<_UTuple, index_sequence<_Is...>> |
1869 | { |
1870 | using type = common_comparison_category_t |
1871 | <__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>; |
1872 | }; |
1873 | |
1874 | template<__tuple_like _UTuple> |
1875 | requires (!__is_tuple_v<_UTuple>) |
1876 | friend constexpr typename __tuple_like_common_comparison_category<_UTuple>::type |
1877 | operator<=>(const tuple& __t, const _UTuple& __u) |
1878 | { |
1879 | using _Cat = typename __tuple_like_common_comparison_category<_UTuple>::type; |
1880 | return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Elements...>()); |
1881 | } |
1882 | #endif // C++23 |
1883 | |
1884 | #else // ! (concepts && consteval) |
1885 | |
1886 | private: |
1887 | template<typename... _UElements> |
1888 | static constexpr |
1889 | __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool> |
1890 | __assignable() |
1891 | { return __and_<is_assignable<_Elements&, _UElements>...>::value; } |
1892 | |
1893 | // Condition for noexcept-specifier of an assignment operator. |
1894 | template<typename... _UElements> |
1895 | static constexpr bool __nothrow_assignable() |
1896 | { |
1897 | return |
1898 | __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value; |
1899 | } |
1900 | |
1901 | public: |
1902 | |
1903 | _GLIBCXX20_CONSTEXPR |
1904 | tuple& |
1905 | operator=(__conditional_t<__assignable<const _Elements&...>(), |
1906 | const tuple&, |
1907 | const __nonesuch&> __in) |
1908 | noexcept(__nothrow_assignable<const _Elements&...>()) |
1909 | { |
1910 | this->_M_assign(__in); |
1911 | return *this; |
1912 | } |
1913 | |
1914 | _GLIBCXX20_CONSTEXPR |
1915 | tuple& |
1916 | operator=(__conditional_t<__assignable<_Elements...>(), |
1917 | tuple&&, |
1918 | __nonesuch&&> __in) |
1919 | noexcept(__nothrow_assignable<_Elements...>()) |
1920 | { |
1921 | this->_M_assign(std::move(__in)); |
1922 | return *this; |
1923 | } |
1924 | |
1925 | template<typename... _UElements> |
1926 | _GLIBCXX20_CONSTEXPR |
1927 | __enable_if_t<__assignable<const _UElements&...>(), tuple&> |
1928 | operator=(const tuple<_UElements...>& __in) |
1929 | noexcept(__nothrow_assignable<const _UElements&...>()) |
1930 | { |
1931 | this->_M_assign(__in); |
1932 | return *this; |
1933 | } |
1934 | |
1935 | template<typename... _UElements> |
1936 | _GLIBCXX20_CONSTEXPR |
1937 | __enable_if_t<__assignable<_UElements...>(), tuple&> |
1938 | operator=(tuple<_UElements...>&& __in) |
1939 | noexcept(__nothrow_assignable<_UElements...>()) |
1940 | { |
1941 | this->_M_assign(std::move(__in)); |
1942 | return *this; |
1943 | } |
1944 | #endif // concepts && consteval |
1945 | |
1946 | // tuple swap |
1947 | _GLIBCXX20_CONSTEXPR |
1948 | void |
1949 | swap(tuple& __in) |
1950 | noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) |
1951 | { _Inherited::_M_swap(__in); } |
1952 | |
1953 | #if __cpp_lib_ranges_zip // >= C++23 |
1954 | // As an extension, we constrain the const swap member function in order |
1955 | // to continue accepting explicit instantiation of tuples whose elements |
1956 | // are not all const swappable. Without this constraint, such an |
1957 | // explicit instantiation would also instantiate the ill-formed body of |
1958 | // this function and yield a hard error. This constraint shouldn't |
1959 | // affect the behavior of valid programs. |
1960 | constexpr void |
1961 | swap(const tuple& __in) const |
1962 | noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>) |
1963 | requires (is_swappable_v<const _Elements> && ...) |
1964 | { _Inherited::_M_swap(__in); } |
1965 | #endif // C++23 |
1966 | }; |
1967 | |
1968 | #if __cpp_deduction_guides >= 201606 |
1969 | template<typename... _UTypes> |
1970 | tuple(_UTypes...) -> tuple<_UTypes...>; |
1971 | template<typename _T1, typename _T2> |
1972 | tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; |
1973 | template<typename _Alloc, typename... _UTypes> |
1974 | tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; |
1975 | template<typename _Alloc, typename _T1, typename _T2> |
1976 | tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; |
1977 | template<typename _Alloc, typename... _UTypes> |
1978 | tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; |
1979 | #endif |
1980 | |
1981 | // Explicit specialization, zero-element tuple. |
1982 | template<> |
1983 | class tuple<> |
1984 | { |
1985 | public: |
1986 | _GLIBCXX20_CONSTEXPR |
1987 | void swap(tuple&) noexcept { /* no-op */ } |
1988 | #if __cpp_lib_ranges_zip // >= C++23 |
1989 | constexpr void swap(const tuple&) const noexcept { /* no-op */ } |
1990 | #endif |
1991 | // We need the default since we're going to define no-op |
1992 | // allocator constructors. |
1993 | tuple() = default; |
1994 | // No-op allocator constructors. |
1995 | template<typename _Alloc> |
1996 | _GLIBCXX20_CONSTEXPR |
1997 | tuple(allocator_arg_t, const _Alloc&) noexcept { } |
1998 | template<typename _Alloc> |
1999 | _GLIBCXX20_CONSTEXPR |
2000 | tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } |
2001 | }; |
2002 | |
2003 | #if !(__cpp_concepts && __cpp_consteval && __cpp_conditional_explicit) // !C++20 |
2004 | /// Partial specialization, 2-element tuple. |
2005 | /// Includes construction and assignment from a pair. |
2006 | template<typename _T1, typename _T2> |
2007 | class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> |
2008 | { |
2009 | typedef _Tuple_impl<0, _T1, _T2> _Inherited; |
2010 | |
2011 | // Constraint for non-explicit default constructor |
2012 | template<bool _Dummy, typename _U1, typename _U2> |
2013 | using _ImplicitDefaultCtor = __enable_if_t< |
2014 | _TupleConstraints<_Dummy, _U1, _U2>:: |
2015 | __is_implicitly_default_constructible(), |
2016 | bool>; |
2017 | |
2018 | // Constraint for explicit default constructor |
2019 | template<bool _Dummy, typename _U1, typename _U2> |
2020 | using _ExplicitDefaultCtor = __enable_if_t< |
2021 | _TupleConstraints<_Dummy, _U1, _U2>:: |
2022 | __is_explicitly_default_constructible(), |
2023 | bool>; |
2024 | |
2025 | template<bool _Dummy> |
2026 | using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; |
2027 | |
2028 | // Constraint for non-explicit constructors |
2029 | template<bool _Cond, typename _U1, typename _U2> |
2030 | using _ImplicitCtor = __enable_if_t< |
2031 | _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), |
2032 | bool>; |
2033 | |
2034 | // Constraint for non-explicit constructors |
2035 | template<bool _Cond, typename _U1, typename _U2> |
2036 | using _ExplicitCtor = __enable_if_t< |
2037 | _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), |
2038 | bool>; |
2039 | |
2040 | template<typename _U1, typename _U2> |
2041 | static constexpr bool __assignable() |
2042 | { |
2043 | return __and_<is_assignable<_T1&, _U1>, |
2044 | is_assignable<_T2&, _U2>>::value; |
2045 | } |
2046 | |
2047 | template<typename _U1, typename _U2> |
2048 | static constexpr bool __nothrow_assignable() |
2049 | { |
2050 | return __and_<is_nothrow_assignable<_T1&, _U1>, |
2051 | is_nothrow_assignable<_T2&, _U2>>::value; |
2052 | } |
2053 | |
2054 | template<typename _U1, typename _U2> |
2055 | static constexpr bool __nothrow_constructible() |
2056 | { |
2057 | return __and_<is_nothrow_constructible<_T1, _U1>, |
2058 | is_nothrow_constructible<_T2, _U2>>::value; |
2059 | } |
2060 | |
2061 | static constexpr bool __nothrow_default_constructible() |
2062 | { |
2063 | return __and_<is_nothrow_default_constructible<_T1>, |
2064 | is_nothrow_default_constructible<_T2>>::value; |
2065 | } |
2066 | |
2067 | template<typename _U1> |
2068 | static constexpr bool __is_alloc_arg() |
2069 | { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } |
2070 | |
2071 | /// @cond undocumented |
2072 | #undef __glibcxx_no_dangling_refs |
2073 | // Error if construction from _U1 and _U2 would create a dangling ref. |
2074 | #if __has_builtin(__reference_constructs_from_temporary) \ |
2075 | && defined _GLIBCXX_DEBUG |
2076 | # define __glibcxx_no_dangling_refs(_U1, _U2) \ |
2077 | static_assert(!__reference_constructs_from_temporary(_T1, _U1) \ |
2078 | && !__reference_constructs_from_temporary(_T2, _U2), \ |
2079 | "std::tuple constructor creates a dangling reference") |
2080 | #else |
2081 | # define __glibcxx_no_dangling_refs(_U1, _U2) |
2082 | #endif |
2083 | /// @endcond |
2084 | |
2085 | public: |
2086 | template<bool _Dummy = true, |
2087 | _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true> |
2088 | constexpr |
2089 | tuple() |
2090 | noexcept(__nothrow_default_constructible()) |
2091 | : _Inherited() { } |
2092 | |
2093 | template<bool _Dummy = true, |
2094 | _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false> |
2095 | explicit constexpr |
2096 | tuple() |
2097 | noexcept(__nothrow_default_constructible()) |
2098 | : _Inherited() { } |
2099 | |
2100 | template<bool _Dummy = true, |
2101 | _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true> |
2102 | constexpr |
2103 | tuple(const _T1& __a1, const _T2& __a2) |
2104 | noexcept(__nothrow_constructible<const _T1&, const _T2&>()) |
2105 | : _Inherited(__a1, __a2) { } |
2106 | |
2107 | template<bool _Dummy = true, |
2108 | _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false> |
2109 | explicit constexpr |
2110 | tuple(const _T1& __a1, const _T2& __a2) |
2111 | noexcept(__nothrow_constructible<const _T1&, const _T2&>()) |
2112 | : _Inherited(__a1, __a2) { } |
2113 | |
2114 | template<typename _U1, typename _U2, |
2115 | _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true> |
2116 | constexpr |
2117 | tuple(_U1&& __a1, _U2&& __a2) |
2118 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2119 | : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) |
2120 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2121 | |
2122 | template<typename _U1, typename _U2, |
2123 | _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false> |
2124 | explicit constexpr |
2125 | tuple(_U1&& __a1, _U2&& __a2) |
2126 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2127 | : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) |
2128 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2129 | |
2130 | constexpr tuple(const tuple&) = default; |
2131 | |
2132 | constexpr tuple(tuple&&) = default; |
2133 | |
2134 | template<typename _U1, typename _U2, |
2135 | _ImplicitCtor<true, const _U1&, const _U2&> = true> |
2136 | constexpr |
2137 | tuple(const tuple<_U1, _U2>& __in) |
2138 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
2139 | : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) |
2140 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2141 | |
2142 | template<typename _U1, typename _U2, |
2143 | _ExplicitCtor<true, const _U1&, const _U2&> = false> |
2144 | explicit constexpr |
2145 | tuple(const tuple<_U1, _U2>& __in) |
2146 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
2147 | : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) |
2148 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2149 | |
2150 | template<typename _U1, typename _U2, |
2151 | _ImplicitCtor<true, _U1, _U2> = true> |
2152 | constexpr |
2153 | tuple(tuple<_U1, _U2>&& __in) |
2154 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2155 | : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) |
2156 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2157 | |
2158 | template<typename _U1, typename _U2, |
2159 | _ExplicitCtor<true, _U1, _U2> = false> |
2160 | explicit constexpr |
2161 | tuple(tuple<_U1, _U2>&& __in) |
2162 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2163 | : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) |
2164 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2165 | |
2166 | template<typename _U1, typename _U2, |
2167 | _ImplicitCtor<true, const _U1&, const _U2&> = true> |
2168 | constexpr |
2169 | tuple(const pair<_U1, _U2>& __in) |
2170 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
2171 | : _Inherited(__in.first, __in.second) |
2172 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2173 | |
2174 | template<typename _U1, typename _U2, |
2175 | _ExplicitCtor<true, const _U1&, const _U2&> = false> |
2176 | explicit constexpr |
2177 | tuple(const pair<_U1, _U2>& __in) |
2178 | noexcept(__nothrow_constructible<const _U1&, const _U2&>()) |
2179 | : _Inherited(__in.first, __in.second) |
2180 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2181 | |
2182 | template<typename _U1, typename _U2, |
2183 | _ImplicitCtor<true, _U1, _U2> = true> |
2184 | constexpr |
2185 | tuple(pair<_U1, _U2>&& __in) |
2186 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2187 | : _Inherited(std::forward<_U1>(__in.first), |
2188 | std::forward<_U2>(__in.second)) |
2189 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2190 | |
2191 | template<typename _U1, typename _U2, |
2192 | _ExplicitCtor<true, _U1, _U2> = false> |
2193 | explicit constexpr |
2194 | tuple(pair<_U1, _U2>&& __in) |
2195 | noexcept(__nothrow_constructible<_U1, _U2>()) |
2196 | : _Inherited(std::forward<_U1>(__in.first), |
2197 | std::forward<_U2>(__in.second)) |
2198 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2199 | |
2200 | // Allocator-extended constructors. |
2201 | |
2202 | template<typename _Alloc, |
2203 | _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true> |
2204 | _GLIBCXX20_CONSTEXPR |
2205 | tuple(allocator_arg_t __tag, const _Alloc& __a) |
2206 | : _Inherited(__tag, __a) { } |
2207 | |
2208 | template<typename _Alloc, |
2209 | _ExplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = false> |
2210 | _GLIBCXX20_CONSTEXPR |
2211 | explicit |
2212 | tuple(allocator_arg_t __tag, const _Alloc& __a) |
2213 | : _Inherited(__tag, __a) { } |
2214 | |
2215 | template<typename _Alloc, bool _Dummy = true, |
2216 | _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true> |
2217 | _GLIBCXX20_CONSTEXPR |
2218 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2219 | const _T1& __a1, const _T2& __a2) |
2220 | : _Inherited(__tag, __a, __a1, __a2) { } |
2221 | |
2222 | template<typename _Alloc, bool _Dummy = true, |
2223 | _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false> |
2224 | explicit |
2225 | _GLIBCXX20_CONSTEXPR |
2226 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2227 | const _T1& __a1, const _T2& __a2) |
2228 | : _Inherited(__tag, __a, __a1, __a2) { } |
2229 | |
2230 | template<typename _Alloc, typename _U1, typename _U2, |
2231 | _ImplicitCtor<true, _U1, _U2> = true> |
2232 | _GLIBCXX20_CONSTEXPR |
2233 | tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) |
2234 | : _Inherited(__tag, __a, std::forward<_U1>(__a1), |
2235 | std::forward<_U2>(__a2)) |
2236 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2237 | |
2238 | template<typename _Alloc, typename _U1, typename _U2, |
2239 | _ExplicitCtor<true, _U1, _U2> = false> |
2240 | explicit |
2241 | _GLIBCXX20_CONSTEXPR |
2242 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2243 | _U1&& __a1, _U2&& __a2) |
2244 | : _Inherited(__tag, __a, std::forward<_U1>(__a1), |
2245 | std::forward<_U2>(__a2)) |
2246 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2247 | |
2248 | template<typename _Alloc> |
2249 | _GLIBCXX20_CONSTEXPR |
2250 | tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) |
2251 | : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } |
2252 | |
2253 | template<typename _Alloc> |
2254 | _GLIBCXX20_CONSTEXPR |
2255 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) |
2256 | : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } |
2257 | |
2258 | template<typename _Alloc, typename _U1, typename _U2, |
2259 | _ImplicitCtor<true, const _U1&, const _U2&> = true> |
2260 | _GLIBCXX20_CONSTEXPR |
2261 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2262 | const tuple<_U1, _U2>& __in) |
2263 | : _Inherited(__tag, __a, |
2264 | static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) |
2265 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2266 | |
2267 | template<typename _Alloc, typename _U1, typename _U2, |
2268 | _ExplicitCtor<true, const _U1&, const _U2&> = false> |
2269 | explicit |
2270 | _GLIBCXX20_CONSTEXPR |
2271 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2272 | const tuple<_U1, _U2>& __in) |
2273 | : _Inherited(__tag, __a, |
2274 | static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) |
2275 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2276 | |
2277 | template<typename _Alloc, typename _U1, typename _U2, |
2278 | _ImplicitCtor<true, _U1, _U2> = true> |
2279 | _GLIBCXX20_CONSTEXPR |
2280 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) |
2281 | : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) |
2282 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2283 | |
2284 | template<typename _Alloc, typename _U1, typename _U2, |
2285 | _ExplicitCtor<true, _U1, _U2> = false> |
2286 | explicit |
2287 | _GLIBCXX20_CONSTEXPR |
2288 | tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) |
2289 | : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) |
2290 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2291 | |
2292 | template<typename _Alloc, typename _U1, typename _U2, |
2293 | _ImplicitCtor<true, const _U1&, const _U2&> = true> |
2294 | _GLIBCXX20_CONSTEXPR |
2295 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2296 | const pair<_U1, _U2>& __in) |
2297 | : _Inherited(__tag, __a, __in.first, __in.second) |
2298 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2299 | |
2300 | template<typename _Alloc, typename _U1, typename _U2, |
2301 | _ExplicitCtor<true, const _U1&, const _U2&> = false> |
2302 | explicit |
2303 | _GLIBCXX20_CONSTEXPR |
2304 | tuple(allocator_arg_t __tag, const _Alloc& __a, |
2305 | const pair<_U1, _U2>& __in) |
2306 | : _Inherited(__tag, __a, __in.first, __in.second) |
2307 | { __glibcxx_no_dangling_refs(const _U1&, const _U2&); } |
2308 | |
2309 | template<typename _Alloc, typename _U1, typename _U2, |
2310 | _ImplicitCtor<true, _U1, _U2> = true> |
2311 | _GLIBCXX20_CONSTEXPR |
2312 | tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) |
2313 | : _Inherited(__tag, __a, std::forward<_U1>(__in.first), |
2314 | std::forward<_U2>(__in.second)) |
2315 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2316 | |
2317 | template<typename _Alloc, typename _U1, typename _U2, |
2318 | _ExplicitCtor<true, _U1, _U2> = false> |
2319 | explicit |
2320 | _GLIBCXX20_CONSTEXPR |
2321 | tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) |
2322 | : _Inherited(__tag, __a, std::forward<_U1>(__in.first), |
2323 | std::forward<_U2>(__in.second)) |
2324 | { __glibcxx_no_dangling_refs(_U1&&, _U2&&); } |
2325 | |
2326 | // Tuple assignment. |
2327 | |
2328 | _GLIBCXX20_CONSTEXPR |
2329 | tuple& |
2330 | operator=(__conditional_t<__assignable<const _T1&, const _T2&>(), |
2331 | const tuple&, |
2332 | const __nonesuch&> __in) |
2333 | noexcept(__nothrow_assignable<const _T1&, const _T2&>()) |
2334 | { |
2335 | this->_M_assign(__in); |
2336 | return *this; |
2337 | } |
2338 | |
2339 | _GLIBCXX20_CONSTEXPR |
2340 | tuple& |
2341 | operator=(__conditional_t<__assignable<_T1, _T2>(), |
2342 | tuple&&, |
2343 | __nonesuch&&> __in) |
2344 | noexcept(__nothrow_assignable<_T1, _T2>()) |
2345 | { |
2346 | this->_M_assign(std::move(__in)); |
2347 | return *this; |
2348 | } |
2349 | |
2350 | template<typename _U1, typename _U2> |
2351 | _GLIBCXX20_CONSTEXPR |
2352 | __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&> |
2353 | operator=(const tuple<_U1, _U2>& __in) |
2354 | noexcept(__nothrow_assignable<const _U1&, const _U2&>()) |
2355 | { |
2356 | this->_M_assign(__in); |
2357 | return *this; |
2358 | } |
2359 | |
2360 | template<typename _U1, typename _U2> |
2361 | _GLIBCXX20_CONSTEXPR |
2362 | __enable_if_t<__assignable<_U1, _U2>(), tuple&> |
2363 | operator=(tuple<_U1, _U2>&& __in) |
2364 | noexcept(__nothrow_assignable<_U1, _U2>()) |
2365 | { |
2366 | this->_M_assign(std::move(__in)); |
2367 | return *this; |
2368 | } |
2369 | |
2370 | template<typename _U1, typename _U2> |
2371 | _GLIBCXX20_CONSTEXPR |
2372 | __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&> |
2373 | operator=(const pair<_U1, _U2>& __in) |
2374 | noexcept(__nothrow_assignable<const _U1&, const _U2&>()) |
2375 | { |
2376 | this->_M_head(*this) = __in.first; |
2377 | this->_M_tail(*this)._M_head(*this) = __in.second; |
2378 | return *this; |
2379 | } |
2380 | |
2381 | template<typename _U1, typename _U2> |
2382 | _GLIBCXX20_CONSTEXPR |
2383 | __enable_if_t<__assignable<_U1, _U2>(), tuple&> |
2384 | operator=(pair<_U1, _U2>&& __in) |
2385 | noexcept(__nothrow_assignable<_U1, _U2>()) |
2386 | { |
2387 | this->_M_head(*this) = std::forward<_U1>(__in.first); |
2388 | this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); |
2389 | return *this; |
2390 | } |
2391 | |
2392 | _GLIBCXX20_CONSTEXPR |
2393 | void |
2394 | swap(tuple& __in) |
2395 | noexcept(__and_<__is_nothrow_swappable<_T1>, |
2396 | __is_nothrow_swappable<_T2>>::value) |
2397 | { _Inherited::_M_swap(__in); } |
2398 | }; |
2399 | #endif // concepts && conditional_explicit |
2400 | |
2401 | /// class tuple_size |
2402 | template<typename... _Elements> |
2403 | struct tuple_size<tuple<_Elements...>> |
2404 | : public integral_constant<size_t, sizeof...(_Elements)> { }; |
2405 | |
2406 | #if __cplusplus >= 201703L |
2407 | template<typename... _Types> |
2408 | inline constexpr size_t tuple_size_v<tuple<_Types...>> |
2409 | = sizeof...(_Types); |
2410 | |
2411 | template<typename... _Types> |
2412 | inline constexpr size_t tuple_size_v<const tuple<_Types...>> |
2413 | = sizeof...(_Types); |
2414 | #endif |
2415 | |
2416 | /// Trait to get the Ith element type from a tuple. |
2417 | template<size_t __i, typename... _Types> |
2418 | struct tuple_element<__i, tuple<_Types...>> |
2419 | { |
2420 | static_assert(__i < sizeof...(_Types), "tuple index must be in range" ); |
2421 | |
2422 | using type = typename _Nth_type<__i, _Types...>::type; |
2423 | }; |
2424 | |
2425 | template<size_t __i, typename _Head, typename... _Tail> |
2426 | constexpr _Head& |
2427 | __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept |
2428 | { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } |
2429 | |
2430 | template<size_t __i, typename _Head, typename... _Tail> |
2431 | constexpr const _Head& |
2432 | __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept |
2433 | { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } |
2434 | |
2435 | // Deleted overload to improve diagnostics for invalid indices |
2436 | template<size_t __i, typename... _Types> |
2437 | __enable_if_t<(__i >= sizeof...(_Types))> |
2438 | __get_helper(const tuple<_Types...>&) = delete; |
2439 | |
2440 | /// Return a reference to the ith element of a tuple. |
2441 | template<size_t __i, typename... _Elements> |
2442 | constexpr __tuple_element_t<__i, tuple<_Elements...>>& |
2443 | get(tuple<_Elements...>& __t) noexcept |
2444 | { return std::__get_helper<__i>(__t); } |
2445 | |
2446 | /// Return a const reference to the ith element of a const tuple. |
2447 | template<size_t __i, typename... _Elements> |
2448 | constexpr const __tuple_element_t<__i, tuple<_Elements...>>& |
2449 | get(const tuple<_Elements...>& __t) noexcept |
2450 | { return std::__get_helper<__i>(__t); } |
2451 | |
2452 | /// Return an rvalue reference to the ith element of a tuple rvalue. |
2453 | template<size_t __i, typename... _Elements> |
2454 | constexpr __tuple_element_t<__i, tuple<_Elements...>>&& |
2455 | get(tuple<_Elements...>&& __t) noexcept |
2456 | { |
2457 | typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; |
2458 | return std::forward<__element_type>(std::__get_helper<__i>(__t)); |
2459 | } |
2460 | |
2461 | /// Return a const rvalue reference to the ith element of a const tuple rvalue. |
2462 | template<size_t __i, typename... _Elements> |
2463 | constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& |
2464 | get(const tuple<_Elements...>&& __t) noexcept |
2465 | { |
2466 | typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; |
2467 | return std::forward<const __element_type>(std::__get_helper<__i>(__t)); |
2468 | } |
2469 | |
2470 | /// @cond undocumented |
2471 | // Deleted overload chosen for invalid indices. |
2472 | template<size_t __i, typename... _Elements> |
2473 | constexpr __enable_if_t<(__i >= sizeof...(_Elements))> |
2474 | get(const tuple<_Elements...>&) = delete; |
2475 | /// @endcond |
2476 | |
2477 | #ifdef __cpp_lib_tuples_by_type // C++ >= 14 |
2478 | /// Return a reference to the unique element of type _Tp of a tuple. |
2479 | template <typename _Tp, typename... _Types> |
2480 | constexpr _Tp& |
2481 | get(tuple<_Types...>& __t) noexcept |
2482 | { |
2483 | constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); |
2484 | static_assert(__idx < sizeof...(_Types), |
2485 | "the type T in std::get<T> must occur exactly once in the tuple" ); |
2486 | return std::__get_helper<__idx>(__t); |
2487 | } |
2488 | |
2489 | /// Return a reference to the unique element of type _Tp of a tuple rvalue. |
2490 | template <typename _Tp, typename... _Types> |
2491 | constexpr _Tp&& |
2492 | get(tuple<_Types...>&& __t) noexcept |
2493 | { |
2494 | constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); |
2495 | static_assert(__idx < sizeof...(_Types), |
2496 | "the type T in std::get<T> must occur exactly once in the tuple" ); |
2497 | return std::forward<_Tp>(std::__get_helper<__idx>(__t)); |
2498 | } |
2499 | |
2500 | /// Return a const reference to the unique element of type _Tp of a tuple. |
2501 | template <typename _Tp, typename... _Types> |
2502 | constexpr const _Tp& |
2503 | get(const tuple<_Types...>& __t) noexcept |
2504 | { |
2505 | constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); |
2506 | static_assert(__idx < sizeof...(_Types), |
2507 | "the type T in std::get<T> must occur exactly once in the tuple" ); |
2508 | return std::__get_helper<__idx>(__t); |
2509 | } |
2510 | |
2511 | /// Return a const reference to the unique element of type _Tp of |
2512 | /// a const tuple rvalue. |
2513 | template <typename _Tp, typename... _Types> |
2514 | constexpr const _Tp&& |
2515 | get(const tuple<_Types...>&& __t) noexcept |
2516 | { |
2517 | constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); |
2518 | static_assert(__idx < sizeof...(_Types), |
2519 | "the type T in std::get<T> must occur exactly once in the tuple" ); |
2520 | return std::forward<const _Tp>(std::__get_helper<__idx>(__t)); |
2521 | } |
2522 | #endif |
2523 | |
2524 | // This class performs the comparison operations on tuples |
2525 | template<typename _Tp, typename _Up, size_t __i, size_t __size> |
2526 | struct __tuple_compare |
2527 | { |
2528 | static constexpr bool |
2529 | __eq(const _Tp& __t, const _Up& __u) |
2530 | { |
2531 | return bool(std::get<__i>(__t) == std::get<__i>(__u)) |
2532 | && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); |
2533 | } |
2534 | |
2535 | static constexpr bool |
2536 | __less(const _Tp& __t, const _Up& __u) |
2537 | { |
2538 | return bool(std::get<__i>(__t) < std::get<__i>(__u)) |
2539 | || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) |
2540 | && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); |
2541 | } |
2542 | }; |
2543 | |
2544 | template<typename _Tp, typename _Up, size_t __size> |
2545 | struct __tuple_compare<_Tp, _Up, __size, __size> |
2546 | { |
2547 | static constexpr bool |
2548 | __eq(const _Tp&, const _Up&) { return true; } |
2549 | |
2550 | static constexpr bool |
2551 | __less(const _Tp&, const _Up&) { return false; } |
2552 | }; |
2553 | |
2554 | template<typename... _TElements, typename... _UElements> |
2555 | constexpr bool |
2556 | operator==(const tuple<_TElements...>& __t, |
2557 | const tuple<_UElements...>& __u) |
2558 | { |
2559 | static_assert(sizeof...(_TElements) == sizeof...(_UElements), |
2560 | "tuple objects can only be compared if they have equal sizes." ); |
2561 | using __compare = __tuple_compare<tuple<_TElements...>, |
2562 | tuple<_UElements...>, |
2563 | 0, sizeof...(_TElements)>; |
2564 | return __compare::__eq(__t, __u); |
2565 | } |
2566 | |
2567 | #if __cpp_lib_three_way_comparison |
2568 | template<typename _Cat, typename _Tp, typename _Up> |
2569 | constexpr _Cat |
2570 | __tuple_cmp(const _Tp&, const _Up&, index_sequence<>) |
2571 | { return _Cat::equivalent; } |
2572 | |
2573 | template<typename _Cat, typename _Tp, typename _Up, |
2574 | size_t _Idx0, size_t... _Idxs> |
2575 | constexpr _Cat |
2576 | __tuple_cmp(const _Tp& __t, const _Up& __u, |
2577 | index_sequence<_Idx0, _Idxs...>) |
2578 | { |
2579 | auto __c |
2580 | = __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u)); |
2581 | if (__c != 0) |
2582 | return __c; |
2583 | return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>()); |
2584 | } |
2585 | |
2586 | template<typename... _Tps, typename... _Ups> |
2587 | constexpr |
2588 | common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...> |
2589 | operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u) |
2590 | { |
2591 | using _Cat |
2592 | = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>; |
2593 | return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>()); |
2594 | } |
2595 | #else |
2596 | template<typename... _TElements, typename... _UElements> |
2597 | constexpr bool |
2598 | operator<(const tuple<_TElements...>& __t, |
2599 | const tuple<_UElements...>& __u) |
2600 | { |
2601 | static_assert(sizeof...(_TElements) == sizeof...(_UElements), |
2602 | "tuple objects can only be compared if they have equal sizes." ); |
2603 | using __compare = __tuple_compare<tuple<_TElements...>, |
2604 | tuple<_UElements...>, |
2605 | 0, sizeof...(_TElements)>; |
2606 | return __compare::__less(__t, __u); |
2607 | } |
2608 | |
2609 | template<typename... _TElements, typename... _UElements> |
2610 | constexpr bool |
2611 | operator!=(const tuple<_TElements...>& __t, |
2612 | const tuple<_UElements...>& __u) |
2613 | { return !(__t == __u); } |
2614 | |
2615 | template<typename... _TElements, typename... _UElements> |
2616 | constexpr bool |
2617 | operator>(const tuple<_TElements...>& __t, |
2618 | const tuple<_UElements...>& __u) |
2619 | { return __u < __t; } |
2620 | |
2621 | template<typename... _TElements, typename... _UElements> |
2622 | constexpr bool |
2623 | operator<=(const tuple<_TElements...>& __t, |
2624 | const tuple<_UElements...>& __u) |
2625 | { return !(__u < __t); } |
2626 | |
2627 | template<typename... _TElements, typename... _UElements> |
2628 | constexpr bool |
2629 | operator>=(const tuple<_TElements...>& __t, |
2630 | const tuple<_UElements...>& __u) |
2631 | { return !(__t < __u); } |
2632 | #endif // three_way_comparison |
2633 | |
2634 | // NB: DR 705. |
2635 | /// Create a tuple containing copies of the arguments |
2636 | template<typename... _Elements> |
2637 | constexpr tuple<typename __decay_and_strip<_Elements>::__type...> |
2638 | make_tuple(_Elements&&... __args) |
2639 | { |
2640 | typedef tuple<typename __decay_and_strip<_Elements>::__type...> |
2641 | __result_type; |
2642 | return __result_type(std::forward<_Elements>(__args)...); |
2643 | } |
2644 | |
2645 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
2646 | // 2275. Why is forward_as_tuple not constexpr? |
2647 | /// Create a tuple of lvalue or rvalue references to the arguments |
2648 | template<typename... _Elements> |
2649 | constexpr tuple<_Elements&&...> |
2650 | forward_as_tuple(_Elements&&... __args) noexcept |
2651 | { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } |
2652 | |
2653 | /// @cond undocumented |
2654 | template<size_t, typename, typename, size_t> |
2655 | struct __make_tuple_impl; |
2656 | |
2657 | template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm> |
2658 | struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> |
2659 | : __make_tuple_impl<_Idx + 1, |
2660 | tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, |
2661 | _Tuple, _Nm> |
2662 | { }; |
2663 | |
2664 | template<size_t _Nm, typename _Tuple, typename... _Tp> |
2665 | struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> |
2666 | { |
2667 | typedef tuple<_Tp...> __type; |
2668 | }; |
2669 | |
2670 | template<typename _Tuple> |
2671 | struct __do_make_tuple |
2672 | : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> |
2673 | { }; |
2674 | |
2675 | // Returns the std::tuple equivalent of a tuple-like type. |
2676 | template<typename _Tuple> |
2677 | struct __make_tuple |
2678 | : public __do_make_tuple<__remove_cvref_t<_Tuple>> |
2679 | { }; |
2680 | |
2681 | // Combines several std::tuple's into a single one. |
2682 | template<typename...> |
2683 | struct __combine_tuples; |
2684 | |
2685 | template<> |
2686 | struct __combine_tuples<> |
2687 | { |
2688 | typedef tuple<> __type; |
2689 | }; |
2690 | |
2691 | template<typename... _Ts> |
2692 | struct __combine_tuples<tuple<_Ts...>> |
2693 | { |
2694 | typedef tuple<_Ts...> __type; |
2695 | }; |
2696 | |
2697 | template<typename... _T1s, typename... _T2s, typename... _Rem> |
2698 | struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> |
2699 | { |
2700 | typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, |
2701 | _Rem...>::__type __type; |
2702 | }; |
2703 | |
2704 | // Computes the result type of tuple_cat given a set of tuple-like types. |
2705 | template<typename... _Tpls> |
2706 | struct __tuple_cat_result |
2707 | { |
2708 | typedef typename __combine_tuples |
2709 | <typename __make_tuple<_Tpls>::__type...>::__type __type; |
2710 | }; |
2711 | |
2712 | // Helper to determine the index set for the first tuple-like |
2713 | // type of a given set. |
2714 | template<typename...> |
2715 | struct __make_1st_indices; |
2716 | |
2717 | template<> |
2718 | struct __make_1st_indices<> |
2719 | { |
2720 | typedef _Index_tuple<> __type; |
2721 | }; |
2722 | |
2723 | template<typename _Tp, typename... _Tpls> |
2724 | struct __make_1st_indices<_Tp, _Tpls...> |
2725 | { |
2726 | typedef typename _Build_index_tuple<tuple_size< |
2727 | typename remove_reference<_Tp>::type>::value>::__type __type; |
2728 | }; |
2729 | |
2730 | // Performs the actual concatenation by step-wise expanding tuple-like |
2731 | // objects into the elements, which are finally forwarded into the |
2732 | // result tuple. |
2733 | template<typename _Ret, typename _Indices, typename... _Tpls> |
2734 | struct __tuple_concater; |
2735 | |
2736 | template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls> |
2737 | struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> |
2738 | { |
2739 | template<typename... _Us> |
2740 | static constexpr _Ret |
2741 | _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) |
2742 | { |
2743 | typedef typename __make_1st_indices<_Tpls...>::__type __idx; |
2744 | typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; |
2745 | return __next::_S_do(std::forward<_Tpls>(__tps)..., |
2746 | std::forward<_Us>(__us)..., |
2747 | std::get<_Is>(std::forward<_Tp>(__tp))...); |
2748 | } |
2749 | }; |
2750 | |
2751 | template<typename _Ret> |
2752 | struct __tuple_concater<_Ret, _Index_tuple<>> |
2753 | { |
2754 | template<typename... _Us> |
2755 | static constexpr _Ret |
2756 | _S_do(_Us&&... __us) |
2757 | { |
2758 | return _Ret(std::forward<_Us>(__us)...); |
2759 | } |
2760 | }; |
2761 | |
2762 | template<typename... _Tps> |
2763 | struct __is_tuple_like_impl<tuple<_Tps...>> : true_type |
2764 | { }; |
2765 | /// @endcond |
2766 | |
2767 | /// Create a `tuple` containing all elements from multiple tuple-like objects |
2768 | #if __cpp_lib_tuple_like // >= C++23 |
2769 | template<__tuple_like... _Tpls> |
2770 | #else |
2771 | template<typename... _Tpls, typename = typename |
2772 | enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type> |
2773 | #endif |
2774 | constexpr auto |
2775 | tuple_cat(_Tpls&&... __tpls) |
2776 | -> typename __tuple_cat_result<_Tpls...>::__type |
2777 | { |
2778 | typedef typename __tuple_cat_result<_Tpls...>::__type __ret; |
2779 | typedef typename __make_1st_indices<_Tpls...>::__type __idx; |
2780 | typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; |
2781 | return __concater::_S_do(std::forward<_Tpls>(__tpls)...); |
2782 | } |
2783 | |
2784 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
2785 | // 2301. Why is tie not constexpr? |
2786 | /// Return a tuple of lvalue references bound to the arguments |
2787 | template<typename... _Elements> |
2788 | constexpr tuple<_Elements&...> |
2789 | tie(_Elements&... __args) noexcept |
2790 | { return tuple<_Elements&...>(__args...); } |
2791 | |
2792 | /// Exchange the values of two tuples |
2793 | template<typename... _Elements> |
2794 | _GLIBCXX20_CONSTEXPR |
2795 | inline |
2796 | #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 |
2797 | // Constrained free swap overload, see p0185r1 |
2798 | typename enable_if<__and_<__is_swappable<_Elements>...>::value |
2799 | >::type |
2800 | #else |
2801 | void |
2802 | #endif |
2803 | swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) |
2804 | noexcept(noexcept(__x.swap(__y))) |
2805 | { __x.swap(__y); } |
2806 | |
2807 | #if __cpp_lib_ranges_zip // >= C++23 |
2808 | template<typename... _Elements> |
2809 | requires (is_swappable_v<const _Elements> && ...) |
2810 | constexpr void |
2811 | swap(const tuple<_Elements...>& __x, const tuple<_Elements...>& __y) |
2812 | noexcept(noexcept(__x.swap(__y))) |
2813 | { __x.swap(__y); } |
2814 | #endif // C++23 |
2815 | |
2816 | #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 |
2817 | /// Exchange the values of two const tuples (if const elements can be swapped) |
2818 | template<typename... _Elements> |
2819 | _GLIBCXX20_CONSTEXPR |
2820 | typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type |
2821 | swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; |
2822 | #endif |
2823 | |
2824 | // A class (and instance) which can be used in 'tie' when an element |
2825 | // of a tuple is not required. |
2826 | // _GLIBCXX14_CONSTEXPR |
2827 | // 2933. PR for LWG 2773 could be clearer |
2828 | struct _Swallow_assign |
2829 | { |
2830 | template<class _Tp> |
2831 | _GLIBCXX14_CONSTEXPR const _Swallow_assign& |
2832 | operator=(const _Tp&) const |
2833 | { return *this; } |
2834 | }; |
2835 | |
2836 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
2837 | // 2773. Making std::ignore constexpr |
2838 | /** Used with `std::tie` to ignore an element of a tuple |
2839 | * |
2840 | * When using `std::tie` to assign the elements of a tuple to variables, |
2841 | * unwanted elements can be ignored by using `std::ignore`. For example: |
2842 | * |
2843 | * ``` |
2844 | * int x, y; |
2845 | * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3); |
2846 | * ``` |
2847 | * |
2848 | * This assignment will perform `x=1; std::ignore=2; y=3;` which results |
2849 | * in the second element being ignored. |
2850 | * |
2851 | * @since C++11 |
2852 | */ |
2853 | _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{}; |
2854 | |
2855 | /// Partial specialization for tuples |
2856 | template<typename... _Types, typename _Alloc> |
2857 | struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { }; |
2858 | |
2859 | // See stl_pair.h... |
2860 | /** "piecewise construction" using a tuple of arguments for each member. |
2861 | * |
2862 | * @param __first Arguments for the first member of the pair. |
2863 | * @param __second Arguments for the second member of the pair. |
2864 | * |
2865 | * The elements of each tuple will be used as the constructor arguments |
2866 | * for the data members of the pair. |
2867 | */ |
2868 | template<class _T1, class _T2> |
2869 | template<typename... _Args1, typename... _Args2> |
2870 | _GLIBCXX20_CONSTEXPR |
2871 | inline |
2872 | pair<_T1, _T2>:: |
2873 | pair(piecewise_construct_t, |
2874 | tuple<_Args1...> __first, tuple<_Args2...> __second) |
2875 | : pair(__first, __second, |
2876 | typename _Build_index_tuple<sizeof...(_Args1)>::__type(), |
2877 | typename _Build_index_tuple<sizeof...(_Args2)>::__type()) |
2878 | { } |
2879 | |
2880 | template<class _T1, class _T2> |
2881 | template<typename... _Args1, size_t... _Indexes1, |
2882 | typename... _Args2, size_t... _Indexes2> |
2883 | _GLIBCXX20_CONSTEXPR inline |
2884 | pair<_T1, _T2>:: |
2885 | pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, |
2886 | _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) |
2887 | : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), |
2888 | second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) |
2889 | { } |
2890 | |
2891 | #if defined(__cpp_lib_apply) || defined(__cpp_lib_make_from_tuple) // C++ >= 17 |
2892 | // Unpack a std::tuple into a type trait and use its value. |
2893 | // For cv std::tuple<_Up> the result is _Trait<_Tp, cv _Up...>::value. |
2894 | // For cv std::tuple<_Up>& the result is _Trait<_Tp, cv _Up&...>::value. |
2895 | // Otherwise the result is false (because we don't know if std::get throws). |
2896 | template<template<typename...> class _Trait, typename _Tp, typename _Tuple> |
2897 | inline constexpr bool __unpack_std_tuple = false; |
2898 | |
2899 | template<template<typename...> class _Trait, typename _Tp, typename... _Up> |
2900 | inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> |
2901 | = _Trait<_Tp, _Up...>::value; |
2902 | |
2903 | template<template<typename...> class _Trait, typename _Tp, typename... _Up> |
2904 | inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> |
2905 | = _Trait<_Tp, _Up&...>::value; |
2906 | |
2907 | template<template<typename...> class _Trait, typename _Tp, typename... _Up> |
2908 | inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> |
2909 | = _Trait<_Tp, const _Up...>::value; |
2910 | |
2911 | template<template<typename...> class _Trait, typename _Tp, typename... _Up> |
2912 | inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> |
2913 | = _Trait<_Tp, const _Up&...>::value; |
2914 | #endif |
2915 | |
2916 | #ifdef __cpp_lib_apply // C++ >= 17 |
2917 | template <typename _Fn, typename _Tuple, size_t... _Idx> |
2918 | constexpr decltype(auto) |
2919 | __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) |
2920 | { |
2921 | return std::__invoke(std::forward<_Fn>(__f), |
2922 | std::get<_Idx>(std::forward<_Tuple>(__t))...); |
2923 | } |
2924 | |
2925 | #if __cpp_lib_tuple_like // >= C++23 |
2926 | template <typename _Fn, __tuple_like _Tuple> |
2927 | #else |
2928 | template <typename _Fn, typename _Tuple> |
2929 | #endif |
2930 | constexpr decltype(auto) |
2931 | apply(_Fn&& __f, _Tuple&& __t) |
2932 | noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>) |
2933 | { |
2934 | using _Indices |
2935 | = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>; |
2936 | return std::__apply_impl(std::forward<_Fn>(__f), |
2937 | std::forward<_Tuple>(__t), |
2938 | _Indices{}); |
2939 | } |
2940 | #endif |
2941 | |
2942 | #ifdef __cpp_lib_make_from_tuple // C++ >= 17 |
2943 | template <typename _Tp, typename _Tuple, size_t... _Idx> |
2944 | constexpr _Tp |
2945 | __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) |
2946 | { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } |
2947 | |
2948 | #if __cpp_lib_tuple_like // >= C++23 |
2949 | template <typename _Tp, __tuple_like _Tuple> |
2950 | #else |
2951 | template <typename _Tp, typename _Tuple> |
2952 | #endif |
2953 | constexpr _Tp |
2954 | make_from_tuple(_Tuple&& __t) |
2955 | noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>) |
2956 | { |
2957 | constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>; |
2958 | #if __has_builtin(__reference_constructs_from_temporary) |
2959 | if constexpr (__n == 1) |
2960 | { |
2961 | using _Elt = decltype(std::get<0>(std::declval<_Tuple>())); |
2962 | static_assert(!__reference_constructs_from_temporary(_Tp, _Elt)); |
2963 | } |
2964 | #endif |
2965 | return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), |
2966 | make_index_sequence<__n>{}); |
2967 | } |
2968 | #endif |
2969 | |
2970 | #if __cpp_lib_tuple_like // >= C++23 |
2971 | template<__tuple_like _TTuple, __tuple_like _UTuple, |
2972 | template<typename> class _TQual, template<typename> class _UQual, |
2973 | typename = make_index_sequence<tuple_size_v<_TTuple>>> |
2974 | struct __tuple_like_common_reference; |
2975 | |
2976 | template<__tuple_like _TTuple, __tuple_like _UTuple, |
2977 | template<typename> class _TQual, template<typename> class _UQual, |
2978 | size_t... _Is> |
2979 | requires requires |
2980 | { typename tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>, |
2981 | _UQual<tuple_element_t<_Is, _UTuple>>>...>; } |
2982 | struct __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Is...>> |
2983 | { |
2984 | using type = tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>, |
2985 | _UQual<tuple_element_t<_Is, _UTuple>>>...>; |
2986 | }; |
2987 | |
2988 | template<__tuple_like _TTuple, __tuple_like _UTuple, |
2989 | template<typename> class _TQual, template<typename> class _UQual> |
2990 | requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>) |
2991 | && is_same_v<_TTuple, decay_t<_TTuple>> |
2992 | && is_same_v<_UTuple, decay_t<_UTuple>> |
2993 | && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>) |
2994 | && requires { typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; } |
2995 | struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual> |
2996 | { |
2997 | using type = typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; |
2998 | }; |
2999 | |
3000 | template<__tuple_like _TTuple, __tuple_like _UTuple, |
3001 | typename = make_index_sequence<tuple_size_v<_TTuple>>> |
3002 | struct __tuple_like_common_type; |
3003 | |
3004 | template<__tuple_like _TTuple, __tuple_like _UTuple, size_t... _Is> |
3005 | requires requires |
3006 | { typename tuple<common_type_t<tuple_element_t<_Is, _TTuple>, |
3007 | tuple_element_t<_Is, _UTuple>>...>; } |
3008 | struct __tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Is...>> |
3009 | { |
3010 | using type = tuple<common_type_t<tuple_element_t<_Is, _TTuple>, |
3011 | tuple_element_t<_Is, _UTuple>>...>; |
3012 | }; |
3013 | |
3014 | template<__tuple_like _TTuple, __tuple_like _UTuple> |
3015 | requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>) |
3016 | && is_same_v<_TTuple, decay_t<_TTuple>> |
3017 | && is_same_v<_UTuple, decay_t<_UTuple>> |
3018 | && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>) |
3019 | && requires { typename __tuple_like_common_type<_TTuple, _UTuple>::type; } |
3020 | struct common_type<_TTuple, _UTuple> |
3021 | { |
3022 | using type = typename __tuple_like_common_type<_TTuple, _UTuple>::type; |
3023 | }; |
3024 | #endif // C++23 |
3025 | |
3026 | /// @} |
3027 | |
3028 | #undef __glibcxx_no_dangling_refs |
3029 | |
3030 | _GLIBCXX_END_NAMESPACE_VERSION |
3031 | } // namespace std |
3032 | |
3033 | #endif // C++11 |
3034 | |
3035 | #endif // _GLIBCXX_TUPLE |
3036 | |