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