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