1// <tuple> -*- C++ -*-
2
3// Copyright (C) 2007-2019 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 <utility>
39#include <array>
40#include <bits/uses_allocator.h>
41#include <bits/invoke.h>
42
43namespace std _GLIBCXX_VISIBILITY(default)
44{
45_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47 /**
48 * @addtogroup utilities
49 * @{
50 */
51
52 template<typename... _Elements>
53 class tuple;
54
55 template<typename _Tp>
56 struct __is_empty_non_tuple : is_empty<_Tp> { };
57
58 // Using EBO for elements that are tuples causes ambiguous base errors.
59 template<typename _El0, typename... _El>
60 struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
61
62 // Use the Empty Base-class Optimization for empty, non-final types.
63 template<typename _Tp>
64 using __empty_not_final
65 = typename conditional<__is_final(_Tp), false_type,
66 __is_empty_non_tuple<_Tp>>::type;
67
68 template<std::size_t _Idx, typename _Head,
69 bool = __empty_not_final<_Head>::value>
70 struct _Head_base;
71
72 template<std::size_t _Idx, typename _Head>
73 struct _Head_base<_Idx, _Head, true>
74 : public _Head
75 {
76 constexpr _Head_base()
77 : _Head() { }
78
79 constexpr _Head_base(const _Head& __h)
80 : _Head(__h) { }
81
82 constexpr _Head_base(const _Head_base&) = default;
83 constexpr _Head_base(_Head_base&&) = default;
84
85 template<typename _UHead>
86 constexpr _Head_base(_UHead&& __h)
87 : _Head(std::forward<_UHead>(__h)) { }
88
89 _Head_base(allocator_arg_t, __uses_alloc0)
90 : _Head() { }
91
92 template<typename _Alloc>
93 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
94 : _Head(allocator_arg, *__a._M_a) { }
95
96 template<typename _Alloc>
97 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
98 : _Head(*__a._M_a) { }
99
100 template<typename _UHead>
101 _Head_base(__uses_alloc0, _UHead&& __uhead)
102 : _Head(std::forward<_UHead>(__uhead)) { }
103
104 template<typename _Alloc, typename _UHead>
105 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
106 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
107
108 template<typename _Alloc, typename _UHead>
109 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
110 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
111
112 static constexpr _Head&
113 _M_head(_Head_base& __b) noexcept { return __b; }
114
115 static constexpr const _Head&
116 _M_head(const _Head_base& __b) noexcept { return __b; }
117 };
118
119 template<std::size_t _Idx, typename _Head>
120 struct _Head_base<_Idx, _Head, false>
121 {
122 constexpr _Head_base()
123 : _M_head_impl() { }
124
125 constexpr _Head_base(const _Head& __h)
126 : _M_head_impl(__h) { }
127
128 constexpr _Head_base(const _Head_base&) = default;
129 constexpr _Head_base(_Head_base&&) = default;
130
131 template<typename _UHead>
132 constexpr _Head_base(_UHead&& __h)
133 : _M_head_impl(std::forward<_UHead>(__h)) { }
134
135 _Head_base(allocator_arg_t, __uses_alloc0)
136 : _M_head_impl() { }
137
138 template<typename _Alloc>
139 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
140 : _M_head_impl(allocator_arg, *__a._M_a) { }
141
142 template<typename _Alloc>
143 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
144 : _M_head_impl(*__a._M_a) { }
145
146 template<typename _UHead>
147 _Head_base(__uses_alloc0, _UHead&& __uhead)
148 : _M_head_impl(std::forward<_UHead>(__uhead)) { }
149
150 template<typename _Alloc, typename _UHead>
151 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
152 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
153 { }
154
155 template<typename _Alloc, typename _UHead>
156 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
157 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
158
159 static constexpr _Head&
160 _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
161
162 static constexpr const _Head&
163 _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
164
165 _Head _M_head_impl;
166 };
167
168 /**
169 * Contains the actual implementation of the @c tuple template, stored
170 * as a recursive inheritance hierarchy from the first element (most
171 * derived class) to the last (least derived class). The @c Idx
172 * parameter gives the 0-based index of the element stored at this
173 * point in the hierarchy; we use it to implement a constant-time
174 * get() operation.
175 */
176 template<std::size_t _Idx, typename... _Elements>
177 struct _Tuple_impl;
178
179 /**
180 * Recursive tuple implementation. Here we store the @c Head element
181 * and derive from a @c Tuple_impl containing the remaining elements
182 * (which contains the @c Tail).
183 */
184 template<std::size_t _Idx, typename _Head, typename... _Tail>
185 struct _Tuple_impl<_Idx, _Head, _Tail...>
186 : public _Tuple_impl<_Idx + 1, _Tail...>,
187 private _Head_base<_Idx, _Head>
188 {
189 template<std::size_t, typename...> friend class _Tuple_impl;
190
191 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192 typedef _Head_base<_Idx, _Head> _Base;
193
194 static constexpr _Head&
195 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
196
197 static constexpr const _Head&
198 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
199
200 static constexpr _Inherited&
201 _M_tail(_Tuple_impl& __t) noexcept { return __t; }
202
203 static constexpr const _Inherited&
204 _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
205
206 constexpr _Tuple_impl()
207 : _Inherited(), _Base() { }
208
209 explicit
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
211 : _Inherited(__tail...), _Base(__head) { }
212
213 template<typename _UHead, typename... _UTail, typename = typename
214 enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
215 explicit
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
217 : _Inherited(std::forward<_UTail>(__tail)...),
218 _Base(std::forward<_UHead>(__head)) { }
219
220 constexpr _Tuple_impl(const _Tuple_impl&) = default;
221
222 // _GLIBCXX_RESOLVE_LIB_DEFECTS
223 // 2729. Missing SFINAE on std::pair::operator=
224 _Tuple_impl& operator=(const _Tuple_impl&) = delete;
225
226 constexpr
227 _Tuple_impl(_Tuple_impl&& __in)
228 noexcept(__and_<is_nothrow_move_constructible<_Head>,
229 is_nothrow_move_constructible<_Inherited>>::value)
230 : _Inherited(std::move(_M_tail(__in))),
231 _Base(std::forward<_Head>(_M_head(__in))) { }
232
233 template<typename... _UElements>
234 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
236 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
237
238 template<typename _UHead, typename... _UTails>
239 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
240 : _Inherited(std::move
241 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
242 _Base(std::forward<_UHead>
243 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
244
245 template<typename _Alloc>
246 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
247 : _Inherited(__tag, __a),
248 _Base(__tag, __use_alloc<_Head>(__a)) { }
249
250 template<typename _Alloc>
251 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
252 const _Head& __head, const _Tail&... __tail)
253 : _Inherited(__tag, __a, __tail...),
254 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
255
256 template<typename _Alloc, typename _UHead, typename... _UTail,
257 typename = typename enable_if<sizeof...(_Tail)
258 == sizeof...(_UTail)>::type>
259 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
260 _UHead&& __head, _UTail&&... __tail)
261 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
262 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
263 std::forward<_UHead>(__head)) { }
264
265 template<typename _Alloc>
266 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
267 const _Tuple_impl& __in)
268 : _Inherited(__tag, __a, _M_tail(__in)),
269 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
270
271 template<typename _Alloc>
272 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
273 _Tuple_impl&& __in)
274 : _Inherited(__tag, __a, std::move(_M_tail(__in))),
275 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
276 std::forward<_Head>(_M_head(__in))) { }
277
278 template<typename _Alloc, typename... _UElements>
279 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
280 const _Tuple_impl<_Idx, _UElements...>& __in)
281 : _Inherited(__tag, __a,
282 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
283 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
284 _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
285
286 template<typename _Alloc, typename _UHead, typename... _UTails>
287 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
288 _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
289 : _Inherited(__tag, __a, std::move
290 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
291 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
292 std::forward<_UHead>
293 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
294
295 template<typename... _UElements>
296 void
297 _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
298 {
299 _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
300 _M_tail(*this)._M_assign(
301 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
302 }
303
304 template<typename _UHead, typename... _UTails>
305 void
306 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
307 {
308 _M_head(*this) = std::forward<_UHead>
309 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
310 _M_tail(*this)._M_assign(
311 std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
312 }
313
314 protected:
315 void
316 _M_swap(_Tuple_impl& __in)
317 {
318 using std::swap;
319 swap(_M_head(*this), _M_head(__in));
320 _Inherited::_M_swap(_M_tail(__in));
321 }
322 };
323
324 // Basis case of inheritance recursion.
325 template<std::size_t _Idx, typename _Head>
326 struct _Tuple_impl<_Idx, _Head>
327 : private _Head_base<_Idx, _Head>
328 {
329 template<std::size_t, typename...> friend class _Tuple_impl;
330
331 typedef _Head_base<_Idx, _Head> _Base;
332
333 static constexpr _Head&
334 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
335
336 static constexpr const _Head&
337 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
338
339 constexpr _Tuple_impl()
340 : _Base() { }
341
342 explicit
343 constexpr _Tuple_impl(const _Head& __head)
344 : _Base(__head) { }
345
346 template<typename _UHead>
347 explicit
348 constexpr _Tuple_impl(_UHead&& __head)
349 : _Base(std::forward<_UHead>(__head)) { }
350
351 constexpr _Tuple_impl(const _Tuple_impl&) = default;
352
353 // _GLIBCXX_RESOLVE_LIB_DEFECTS
354 // 2729. Missing SFINAE on std::pair::operator=
355 _Tuple_impl& operator=(const _Tuple_impl&) = delete;
356
357 constexpr
358 _Tuple_impl(_Tuple_impl&& __in)
359 noexcept(is_nothrow_move_constructible<_Head>::value)
360 : _Base(std::forward<_Head>(_M_head(__in))) { }
361
362 template<typename _UHead>
363 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
364 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
365
366 template<typename _UHead>
367 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
368 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
369 { }
370
371 template<typename _Alloc>
372 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
373 : _Base(__tag, __use_alloc<_Head>(__a)) { }
374
375 template<typename _Alloc>
376 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
377 const _Head& __head)
378 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
379
380 template<typename _Alloc, typename _UHead>
381 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
382 _UHead&& __head)
383 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
384 std::forward<_UHead>(__head)) { }
385
386 template<typename _Alloc>
387 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
388 const _Tuple_impl& __in)
389 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
390
391 template<typename _Alloc>
392 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
393 _Tuple_impl&& __in)
394 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
395 std::forward<_Head>(_M_head(__in))) { }
396
397 template<typename _Alloc, typename _UHead>
398 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
399 const _Tuple_impl<_Idx, _UHead>& __in)
400 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
401 _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
402
403 template<typename _Alloc, typename _UHead>
404 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
405 _Tuple_impl<_Idx, _UHead>&& __in)
406 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
407 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
408 { }
409
410 template<typename _UHead>
411 void
412 _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
413 {
414 _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
415 }
416
417 template<typename _UHead>
418 void
419 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
420 {
421 _M_head(*this)
422 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
423 }
424
425 protected:
426 void
427 _M_swap(_Tuple_impl& __in)
428 {
429 using std::swap;
430 swap(_M_head(*this), _M_head(__in));
431 }
432 };
433
434 // Concept utility functions, reused in conditionally-explicit
435 // constructors.
436 template<bool, typename... _Elements>
437 struct _TC
438 {
439 template<typename... _UElements>
440 static constexpr bool _ConstructibleTuple()
441 {
442 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
443 }
444
445 template<typename... _UElements>
446 static constexpr bool _ImplicitlyConvertibleTuple()
447 {
448 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
449 }
450
451 template<typename... _UElements>
452 static constexpr bool _MoveConstructibleTuple()
453 {
454 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
455 }
456
457 template<typename... _UElements>
458 static constexpr bool _ImplicitlyMoveConvertibleTuple()
459 {
460 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
461 }
462
463 template<typename _SrcTuple>
464 static constexpr bool _NonNestedTuple()
465 {
466 return __and_<__not_<is_same<tuple<_Elements...>,
467 __remove_cvref_t<_SrcTuple>>>,
468 __not_<is_convertible<_SrcTuple, _Elements...>>,
469 __not_<is_constructible<_Elements..., _SrcTuple>>
470 >::value;
471 }
472
473 template<typename... _UElements>
474 static constexpr bool _NotSameTuple()
475 {
476 return __not_<is_same<tuple<_Elements...>,
477 __remove_cvref_t<_UElements>...>>::value;
478 }
479 };
480
481 template<typename... _Elements>
482 struct _TC<false, _Elements...>
483 {
484 template<typename... _UElements>
485 static constexpr bool _ConstructibleTuple()
486 {
487 return false;
488 }
489
490 template<typename... _UElements>
491 static constexpr bool _ImplicitlyConvertibleTuple()
492 {
493 return false;
494 }
495
496 template<typename... _UElements>
497 static constexpr bool _MoveConstructibleTuple()
498 {
499 return false;
500 }
501
502 template<typename... _UElements>
503 static constexpr bool _ImplicitlyMoveConvertibleTuple()
504 {
505 return false;
506 }
507
508 template<typename... _UElements>
509 static constexpr bool _NonNestedTuple()
510 {
511 return true;
512 }
513
514 template<typename... _UElements>
515 static constexpr bool _NotSameTuple()
516 {
517 return true;
518 }
519 };
520
521 /// Primary class template, tuple
522 template<typename... _Elements>
523 class tuple : public _Tuple_impl<0, _Elements...>
524 {
525 typedef _Tuple_impl<0, _Elements...> _Inherited;
526
527 // Used for constraining the default constructor so
528 // that it becomes dependent on the constraints.
529 template<typename _Dummy>
530 struct _TC2
531 {
532 static constexpr bool _DefaultConstructibleTuple()
533 {
534 return __and_<is_default_constructible<_Elements>...>::value;
535 }
536 static constexpr bool _ImplicitlyDefaultConstructibleTuple()
537 {
538 return __and_<__is_implicitly_default_constructible<_Elements>...>
539 ::value;
540 }
541 };
542
543 template<typename... _UElements>
544 static constexpr
545 __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
546 __assignable()
547 { return __and_<is_assignable<_Elements&, _UElements>...>::value; }
548
549 template<typename... _UElements>
550 static constexpr bool __nothrow_assignable()
551 {
552 return
553 __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
554 }
555
556 public:
557 template<typename _Dummy = void,
558 typename enable_if<_TC2<_Dummy>::
559 _ImplicitlyDefaultConstructibleTuple(),
560 bool>::type = true>
561 constexpr tuple()
562 : _Inherited() { }
563
564 template<typename _Dummy = void,
565 typename enable_if<_TC2<_Dummy>::
566 _DefaultConstructibleTuple()
567 &&
568 !_TC2<_Dummy>::
569 _ImplicitlyDefaultConstructibleTuple(),
570 bool>::type = false>
571 explicit constexpr tuple()
572 : _Inherited() { }
573
574 // Shortcut for the cases where constructors taking _Elements...
575 // need to be constrained.
576 template<typename _Dummy> using _TCC =
577 _TC<is_same<_Dummy, void>::value,
578 _Elements...>;
579
580 template<typename _Dummy = void,
581 typename enable_if<
582 _TCC<_Dummy>::template
583 _ConstructibleTuple<_Elements...>()
584 && _TCC<_Dummy>::template
585 _ImplicitlyConvertibleTuple<_Elements...>()
586 && (sizeof...(_Elements) >= 1),
587 bool>::type=true>
588 constexpr tuple(const _Elements&... __elements)
589 : _Inherited(__elements...) { }
590
591 template<typename _Dummy = void,
592 typename enable_if<
593 _TCC<_Dummy>::template
594 _ConstructibleTuple<_Elements...>()
595 && !_TCC<_Dummy>::template
596 _ImplicitlyConvertibleTuple<_Elements...>()
597 && (sizeof...(_Elements) >= 1),
598 bool>::type=false>
599 explicit constexpr tuple(const _Elements&... __elements)
600 : _Inherited(__elements...) { }
601
602 // Shortcut for the cases where constructors taking _UElements...
603 // need to be constrained.
604 template<typename... _UElements> using _TMC =
605 _TC<(sizeof...(_Elements) == sizeof...(_UElements))
606 && (_TC<(sizeof...(_UElements)==1), _Elements...>::
607 template _NotSameTuple<_UElements...>()),
608 _Elements...>;
609
610 // Shortcut for the cases where constructors taking tuple<_UElements...>
611 // need to be constrained.
612 template<typename... _UElements> using _TMCT =
613 _TC<(sizeof...(_Elements) == sizeof...(_UElements))
614 && !is_same<tuple<_Elements...>,
615 tuple<_UElements...>>::value,
616 _Elements...>;
617
618 template<typename... _UElements, typename
619 enable_if<
620 _TMC<_UElements...>::template
621 _MoveConstructibleTuple<_UElements...>()
622 && _TMC<_UElements...>::template
623 _ImplicitlyMoveConvertibleTuple<_UElements...>()
624 && (sizeof...(_Elements) >= 1),
625 bool>::type=true>
626 constexpr tuple(_UElements&&... __elements)
627 : _Inherited(std::forward<_UElements>(__elements)...) { }
628
629 template<typename... _UElements, typename
630 enable_if<
631 _TMC<_UElements...>::template
632 _MoveConstructibleTuple<_UElements...>()
633 && !_TMC<_UElements...>::template
634 _ImplicitlyMoveConvertibleTuple<_UElements...>()
635 && (sizeof...(_Elements) >= 1),
636 bool>::type=false>
637 explicit constexpr tuple(_UElements&&... __elements)
638 : _Inherited(std::forward<_UElements>(__elements)...) { }
639
640 constexpr tuple(const tuple&) = default;
641
642 constexpr tuple(tuple&&) = default;
643
644 // Shortcut for the cases where constructors taking tuples
645 // must avoid creating temporaries.
646 template<typename _Dummy> using _TNTC =
647 _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
648 _Elements...>;
649
650 template<typename... _UElements, typename _Dummy = void, typename
651 enable_if<_TMCT<_UElements...>::template
652 _ConstructibleTuple<_UElements...>()
653 && _TMCT<_UElements...>::template
654 _ImplicitlyConvertibleTuple<_UElements...>()
655 && _TNTC<_Dummy>::template
656 _NonNestedTuple<const tuple<_UElements...>&>(),
657 bool>::type=true>
658 constexpr tuple(const tuple<_UElements...>& __in)
659 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
660 { }
661
662 template<typename... _UElements, typename _Dummy = void, typename
663 enable_if<_TMCT<_UElements...>::template
664 _ConstructibleTuple<_UElements...>()
665 && !_TMCT<_UElements...>::template
666 _ImplicitlyConvertibleTuple<_UElements...>()
667 && _TNTC<_Dummy>::template
668 _NonNestedTuple<const tuple<_UElements...>&>(),
669 bool>::type=false>
670 explicit constexpr tuple(const tuple<_UElements...>& __in)
671 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
672 { }
673
674 template<typename... _UElements, typename _Dummy = void, typename
675 enable_if<_TMCT<_UElements...>::template
676 _MoveConstructibleTuple<_UElements...>()
677 && _TMCT<_UElements...>::template
678 _ImplicitlyMoveConvertibleTuple<_UElements...>()
679 && _TNTC<_Dummy>::template
680 _NonNestedTuple<tuple<_UElements...>&&>(),
681 bool>::type=true>
682 constexpr tuple(tuple<_UElements...>&& __in)
683 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
684
685 template<typename... _UElements, typename _Dummy = void, typename
686 enable_if<_TMCT<_UElements...>::template
687 _MoveConstructibleTuple<_UElements...>()
688 && !_TMCT<_UElements...>::template
689 _ImplicitlyMoveConvertibleTuple<_UElements...>()
690 && _TNTC<_Dummy>::template
691 _NonNestedTuple<tuple<_UElements...>&&>(),
692 bool>::type=false>
693 explicit constexpr tuple(tuple<_UElements...>&& __in)
694 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
695
696 // Allocator-extended constructors.
697
698 template<typename _Alloc>
699 tuple(allocator_arg_t __tag, const _Alloc& __a)
700 : _Inherited(__tag, __a) { }
701
702 template<typename _Alloc, typename _Dummy = void,
703 typename enable_if<
704 _TCC<_Dummy>::template
705 _ConstructibleTuple<_Elements...>()
706 && _TCC<_Dummy>::template
707 _ImplicitlyConvertibleTuple<_Elements...>(),
708 bool>::type=true>
709 tuple(allocator_arg_t __tag, const _Alloc& __a,
710 const _Elements&... __elements)
711 : _Inherited(__tag, __a, __elements...) { }
712
713 template<typename _Alloc, typename _Dummy = void,
714 typename enable_if<
715 _TCC<_Dummy>::template
716 _ConstructibleTuple<_Elements...>()
717 && !_TCC<_Dummy>::template
718 _ImplicitlyConvertibleTuple<_Elements...>(),
719 bool>::type=false>
720 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
721 const _Elements&... __elements)
722 : _Inherited(__tag, __a, __elements...) { }
723
724 template<typename _Alloc, typename... _UElements, typename
725 enable_if<_TMC<_UElements...>::template
726 _MoveConstructibleTuple<_UElements...>()
727 && _TMC<_UElements...>::template
728 _ImplicitlyMoveConvertibleTuple<_UElements...>(),
729 bool>::type=true>
730 tuple(allocator_arg_t __tag, const _Alloc& __a,
731 _UElements&&... __elements)
732 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
733 { }
734
735 template<typename _Alloc, typename... _UElements, typename
736 enable_if<_TMC<_UElements...>::template
737 _MoveConstructibleTuple<_UElements...>()
738 && !_TMC<_UElements...>::template
739 _ImplicitlyMoveConvertibleTuple<_UElements...>(),
740 bool>::type=false>
741 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
742 _UElements&&... __elements)
743 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
744 { }
745
746 template<typename _Alloc>
747 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
748 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
749
750 template<typename _Alloc>
751 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
752 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
753
754 template<typename _Alloc, typename _Dummy = void,
755 typename... _UElements, typename
756 enable_if<_TMCT<_UElements...>::template
757 _ConstructibleTuple<_UElements...>()
758 && _TMCT<_UElements...>::template
759 _ImplicitlyConvertibleTuple<_UElements...>()
760 && _TNTC<_Dummy>::template
761 _NonNestedTuple<tuple<_UElements...>&&>(),
762 bool>::type=true>
763 tuple(allocator_arg_t __tag, const _Alloc& __a,
764 const tuple<_UElements...>& __in)
765 : _Inherited(__tag, __a,
766 static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
767 { }
768
769 template<typename _Alloc, typename _Dummy = void,
770 typename... _UElements, typename
771 enable_if<_TMCT<_UElements...>::template
772 _ConstructibleTuple<_UElements...>()
773 && !_TMCT<_UElements...>::template
774 _ImplicitlyConvertibleTuple<_UElements...>()
775 && _TNTC<_Dummy>::template
776 _NonNestedTuple<tuple<_UElements...>&&>(),
777 bool>::type=false>
778 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
779 const tuple<_UElements...>& __in)
780 : _Inherited(__tag, __a,
781 static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
782 { }
783
784 template<typename _Alloc, typename _Dummy = void,
785 typename... _UElements, typename
786 enable_if<_TMCT<_UElements...>::template
787 _MoveConstructibleTuple<_UElements...>()
788 && _TMCT<_UElements...>::template
789 _ImplicitlyMoveConvertibleTuple<_UElements...>()
790 && _TNTC<_Dummy>::template
791 _NonNestedTuple<tuple<_UElements...>&&>(),
792 bool>::type=true>
793 tuple(allocator_arg_t __tag, const _Alloc& __a,
794 tuple<_UElements...>&& __in)
795 : _Inherited(__tag, __a,
796 static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
797 { }
798
799 template<typename _Alloc, typename _Dummy = void,
800 typename... _UElements, typename
801 enable_if<_TMCT<_UElements...>::template
802 _MoveConstructibleTuple<_UElements...>()
803 && !_TMCT<_UElements...>::template
804 _ImplicitlyMoveConvertibleTuple<_UElements...>()
805 && _TNTC<_Dummy>::template
806 _NonNestedTuple<tuple<_UElements...>&&>(),
807 bool>::type=false>
808 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
809 tuple<_UElements...>&& __in)
810 : _Inherited(__tag, __a,
811 static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
812 { }
813
814 // tuple assignment
815
816 tuple&
817 operator=(typename conditional<__assignable<const _Elements&...>(),
818 const tuple&,
819 const __nonesuch_no_braces&>::type __in)
820 noexcept(__nothrow_assignable<const _Elements&...>())
821 {
822 this->_M_assign(__in);
823 return *this;
824 }
825
826 tuple&
827 operator=(typename conditional<__assignable<_Elements...>(),
828 tuple&&,
829 __nonesuch_no_braces&&>::type __in)
830 noexcept(__nothrow_assignable<_Elements...>())
831 {
832 this->_M_assign(std::move(__in));
833 return *this;
834 }
835
836 template<typename... _UElements>
837 __enable_if_t<__assignable<const _UElements&...>(), tuple&>
838 operator=(const tuple<_UElements...>& __in)
839 noexcept(__nothrow_assignable<const _UElements&...>())
840 {
841 this->_M_assign(__in);
842 return *this;
843 }
844
845 template<typename... _UElements>
846 __enable_if_t<__assignable<_UElements...>(), tuple&>
847 operator=(tuple<_UElements...>&& __in)
848 noexcept(__nothrow_assignable<_UElements...>())
849 {
850 this->_M_assign(std::move(__in));
851 return *this;
852 }
853
854 // tuple swap
855 void
856 swap(tuple& __in)
857 noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
858 { _Inherited::_M_swap(__in); }
859 };
860
861#if __cpp_deduction_guides >= 201606
862 template<typename... _UTypes>
863 tuple(_UTypes...) -> tuple<_UTypes...>;
864 template<typename _T1, typename _T2>
865 tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
866 template<typename _Alloc, typename... _UTypes>
867 tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
868 template<typename _Alloc, typename _T1, typename _T2>
869 tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
870 template<typename _Alloc, typename... _UTypes>
871 tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
872#endif
873
874 // Explicit specialization, zero-element tuple.
875 template<>
876 class tuple<>
877 {
878 public:
879 void swap(tuple&) noexcept { /* no-op */ }
880 // We need the default since we're going to define no-op
881 // allocator constructors.
882 tuple() = default;
883 // No-op allocator constructors.
884 template<typename _Alloc>
885 tuple(allocator_arg_t, const _Alloc&) { }
886 template<typename _Alloc>
887 tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
888 };
889
890 /// Partial specialization, 2-element tuple.
891 /// Includes construction and assignment from a pair.
892 template<typename _T1, typename _T2>
893 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
894 {
895 typedef _Tuple_impl<0, _T1, _T2> _Inherited;
896
897 template<typename _U1, typename _U2>
898 static constexpr bool __assignable()
899 {
900 return __and_<is_assignable<_T1&, _U1>,
901 is_assignable<_T2&, _U2>>::value;
902 }
903
904 template<typename _U1, typename _U2>
905 static constexpr bool __nothrow_assignable()
906 {
907 return __and_<is_nothrow_assignable<_T1&, _U1>,
908 is_nothrow_assignable<_T2&, _U2>>::value;
909 }
910
911 public:
912 template <typename _U1 = _T1,
913 typename _U2 = _T2,
914 typename enable_if<__and_<
915 __is_implicitly_default_constructible<_U1>,
916 __is_implicitly_default_constructible<_U2>>
917 ::value, bool>::type = true>
918 constexpr tuple()
919 : _Inherited() { }
920
921 template <typename _U1 = _T1,
922 typename _U2 = _T2,
923 typename enable_if<
924 __and_<
925 is_default_constructible<_U1>,
926 is_default_constructible<_U2>,
927 __not_<
928 __and_<__is_implicitly_default_constructible<_U1>,
929 __is_implicitly_default_constructible<_U2>>>>
930 ::value, bool>::type = false>
931 explicit constexpr tuple()
932 : _Inherited() { }
933
934 // Shortcut for the cases where constructors taking _T1, _T2
935 // need to be constrained.
936 template<typename _Dummy> using _TCC =
937 _TC<is_same<_Dummy, void>::value, _T1, _T2>;
938
939 template<typename _Dummy = void, typename
940 enable_if<_TCC<_Dummy>::template
941 _ConstructibleTuple<_T1, _T2>()
942 && _TCC<_Dummy>::template
943 _ImplicitlyConvertibleTuple<_T1, _T2>(),
944 bool>::type = true>
945 constexpr tuple(const _T1& __a1, const _T2& __a2)
946 : _Inherited(__a1, __a2) { }
947
948 template<typename _Dummy = void, typename
949 enable_if<_TCC<_Dummy>::template
950 _ConstructibleTuple<_T1, _T2>()
951 && !_TCC<_Dummy>::template
952 _ImplicitlyConvertibleTuple<_T1, _T2>(),
953 bool>::type = false>
954 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
955 : _Inherited(__a1, __a2) { }
956
957 // Shortcut for the cases where constructors taking _U1, _U2
958 // need to be constrained.
959 using _TMC = _TC<true, _T1, _T2>;
960
961 template<typename _U1, typename _U2, typename
962 enable_if<_TMC::template
963 _MoveConstructibleTuple<_U1, _U2>()
964 && _TMC::template
965 _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
966 && !is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value,
967 bool>::type = true>
968 constexpr tuple(_U1&& __a1, _U2&& __a2)
969 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
970
971 template<typename _U1, typename _U2, typename
972 enable_if<_TMC::template
973 _MoveConstructibleTuple<_U1, _U2>()
974 && !_TMC::template
975 _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
976 && !is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value,
977 bool>::type = false>
978 explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
979 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
980
981 constexpr tuple(const tuple&) = default;
982
983 constexpr tuple(tuple&&) = default;
984
985 template<typename _U1, typename _U2, typename
986 enable_if<_TMC::template
987 _ConstructibleTuple<_U1, _U2>()
988 && _TMC::template
989 _ImplicitlyConvertibleTuple<_U1, _U2>(),
990 bool>::type = true>
991 constexpr tuple(const tuple<_U1, _U2>& __in)
992 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
993
994 template<typename _U1, typename _U2, typename
995 enable_if<_TMC::template
996 _ConstructibleTuple<_U1, _U2>()
997 && !_TMC::template
998 _ImplicitlyConvertibleTuple<_U1, _U2>(),
999 bool>::type = false>
1000 explicit constexpr tuple(const tuple<_U1, _U2>& __in)
1001 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
1002
1003 template<typename _U1, typename _U2, typename
1004 enable_if<_TMC::template
1005 _MoveConstructibleTuple<_U1, _U2>()
1006 && _TMC::template
1007 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1008 bool>::type = true>
1009 constexpr tuple(tuple<_U1, _U2>&& __in)
1010 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1011
1012 template<typename _U1, typename _U2, typename
1013 enable_if<_TMC::template
1014 _MoveConstructibleTuple<_U1, _U2>()
1015 && !_TMC::template
1016 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1017 bool>::type = false>
1018 explicit constexpr tuple(tuple<_U1, _U2>&& __in)
1019 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1020
1021 template<typename _U1, typename _U2, typename
1022 enable_if<_TMC::template
1023 _ConstructibleTuple<_U1, _U2>()
1024 && _TMC::template
1025 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1026 bool>::type = true>
1027 constexpr tuple(const pair<_U1, _U2>& __in)
1028 : _Inherited(__in.first, __in.second) { }
1029
1030 template<typename _U1, typename _U2, typename
1031 enable_if<_TMC::template
1032 _ConstructibleTuple<_U1, _U2>()
1033 && !_TMC::template
1034 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1035 bool>::type = false>
1036 explicit constexpr tuple(const pair<_U1, _U2>& __in)
1037 : _Inherited(__in.first, __in.second) { }
1038
1039 template<typename _U1, typename _U2, typename
1040 enable_if<_TMC::template
1041 _MoveConstructibleTuple<_U1, _U2>()
1042 && _TMC::template
1043 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1044 bool>::type = true>
1045 constexpr tuple(pair<_U1, _U2>&& __in)
1046 : _Inherited(std::forward<_U1>(__in.first),
1047 std::forward<_U2>(__in.second)) { }
1048
1049 template<typename _U1, typename _U2, typename
1050 enable_if<_TMC::template
1051 _MoveConstructibleTuple<_U1, _U2>()
1052 && !_TMC::template
1053 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1054 bool>::type = false>
1055 explicit constexpr tuple(pair<_U1, _U2>&& __in)
1056 : _Inherited(std::forward<_U1>(__in.first),
1057 std::forward<_U2>(__in.second)) { }
1058
1059 // Allocator-extended constructors.
1060
1061 template<typename _Alloc>
1062 tuple(allocator_arg_t __tag, const _Alloc& __a)
1063 : _Inherited(__tag, __a) { }
1064
1065 template<typename _Alloc, typename _Dummy = void,
1066 typename enable_if<
1067 _TCC<_Dummy>::template
1068 _ConstructibleTuple<_T1, _T2>()
1069 && _TCC<_Dummy>::template
1070 _ImplicitlyConvertibleTuple<_T1, _T2>(),
1071 bool>::type=true>
1072
1073 tuple(allocator_arg_t __tag, const _Alloc& __a,
1074 const _T1& __a1, const _T2& __a2)
1075 : _Inherited(__tag, __a, __a1, __a2) { }
1076
1077 template<typename _Alloc, typename _Dummy = void,
1078 typename enable_if<
1079 _TCC<_Dummy>::template
1080 _ConstructibleTuple<_T1, _T2>()
1081 && !_TCC<_Dummy>::template
1082 _ImplicitlyConvertibleTuple<_T1, _T2>(),
1083 bool>::type=false>
1084
1085 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1086 const _T1& __a1, const _T2& __a2)
1087 : _Inherited(__tag, __a, __a1, __a2) { }
1088
1089 template<typename _Alloc, typename _U1, typename _U2, typename
1090 enable_if<_TMC::template
1091 _MoveConstructibleTuple<_U1, _U2>()
1092 && _TMC::template
1093 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1094 bool>::type = true>
1095 tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
1096 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1097 std::forward<_U2>(__a2)) { }
1098
1099 template<typename _Alloc, typename _U1, typename _U2, typename
1100 enable_if<_TMC::template
1101 _MoveConstructibleTuple<_U1, _U2>()
1102 && !_TMC::template
1103 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1104 bool>::type = false>
1105 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1106 _U1&& __a1, _U2&& __a2)
1107 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1108 std::forward<_U2>(__a2)) { }
1109
1110 template<typename _Alloc>
1111 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
1112 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
1113
1114 template<typename _Alloc>
1115 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1116 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
1117
1118 template<typename _Alloc, typename _U1, typename _U2, typename
1119 enable_if<_TMC::template
1120 _ConstructibleTuple<_U1, _U2>()
1121 && _TMC::template
1122 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1123 bool>::type = true>
1124 tuple(allocator_arg_t __tag, const _Alloc& __a,
1125 const tuple<_U1, _U2>& __in)
1126 : _Inherited(__tag, __a,
1127 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1128 { }
1129
1130 template<typename _Alloc, typename _U1, typename _U2, typename
1131 enable_if<_TMC::template
1132 _ConstructibleTuple<_U1, _U2>()
1133 && !_TMC::template
1134 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1135 bool>::type = false>
1136 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1137 const tuple<_U1, _U2>& __in)
1138 : _Inherited(__tag, __a,
1139 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1140 { }
1141
1142 template<typename _Alloc, typename _U1, typename _U2, typename
1143 enable_if<_TMC::template
1144 _MoveConstructibleTuple<_U1, _U2>()
1145 && _TMC::template
1146 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1147 bool>::type = true>
1148 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1149 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1150 { }
1151
1152 template<typename _Alloc, typename _U1, typename _U2, typename
1153 enable_if<_TMC::template
1154 _MoveConstructibleTuple<_U1, _U2>()
1155 && !_TMC::template
1156 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1157 bool>::type = false>
1158 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1159 tuple<_U1, _U2>&& __in)
1160 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1161 { }
1162
1163 template<typename _Alloc, typename _U1, typename _U2, typename
1164 enable_if<_TMC::template
1165 _ConstructibleTuple<_U1, _U2>()
1166 && _TMC::template
1167 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1168 bool>::type = true>
1169 tuple(allocator_arg_t __tag, const _Alloc& __a,
1170 const pair<_U1, _U2>& __in)
1171 : _Inherited(__tag, __a, __in.first, __in.second) { }
1172
1173 template<typename _Alloc, typename _U1, typename _U2, typename
1174 enable_if<_TMC::template
1175 _ConstructibleTuple<_U1, _U2>()
1176 && !_TMC::template
1177 _ImplicitlyConvertibleTuple<_U1, _U2>(),
1178 bool>::type = false>
1179 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1180 const pair<_U1, _U2>& __in)
1181 : _Inherited(__tag, __a, __in.first, __in.second) { }
1182
1183 template<typename _Alloc, typename _U1, typename _U2, typename
1184 enable_if<_TMC::template
1185 _MoveConstructibleTuple<_U1, _U2>()
1186 && _TMC::template
1187 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1188 bool>::type = true>
1189 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1190 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1191 std::forward<_U2>(__in.second)) { }
1192
1193 template<typename _Alloc, typename _U1, typename _U2, typename
1194 enable_if<_TMC::template
1195 _MoveConstructibleTuple<_U1, _U2>()
1196 && !_TMC::template
1197 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1198 bool>::type = false>
1199 explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1200 pair<_U1, _U2>&& __in)
1201 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1202 std::forward<_U2>(__in.second)) { }
1203
1204 tuple&
1205 operator=(typename conditional<__assignable<const _T1&, const _T2&>(),
1206 const tuple&,
1207 const __nonesuch_no_braces&>::type __in)
1208 noexcept(__nothrow_assignable<const _T1&, const _T2&>())
1209 {
1210 this->_M_assign(__in);
1211 return *this;
1212 }
1213
1214 tuple&
1215 operator=(typename conditional<__assignable<_T1, _T2>(),
1216 tuple&&,
1217 __nonesuch_no_braces&&>::type __in)
1218 noexcept(__nothrow_assignable<_T1, _T2>())
1219 {
1220 this->_M_assign(std::move(__in));
1221 return *this;
1222 }
1223
1224 template<typename _U1, typename _U2>
1225 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
1226 operator=(const tuple<_U1, _U2>& __in)
1227 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
1228 {
1229 this->_M_assign(__in);
1230 return *this;
1231 }
1232
1233 template<typename _U1, typename _U2>
1234 __enable_if_t<__assignable<_U1, _U2>(), tuple&>
1235 operator=(tuple<_U1, _U2>&& __in)
1236 noexcept(__nothrow_assignable<_U1, _U2>())
1237 {
1238 this->_M_assign(std::move(__in));
1239 return *this;
1240 }
1241
1242 template<typename _U1, typename _U2>
1243 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
1244 operator=(const pair<_U1, _U2>& __in)
1245 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
1246 {
1247 this->_M_head(*this) = __in.first;
1248 this->_M_tail(*this)._M_head(*this) = __in.second;
1249 return *this;
1250 }
1251
1252 template<typename _U1, typename _U2>
1253 __enable_if_t<__assignable<_U1, _U2>(), tuple&>
1254 operator=(pair<_U1, _U2>&& __in)
1255 noexcept(__nothrow_assignable<_U1, _U2>())
1256 {
1257 this->_M_head(*this) = std::forward<_U1>(__in.first);
1258 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1259 return *this;
1260 }
1261
1262 void
1263 swap(tuple& __in)
1264 noexcept(__and_<__is_nothrow_swappable<_T1>,
1265 __is_nothrow_swappable<_T2>>::value)
1266 { _Inherited::_M_swap(__in); }
1267 };
1268
1269
1270 /// class tuple_size
1271 template<typename... _Elements>
1272 struct tuple_size<tuple<_Elements...>>
1273 : public integral_constant<std::size_t, sizeof...(_Elements)> { };
1274
1275#if __cplusplus > 201402L
1276 template <typename _Tp>
1277 inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1278#endif
1279
1280 /**
1281 * Recursive case for tuple_element: strip off the first element in
1282 * the tuple and retrieve the (i-1)th element of the remaining tuple.
1283 */
1284 template<std::size_t __i, typename _Head, typename... _Tail>
1285 struct tuple_element<__i, tuple<_Head, _Tail...> >
1286 : tuple_element<__i - 1, tuple<_Tail...> > { };
1287
1288 /**
1289 * Basis case for tuple_element: The first element is the one we're seeking.
1290 */
1291 template<typename _Head, typename... _Tail>
1292 struct tuple_element<0, tuple<_Head, _Tail...> >
1293 {
1294 typedef _Head type;
1295 };
1296
1297 /**
1298 * Error case for tuple_element: invalid index.
1299 */
1300 template<size_t __i>
1301 struct tuple_element<__i, tuple<>>
1302 {
1303 static_assert(__i < tuple_size<tuple<>>::value,
1304 "tuple index is in range");
1305 };
1306
1307 template<std::size_t __i, typename _Head, typename... _Tail>
1308 constexpr _Head&
1309 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1310 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1311
1312 template<std::size_t __i, typename _Head, typename... _Tail>
1313 constexpr const _Head&
1314 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1315 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1316
1317 /// Return a reference to the ith element of a tuple.
1318 template<std::size_t __i, typename... _Elements>
1319 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1320 get(tuple<_Elements...>& __t) noexcept
1321 { return std::__get_helper<__i>(__t); }
1322
1323 /// Return a const reference to the ith element of a const tuple.
1324 template<std::size_t __i, typename... _Elements>
1325 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1326 get(const tuple<_Elements...>& __t) noexcept
1327 { return std::__get_helper<__i>(__t); }
1328
1329 /// Return an rvalue reference to the ith element of a tuple rvalue.
1330 template<std::size_t __i, typename... _Elements>
1331 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1332 get(tuple<_Elements...>&& __t) noexcept
1333 {
1334 typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1335 return std::forward<__element_type&&>(std::get<__i>(__t));
1336 }
1337
1338 /// Return a const rvalue reference to the ith element of a const tuple rvalue.
1339 template<std::size_t __i, typename... _Elements>
1340 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
1341 get(const tuple<_Elements...>&& __t) noexcept
1342 {
1343 typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1344 return std::forward<const __element_type&&>(std::get<__i>(__t));
1345 }
1346
1347#if __cplusplus >= 201402L
1348
1349#define __cpp_lib_tuples_by_type 201304
1350
1351 template<typename _Head, size_t __i, typename... _Tail>
1352 constexpr _Head&
1353 __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1354 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1355
1356 template<typename _Head, size_t __i, typename... _Tail>
1357 constexpr const _Head&
1358 __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1359 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1360
1361 /// Return a reference to the unique element of type _Tp of a tuple.
1362 template <typename _Tp, typename... _Types>
1363 constexpr _Tp&
1364 get(tuple<_Types...>& __t) noexcept
1365 { return std::__get_helper2<_Tp>(__t); }
1366
1367 /// Return a reference to the unique element of type _Tp of a tuple rvalue.
1368 template <typename _Tp, typename... _Types>
1369 constexpr _Tp&&
1370 get(tuple<_Types...>&& __t) noexcept
1371 { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
1372
1373 /// Return a const reference to the unique element of type _Tp of a tuple.
1374 template <typename _Tp, typename... _Types>
1375 constexpr const _Tp&
1376 get(const tuple<_Types...>& __t) noexcept
1377 { return std::__get_helper2<_Tp>(__t); }
1378
1379 /// Return a const reference to the unique element of type _Tp of
1380 /// a const tuple rvalue.
1381 template <typename _Tp, typename... _Types>
1382 constexpr const _Tp&&
1383 get(const tuple<_Types...>&& __t) noexcept
1384 { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }
1385#endif
1386
1387 // This class performs the comparison operations on tuples
1388 template<typename _Tp, typename _Up, size_t __i, size_t __size>
1389 struct __tuple_compare
1390 {
1391 static constexpr bool
1392 __eq(const _Tp& __t, const _Up& __u)
1393 {
1394 return bool(std::get<__i>(__t) == std::get<__i>(__u))
1395 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
1396 }
1397
1398 static constexpr bool
1399 __less(const _Tp& __t, const _Up& __u)
1400 {
1401 return bool(std::get<__i>(__t) < std::get<__i>(__u))
1402 || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
1403 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
1404 }
1405 };
1406
1407 template<typename _Tp, typename _Up, size_t __size>
1408 struct __tuple_compare<_Tp, _Up, __size, __size>
1409 {
1410 static constexpr bool
1411 __eq(const _Tp&, const _Up&) { return true; }
1412
1413 static constexpr bool
1414 __less(const _Tp&, const _Up&) { return false; }
1415 };
1416
1417 template<typename... _TElements, typename... _UElements>
1418 constexpr bool
1419 operator==(const tuple<_TElements...>& __t,
1420 const tuple<_UElements...>& __u)
1421 {
1422 static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1423 "tuple objects can only be compared if they have equal sizes.");
1424 using __compare = __tuple_compare<tuple<_TElements...>,
1425 tuple<_UElements...>,
1426 0, sizeof...(_TElements)>;
1427 return __compare::__eq(__t, __u);
1428 }
1429
1430 template<typename... _TElements, typename... _UElements>
1431 constexpr bool
1432 operator<(const tuple<_TElements...>& __t,
1433 const tuple<_UElements...>& __u)
1434 {
1435 static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1436 "tuple objects can only be compared if they have equal sizes.");
1437 using __compare = __tuple_compare<tuple<_TElements...>,
1438 tuple<_UElements...>,
1439 0, sizeof...(_TElements)>;
1440 return __compare::__less(__t, __u);
1441 }
1442
1443 template<typename... _TElements, typename... _UElements>
1444 constexpr bool
1445 operator!=(const tuple<_TElements...>& __t,
1446 const tuple<_UElements...>& __u)
1447 { return !(__t == __u); }
1448
1449 template<typename... _TElements, typename... _UElements>
1450 constexpr bool
1451 operator>(const tuple<_TElements...>& __t,
1452 const tuple<_UElements...>& __u)
1453 { return __u < __t; }
1454
1455 template<typename... _TElements, typename... _UElements>
1456 constexpr bool
1457 operator<=(const tuple<_TElements...>& __t,
1458 const tuple<_UElements...>& __u)
1459 { return !(__u < __t); }
1460
1461 template<typename... _TElements, typename... _UElements>
1462 constexpr bool
1463 operator>=(const tuple<_TElements...>& __t,
1464 const tuple<_UElements...>& __u)
1465 { return !(__t < __u); }
1466
1467 // NB: DR 705.
1468 template<typename... _Elements>
1469 constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1470 make_tuple(_Elements&&... __args)
1471 {
1472 typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1473 __result_type;
1474 return __result_type(std::forward<_Elements>(__args)...);
1475 }
1476
1477 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1478 // 2275. Why is forward_as_tuple not constexpr?
1479 /// std::forward_as_tuple
1480 template<typename... _Elements>
1481 constexpr tuple<_Elements&&...>
1482 forward_as_tuple(_Elements&&... __args) noexcept
1483 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1484
1485 template<size_t, typename, typename, size_t>
1486 struct __make_tuple_impl;
1487
1488 template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1489 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1490 : __make_tuple_impl<_Idx + 1,
1491 tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1492 _Tuple, _Nm>
1493 { };
1494
1495 template<std::size_t _Nm, typename _Tuple, typename... _Tp>
1496 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1497 {
1498 typedef tuple<_Tp...> __type;
1499 };
1500
1501 template<typename _Tuple>
1502 struct __do_make_tuple
1503 : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1504 { };
1505
1506 // Returns the std::tuple equivalent of a tuple-like type.
1507 template<typename _Tuple>
1508 struct __make_tuple
1509 : public __do_make_tuple<__remove_cvref_t<_Tuple>>
1510 { };
1511
1512 // Combines several std::tuple's into a single one.
1513 template<typename...>
1514 struct __combine_tuples;
1515
1516 template<>
1517 struct __combine_tuples<>
1518 {
1519 typedef tuple<> __type;
1520 };
1521
1522 template<typename... _Ts>
1523 struct __combine_tuples<tuple<_Ts...>>
1524 {
1525 typedef tuple<_Ts...> __type;
1526 };
1527
1528 template<typename... _T1s, typename... _T2s, typename... _Rem>
1529 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1530 {
1531 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1532 _Rem...>::__type __type;
1533 };
1534
1535 // Computes the result type of tuple_cat given a set of tuple-like types.
1536 template<typename... _Tpls>
1537 struct __tuple_cat_result
1538 {
1539 typedef typename __combine_tuples
1540 <typename __make_tuple<_Tpls>::__type...>::__type __type;
1541 };
1542
1543 // Helper to determine the index set for the first tuple-like
1544 // type of a given set.
1545 template<typename...>
1546 struct __make_1st_indices;
1547
1548 template<>
1549 struct __make_1st_indices<>
1550 {
1551 typedef std::_Index_tuple<> __type;
1552 };
1553
1554 template<typename _Tp, typename... _Tpls>
1555 struct __make_1st_indices<_Tp, _Tpls...>
1556 {
1557 typedef typename std::_Build_index_tuple<std::tuple_size<
1558 typename std::remove_reference<_Tp>::type>::value>::__type __type;
1559 };
1560
1561 // Performs the actual concatenation by step-wise expanding tuple-like
1562 // objects into the elements, which are finally forwarded into the
1563 // result tuple.
1564 template<typename _Ret, typename _Indices, typename... _Tpls>
1565 struct __tuple_concater;
1566
1567 template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
1568 struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1569 {
1570 template<typename... _Us>
1571 static constexpr _Ret
1572 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1573 {
1574 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1575 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
1576 return __next::_S_do(std::forward<_Tpls>(__tps)...,
1577 std::forward<_Us>(__us)...,
1578 std::get<_Is>(std::forward<_Tp>(__tp))...);
1579 }
1580 };
1581
1582 template<typename _Ret>
1583 struct __tuple_concater<_Ret, std::_Index_tuple<>>
1584 {
1585 template<typename... _Us>
1586 static constexpr _Ret
1587 _S_do(_Us&&... __us)
1588 {
1589 return _Ret(std::forward<_Us>(__us)...);
1590 }
1591 };
1592
1593 /// tuple_cat
1594 template<typename... _Tpls, typename = typename
1595 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1596 constexpr auto
1597 tuple_cat(_Tpls&&... __tpls)
1598 -> typename __tuple_cat_result<_Tpls...>::__type
1599 {
1600 typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1601 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1602 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1603 return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1604 }
1605
1606 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1607 // 2301. Why is tie not constexpr?
1608 /// tie
1609 template<typename... _Elements>
1610 constexpr tuple<_Elements&...>
1611 tie(_Elements&... __args) noexcept
1612 { return tuple<_Elements&...>(__args...); }
1613
1614 /// swap
1615 template<typename... _Elements>
1616 inline
1617#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1618 // Constrained free swap overload, see p0185r1
1619 typename enable_if<__and_<__is_swappable<_Elements>...>::value
1620 >::type
1621#else
1622 void
1623#endif
1624 swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1625 noexcept(noexcept(__x.swap(__y)))
1626 { __x.swap(__y); }
1627
1628#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1629 template<typename... _Elements>
1630 typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
1631 swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
1632#endif
1633
1634 // A class (and instance) which can be used in 'tie' when an element
1635 // of a tuple is not required.
1636 // _GLIBCXX14_CONSTEXPR
1637 // 2933. PR for LWG 2773 could be clearer
1638 struct _Swallow_assign
1639 {
1640 template<class _Tp>
1641 _GLIBCXX14_CONSTEXPR const _Swallow_assign&
1642 operator=(const _Tp&) const
1643 { return *this; }
1644 };
1645
1646 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1647 // 2773. Making std::ignore constexpr
1648 _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
1649
1650 /// Partial specialization for tuples
1651 template<typename... _Types, typename _Alloc>
1652 struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1653
1654 // See stl_pair.h...
1655 template<class _T1, class _T2>
1656 template<typename... _Args1, typename... _Args2>
1657 inline
1658 pair<_T1, _T2>::
1659 pair(piecewise_construct_t,
1660 tuple<_Args1...> __first, tuple<_Args2...> __second)
1661 : pair(__first, __second,
1662 typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1663 typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1664 { }
1665
1666 template<class _T1, class _T2>
1667 template<typename... _Args1, std::size_t... _Indexes1,
1668 typename... _Args2, std::size_t... _Indexes2>
1669 inline
1670 pair<_T1, _T2>::
1671 pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1672 _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1673 : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1674 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1675 { }
1676
1677#if __cplusplus >= 201703L
1678# define __cpp_lib_apply 201603
1679
1680 template <typename _Fn, typename _Tuple, size_t... _Idx>
1681 constexpr decltype(auto)
1682 __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
1683 {
1684 return std::__invoke(std::forward<_Fn>(__f),
1685 std::get<_Idx>(std::forward<_Tuple>(__t))...);
1686 }
1687
1688 template <typename _Fn, typename _Tuple>
1689 constexpr decltype(auto)
1690 apply(_Fn&& __f, _Tuple&& __t)
1691 {
1692 using _Indices
1693 = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
1694 return std::__apply_impl(std::forward<_Fn>(__f),
1695 std::forward<_Tuple>(__t),
1696 _Indices{});
1697 }
1698
1699#define __cpp_lib_make_from_tuple 201606
1700
1701 template <typename _Tp, typename _Tuple, size_t... _Idx>
1702 constexpr _Tp
1703 __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
1704 { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
1705
1706 template <typename _Tp, typename _Tuple>
1707 constexpr _Tp
1708 make_from_tuple(_Tuple&& __t)
1709 {
1710 return __make_from_tuple_impl<_Tp>(
1711 std::forward<_Tuple>(__t),
1712 make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
1713 }
1714#endif // C++17
1715
1716 /// @}
1717
1718_GLIBCXX_END_NAMESPACE_VERSION
1719} // namespace std
1720
1721#endif // C++11
1722
1723#endif // _GLIBCXX_TUPLE
1724