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