libstdc++
tuple
Go to the documentation of this file.
1 // <tuple> -*- C++ -*-
2 
3 // Copyright (C) 2007-2015 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)
226  : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
227  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
228 
229  template<typename _UHead, typename... _UTails>
230  constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
231  : _Inherited(std::move
232  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
233  _Base(std::forward<_UHead>
234  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
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,
271  const _Tuple_impl<_Idx, _UElements...>& __in)
272  : _Inherited(__tag, __a,
273  _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
274  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
275  _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
276 
277  template<typename _Alloc, typename _UHead, typename... _UTails>
278  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
279  _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
280  : _Inherited(__tag, __a, std::move
281  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
282  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
283  std::forward<_UHead>
284  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
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>
318  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
319  _M_tail(*this) = std::move
320  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
321  return *this;
322  }
323 
324  protected:
325  void
326  _M_swap(_Tuple_impl& __in)
327  noexcept(noexcept(swap(std::declval<_Head&>(),
328  std::declval<_Head&>()))
329  && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
330  {
331  using std::swap;
332  swap(_M_head(*this), _M_head(__in));
333  _Inherited::_M_swap(_M_tail(__in));
334  }
335  };
336 
337  // Basis case of inheritance recursion.
338  template<std::size_t _Idx, typename _Head>
339  struct _Tuple_impl<_Idx, _Head>
340  : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
341  {
342  template<std::size_t, typename...> friend class _Tuple_impl;
343 
344  typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
345 
346  static constexpr _Head&
347  _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
348 
349  static constexpr const _Head&
350  _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
351 
352  constexpr _Tuple_impl()
353  : _Base() { }
354 
355  explicit
356  constexpr _Tuple_impl(const _Head& __head)
357  : _Base(__head) { }
358 
359  template<typename _UHead>
360  explicit
361  constexpr _Tuple_impl(_UHead&& __head)
362  : _Base(std::forward<_UHead>(__head)) { }
363 
364  constexpr _Tuple_impl(const _Tuple_impl&) = default;
365 
366  constexpr
367  _Tuple_impl(_Tuple_impl&& __in)
368  noexcept(is_nothrow_move_constructible<_Head>::value)
369  : _Base(std::forward<_Head>(_M_head(__in))) { }
370 
371  template<typename _UHead>
372  constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
373  : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
374 
375  template<typename _UHead>
376  constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
377  : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
378  { }
379 
380  template<typename _Alloc>
381  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
382  : _Base(__tag, __use_alloc<_Head>(__a)) { }
383 
384  template<typename _Alloc>
385  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
386  const _Head& __head)
387  : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
388 
389  template<typename _Alloc, typename _UHead>
390  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
391  _UHead&& __head)
392  : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
393  std::forward<_UHead>(__head)) { }
394 
395  template<typename _Alloc>
396  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
397  const _Tuple_impl& __in)
398  : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
399 
400  template<typename _Alloc>
401  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
402  _Tuple_impl&& __in)
403  : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
404  std::forward<_Head>(_M_head(__in))) { }
405 
406  template<typename _Alloc, typename _UHead>
407  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
408  const _Tuple_impl<_Idx, _UHead>& __in)
409  : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
410  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
411 
412  template<typename _Alloc, typename _UHead>
413  _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
414  _Tuple_impl<_Idx, _UHead>&& __in)
415  : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
416  std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
417  { }
418 
419  _Tuple_impl&
420  operator=(const _Tuple_impl& __in)
421  {
422  _M_head(*this) = _M_head(__in);
423  return *this;
424  }
425 
426  _Tuple_impl&
427  operator=(_Tuple_impl&& __in)
428  noexcept(is_nothrow_move_assignable<_Head>::value)
429  {
430  _M_head(*this) = std::forward<_Head>(_M_head(__in));
431  return *this;
432  }
433 
434  template<typename _UHead>
435  _Tuple_impl&
436  operator=(const _Tuple_impl<_Idx, _UHead>& __in)
437  {
438  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
439  return *this;
440  }
441 
442  template<typename _UHead>
443  _Tuple_impl&
444  operator=(_Tuple_impl<_Idx, _UHead>&& __in)
445  {
446  _M_head(*this)
447  = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
448  return *this;
449  }
450 
451  protected:
452  void
453  _M_swap(_Tuple_impl& __in)
454  noexcept(noexcept(swap(std::declval<_Head&>(), std::declval<_Head&>())))
455  {
456  using std::swap;
457  swap(_M_head(*this), _M_head(__in));
458  }
459  };
460 
461  /// Primary class template, tuple
462  template<typename... _Elements>
463  class tuple : public _Tuple_impl<0, _Elements...>
464  {
465  typedef _Tuple_impl<0, _Elements...> _Inherited;
466 
467  public:
468  constexpr tuple()
469  : _Inherited() { }
470 
471  explicit
472  constexpr tuple(const _Elements&... __elements)
473  : _Inherited(__elements...) { }
474 
475  template<typename... _UElements, typename = typename
476  enable_if<__and_<is_convertible<_UElements,
477  _Elements>...>::value>::type>
478  explicit
479  constexpr tuple(_UElements&&... __elements)
480  : _Inherited(std::forward<_UElements>(__elements)...) { }
481 
482  constexpr tuple(const tuple&) = default;
483 
484  constexpr tuple(tuple&&) = default;
485 
486  template<typename... _UElements, typename = typename
487  enable_if<__and_<is_convertible<const _UElements&,
488  _Elements>...>::value>::type>
489  constexpr tuple(const tuple<_UElements...>& __in)
490  : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
491  { }
492 
493  template<typename... _UElements, typename = typename
494  enable_if<__and_<is_convertible<_UElements,
495  _Elements>...>::value>::type>
496  constexpr tuple(tuple<_UElements...>&& __in)
497  : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
498 
499  // Allocator-extended constructors.
500 
501  template<typename _Alloc>
502  tuple(allocator_arg_t __tag, const _Alloc& __a)
503  : _Inherited(__tag, __a) { }
504 
505  template<typename _Alloc>
506  tuple(allocator_arg_t __tag, const _Alloc& __a,
507  const _Elements&... __elements)
508  : _Inherited(__tag, __a, __elements...) { }
509 
510  template<typename _Alloc, typename... _UElements, typename = typename
511  enable_if<sizeof...(_UElements)
512  == sizeof...(_Elements)>::type>
513  tuple(allocator_arg_t __tag, const _Alloc& __a,
514  _UElements&&... __elements)
515  : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
516  { }
517 
518  template<typename _Alloc>
519  tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
520  : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
521 
522  template<typename _Alloc>
523  tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
524  : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
525 
526  template<typename _Alloc, typename... _UElements, typename = typename
527  enable_if<sizeof...(_UElements)
528  == sizeof...(_Elements)>::type>
529  tuple(allocator_arg_t __tag, const _Alloc& __a,
530  const tuple<_UElements...>& __in)
531  : _Inherited(__tag, __a,
532  static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
533  { }
534 
535  template<typename _Alloc, typename... _UElements, typename = typename
536  enable_if<sizeof...(_UElements)
537  == sizeof...(_Elements)>::type>
538  tuple(allocator_arg_t __tag, const _Alloc& __a,
539  tuple<_UElements...>&& __in)
540  : _Inherited(__tag, __a,
541  static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
542  { }
543 
544  tuple&
545  operator=(const tuple& __in)
546  {
547  static_cast<_Inherited&>(*this) = __in;
548  return *this;
549  }
550 
551  tuple&
552  operator=(tuple&& __in)
553  noexcept(is_nothrow_move_assignable<_Inherited>::value)
554  {
555  static_cast<_Inherited&>(*this) = std::move(__in);
556  return *this;
557  }
558 
559  template<typename... _UElements, typename = typename
560  enable_if<sizeof...(_UElements)
561  == sizeof...(_Elements)>::type>
562  tuple&
563  operator=(const tuple<_UElements...>& __in)
564  {
565  static_cast<_Inherited&>(*this) = __in;
566  return *this;
567  }
568 
569  template<typename... _UElements, typename = typename
570  enable_if<sizeof...(_UElements)
571  == sizeof...(_Elements)>::type>
572  tuple&
573  operator=(tuple<_UElements...>&& __in)
574  {
575  static_cast<_Inherited&>(*this) = std::move(__in);
576  return *this;
577  }
578 
579  void
580  swap(tuple& __in)
581  noexcept(noexcept(__in._M_swap(__in)))
582  { _Inherited::_M_swap(__in); }
583  };
584 
585  // Explicit specialization, zero-element tuple.
586  template<>
587  class tuple<>
588  {
589  public:
590  void swap(tuple&) noexcept { /* no-op */ }
591  };
592 
593  /// Partial specialization, 2-element tuple.
594  /// Includes construction and assignment from a pair.
595  template<typename _T1, typename _T2>
596  class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
597  {
598  typedef _Tuple_impl<0, _T1, _T2> _Inherited;
599 
600  public:
601  constexpr tuple()
602  : _Inherited() { }
603 
604  explicit
605  constexpr tuple(const _T1& __a1, const _T2& __a2)
606  : _Inherited(__a1, __a2) { }
607 
608  template<typename _U1, typename _U2, typename = typename
609  enable_if<__and_<is_convertible<_U1, _T1>,
610  is_convertible<_U2, _T2>>::value>::type>
611  explicit
612  constexpr tuple(_U1&& __a1, _U2&& __a2)
613  : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
614 
615  constexpr tuple(const tuple&) = default;
616 
617  constexpr tuple(tuple&&) = default;
618 
619  template<typename _U1, typename _U2, typename = typename
620  enable_if<__and_<is_convertible<const _U1&, _T1>,
621  is_convertible<const _U2&, _T2>>::value>::type>
622  constexpr tuple(const tuple<_U1, _U2>& __in)
623  : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
624 
625  template<typename _U1, typename _U2, typename = typename
626  enable_if<__and_<is_convertible<_U1, _T1>,
627  is_convertible<_U2, _T2>>::value>::type>
628  constexpr tuple(tuple<_U1, _U2>&& __in)
629  : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
630 
631  template<typename _U1, typename _U2, typename = typename
632  enable_if<__and_<is_convertible<const _U1&, _T1>,
633  is_convertible<const _U2&, _T2>>::value>::type>
634  constexpr tuple(const pair<_U1, _U2>& __in)
635  : _Inherited(__in.first, __in.second) { }
636 
637  template<typename _U1, typename _U2, typename = typename
638  enable_if<__and_<is_convertible<_U1, _T1>,
639  is_convertible<_U2, _T2>>::value>::type>
640  constexpr tuple(pair<_U1, _U2>&& __in)
641  : _Inherited(std::forward<_U1>(__in.first),
642  std::forward<_U2>(__in.second)) { }
643 
644  // Allocator-extended constructors.
645 
646  template<typename _Alloc>
647  tuple(allocator_arg_t __tag, const _Alloc& __a)
648  : _Inherited(__tag, __a) { }
649 
650  template<typename _Alloc>
651  tuple(allocator_arg_t __tag, const _Alloc& __a,
652  const _T1& __a1, const _T2& __a2)
653  : _Inherited(__tag, __a, __a1, __a2) { }
654 
655  template<typename _Alloc, typename _U1, typename _U2>
656  tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
657  : _Inherited(__tag, __a, std::forward<_U1>(__a1),
658  std::forward<_U2>(__a2)) { }
659 
660  template<typename _Alloc>
661  tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
662  : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
663 
664  template<typename _Alloc>
665  tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
666  : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
667 
668  template<typename _Alloc, typename _U1, typename _U2>
669  tuple(allocator_arg_t __tag, const _Alloc& __a,
670  const tuple<_U1, _U2>& __in)
671  : _Inherited(__tag, __a,
672  static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
673  { }
674 
675  template<typename _Alloc, typename _U1, typename _U2>
676  tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
677  : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
678  { }
679 
680  template<typename _Alloc, typename _U1, typename _U2>
681  tuple(allocator_arg_t __tag, const _Alloc& __a,
682  const pair<_U1, _U2>& __in)
683  : _Inherited(__tag, __a, __in.first, __in.second) { }
684 
685  template<typename _Alloc, typename _U1, typename _U2>
686  tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
687  : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
688  std::forward<_U2>(__in.second)) { }
689 
690  tuple&
691  operator=(const tuple& __in)
692  {
693  static_cast<_Inherited&>(*this) = __in;
694  return *this;
695  }
696 
697  tuple&
698  operator=(tuple&& __in)
699  noexcept(is_nothrow_move_assignable<_Inherited>::value)
700  {
701  static_cast<_Inherited&>(*this) = std::move(__in);
702  return *this;
703  }
704 
705  template<typename _U1, typename _U2>
706  tuple&
707  operator=(const tuple<_U1, _U2>& __in)
708  {
709  static_cast<_Inherited&>(*this) = __in;
710  return *this;
711  }
712 
713  template<typename _U1, typename _U2>
714  tuple&
715  operator=(tuple<_U1, _U2>&& __in)
716  {
717  static_cast<_Inherited&>(*this) = std::move(__in);
718  return *this;
719  }
720 
721  template<typename _U1, typename _U2>
722  tuple&
723  operator=(const pair<_U1, _U2>& __in)
724  {
725  this->_M_head(*this) = __in.first;
726  this->_M_tail(*this)._M_head(*this) = __in.second;
727  return *this;
728  }
729 
730  template<typename _U1, typename _U2>
731  tuple&
732  operator=(pair<_U1, _U2>&& __in)
733  {
734  this->_M_head(*this) = std::forward<_U1>(__in.first);
735  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
736  return *this;
737  }
738 
739  void
740  swap(tuple& __in)
741  noexcept(noexcept(__in._M_swap(__in)))
742  { _Inherited::_M_swap(__in); }
743  };
744 
745 
746  /// Gives the type of the ith element of a given tuple type.
747  template<std::size_t __i, typename _Tp>
748  struct tuple_element;
749 
750  /**
751  * Recursive case for tuple_element: strip off the first element in
752  * the tuple and retrieve the (i-1)th element of the remaining tuple.
753  */
754  template<std::size_t __i, typename _Head, typename... _Tail>
755  struct tuple_element<__i, tuple<_Head, _Tail...> >
756  : tuple_element<__i - 1, tuple<_Tail...> > { };
757 
758  /**
759  * Basis case for tuple_element: The first element is the one we're seeking.
760  */
761  template<typename _Head, typename... _Tail>
762  struct tuple_element<0, tuple<_Head, _Tail...> >
763  {
764  typedef _Head type;
765  };
766 
767  // Duplicate of C++14's tuple_element_t for internal use in C++11 mode
768  template<std::size_t __i, typename _Tp>
769  using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
770 
771  template<std::size_t __i, typename _Tp>
772  struct tuple_element<__i, const _Tp>
773  {
774  typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
775  };
776 
777  template<std::size_t __i, typename _Tp>
778  struct tuple_element<__i, volatile _Tp>
779  {
780  typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
781  };
782 
783  template<std::size_t __i, typename _Tp>
784  struct tuple_element<__i, const volatile _Tp>
785  {
786  typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
787  };
788 
789 #if __cplusplus > 201103L
790 #define __cpp_lib_tuple_element_t 201402
791 
792  template<std::size_t __i, typename _Tp>
793  using tuple_element_t = typename tuple_element<__i, _Tp>::type;
794 #endif
795 
796  /// Finds the size of a given tuple type.
797  template<typename _Tp>
798  struct tuple_size;
799 
800  // _GLIBCXX_RESOLVE_LIB_DEFECTS
801  // 2313. tuple_size should always derive from integral_constant<size_t, N>
802  template<typename _Tp>
803  struct tuple_size<const _Tp>
804  : integral_constant<size_t, tuple_size<_Tp>::value> { };
805 
806  template<typename _Tp>
807  struct tuple_size<volatile _Tp>
808  : integral_constant<size_t, tuple_size<_Tp>::value> { };
809 
810  template<typename _Tp>
811  struct tuple_size<const volatile _Tp>
812  : integral_constant<size_t, tuple_size<_Tp>::value> { };
813 
814  /// class tuple_size
815  template<typename... _Elements>
816  struct tuple_size<tuple<_Elements...>>
817  : public integral_constant<std::size_t, sizeof...(_Elements)> { };
818 
819  template<std::size_t __i, typename _Head, typename... _Tail>
820  constexpr _Head&
821  __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
822  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
823 
824  template<std::size_t __i, typename _Head, typename... _Tail>
825  constexpr const _Head&
826  __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
827  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
828 
829  /// Return a reference to the ith element of a tuple.
830  template<std::size_t __i, typename... _Elements>
831  constexpr __tuple_element_t<__i, tuple<_Elements...>>&
832  get(tuple<_Elements...>& __t) noexcept
833  { return std::__get_helper<__i>(__t); }
834 
835  /// Return a const reference to the ith element of a const tuple.
836  template<std::size_t __i, typename... _Elements>
837  constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
838  get(const tuple<_Elements...>& __t) noexcept
839  { return std::__get_helper<__i>(__t); }
840 
841  /// Return an rvalue reference to the ith element of a tuple rvalue.
842  template<std::size_t __i, typename... _Elements>
843  constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
844  get(tuple<_Elements...>&& __t) noexcept
845  {
846  typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
847  return std::forward<__element_type&&>(std::get<__i>(__t));
848  }
849 
850 #if __cplusplus > 201103L
851 
852 #define __cpp_lib_tuples_by_type 201304
853 
854  template<typename _Head, size_t __i, typename... _Tail>
855  constexpr _Head&
856  __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
857  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
858 
859  template<typename _Head, size_t __i, typename... _Tail>
860  constexpr const _Head&
861  __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
862  { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
863 
864  /// Return a reference to the unique element of type _Tp of a tuple.
865  template <typename _Tp, typename... _Types>
866  constexpr _Tp&
867  get(tuple<_Types...>& __t) noexcept
868  { return std::__get_helper2<_Tp>(__t); }
869 
870  /// Return a reference to the unique element of type _Tp of a tuple rvalue.
871  template <typename _Tp, typename... _Types>
872  constexpr _Tp&&
873  get(tuple<_Types...>&& __t) noexcept
874  { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
875 
876  /// Return a const reference to the unique element of type _Tp of a tuple.
877  template <typename _Tp, typename... _Types>
878  constexpr const _Tp&
879  get(const tuple<_Types...>& __t) noexcept
880  { return std::__get_helper2<_Tp>(__t); }
881 #endif
882 
883  // This class performs the comparison operations on tuples
884  template<typename _Tp, typename _Up, size_t __i, size_t __size>
885  struct __tuple_compare
886  {
887  static constexpr bool
888  __eq(const _Tp& __t, const _Up& __u)
889  {
890  return bool(std::get<__i>(__t) == std::get<__i>(__u))
891  && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
892  }
893 
894  static constexpr bool
895  __less(const _Tp& __t, const _Up& __u)
896  {
897  return bool(std::get<__i>(__t) < std::get<__i>(__u))
898  || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
899  && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
900  }
901  };
902 
903  template<typename _Tp, typename _Up, size_t __size>
904  struct __tuple_compare<_Tp, _Up, __size, __size>
905  {
906  static constexpr bool
907  __eq(const _Tp&, const _Up&) { return true; }
908 
909  static constexpr bool
910  __less(const _Tp&, const _Up&) { return false; }
911  };
912 
913  template<typename... _TElements, typename... _UElements>
914  constexpr bool
915  operator==(const tuple<_TElements...>& __t,
916  const tuple<_UElements...>& __u)
917  {
918  static_assert(sizeof...(_TElements) == sizeof...(_UElements),
919  "tuple objects can only be compared if they have equal sizes.");
920  using __compare = __tuple_compare<tuple<_TElements...>,
921  tuple<_UElements...>,
922  0, sizeof...(_TElements)>;
923  return __compare::__eq(__t, __u);
924  }
925 
926  template<typename... _TElements, typename... _UElements>
927  constexpr bool
928  operator<(const tuple<_TElements...>& __t,
929  const tuple<_UElements...>& __u)
930  {
931  static_assert(sizeof...(_TElements) == sizeof...(_UElements),
932  "tuple objects can only be compared if they have equal sizes.");
933  using __compare = __tuple_compare<tuple<_TElements...>,
934  tuple<_UElements...>,
935  0, sizeof...(_TElements)>;
936  return __compare::__less(__t, __u);
937  }
938 
939  template<typename... _TElements, typename... _UElements>
940  constexpr bool
941  operator!=(const tuple<_TElements...>& __t,
942  const tuple<_UElements...>& __u)
943  { return !(__t == __u); }
944 
945  template<typename... _TElements, typename... _UElements>
946  constexpr bool
947  operator>(const tuple<_TElements...>& __t,
948  const tuple<_UElements...>& __u)
949  { return __u < __t; }
950 
951  template<typename... _TElements, typename... _UElements>
952  constexpr bool
953  operator<=(const tuple<_TElements...>& __t,
954  const tuple<_UElements...>& __u)
955  { return !(__u < __t); }
956 
957  template<typename... _TElements, typename... _UElements>
958  constexpr bool
959  operator>=(const tuple<_TElements...>& __t,
960  const tuple<_UElements...>& __u)
961  { return !(__t < __u); }
962 
963  // NB: DR 705.
964  template<typename... _Elements>
965  constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
966  make_tuple(_Elements&&... __args)
967  {
968  typedef tuple<typename __decay_and_strip<_Elements>::__type...>
969  __result_type;
970  return __result_type(std::forward<_Elements>(__args)...);
971  }
972 
973  template<typename... _Elements>
974  tuple<_Elements&&...>
975  forward_as_tuple(_Elements&&... __args) noexcept
976  { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
977 
978  template<typename>
979  struct __is_tuple_like_impl : false_type
980  { };
981 
982  template<typename... _Tps>
983  struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
984  { };
985 
986  template<typename _T1, typename _T2>
987  struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
988  { };
989 
990  template<typename _Tp, std::size_t _Nm>
991  struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
992  { };
993 
994  // Internal type trait that allows us to sfinae-protect tuple_cat.
995  template<typename _Tp>
996  struct __is_tuple_like
997  : public __is_tuple_like_impl<typename std::remove_cv
998  <typename std::remove_reference<_Tp>::type>::type>::type
999  { };
1000 
1001  template<size_t, typename, typename, size_t>
1002  struct __make_tuple_impl;
1003 
1004  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1005  struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1006  : __make_tuple_impl<_Idx + 1,
1007  tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1008  _Tuple, _Nm>
1009  { };
1010 
1011  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
1012  struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1013  {
1014  typedef tuple<_Tp...> __type;
1015  };
1016 
1017  template<typename _Tuple>
1018  struct __do_make_tuple
1019  : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1020  { };
1021 
1022  // Returns the std::tuple equivalent of a tuple-like type.
1023  template<typename _Tuple>
1024  struct __make_tuple
1025  : public __do_make_tuple<typename std::remove_cv
1026  <typename std::remove_reference<_Tuple>::type>::type>
1027  { };
1028 
1029  // Combines several std::tuple's into a single one.
1030  template<typename...>
1031  struct __combine_tuples;
1032 
1033  template<>
1034  struct __combine_tuples<>
1035  {
1036  typedef tuple<> __type;
1037  };
1038 
1039  template<typename... _Ts>
1040  struct __combine_tuples<tuple<_Ts...>>
1041  {
1042  typedef tuple<_Ts...> __type;
1043  };
1044 
1045  template<typename... _T1s, typename... _T2s, typename... _Rem>
1046  struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1047  {
1048  typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1049  _Rem...>::__type __type;
1050  };
1051 
1052  // Computes the result type of tuple_cat given a set of tuple-like types.
1053  template<typename... _Tpls>
1054  struct __tuple_cat_result
1055  {
1056  typedef typename __combine_tuples
1057  <typename __make_tuple<_Tpls>::__type...>::__type __type;
1058  };
1059 
1060  // Helper to determine the index set for the first tuple-like
1061  // type of a given set.
1062  template<typename...>
1063  struct __make_1st_indices;
1064 
1065  template<>
1066  struct __make_1st_indices<>
1067  {
1068  typedef std::_Index_tuple<> __type;
1069  };
1070 
1071  template<typename _Tp, typename... _Tpls>
1072  struct __make_1st_indices<_Tp, _Tpls...>
1073  {
1074  typedef typename std::_Build_index_tuple<std::tuple_size<
1075  typename std::remove_reference<_Tp>::type>::value>::__type __type;
1076  };
1077 
1078  // Performs the actual concatenation by step-wise expanding tuple-like
1079  // objects into the elements, which are finally forwarded into the
1080  // result tuple.
1081  template<typename _Ret, typename _Indices, typename... _Tpls>
1082  struct __tuple_concater;
1083 
1084  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
1085  struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1086  {
1087  template<typename... _Us>
1088  static constexpr _Ret
1089  _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1090  {
1091  typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1092  typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
1093  return __next::_S_do(std::forward<_Tpls>(__tps)...,
1094  std::forward<_Us>(__us)...,
1095  std::get<_Is>(std::forward<_Tp>(__tp))...);
1096  }
1097  };
1098 
1099  template<typename _Ret>
1100  struct __tuple_concater<_Ret, std::_Index_tuple<>>
1101  {
1102  template<typename... _Us>
1103  static constexpr _Ret
1104  _S_do(_Us&&... __us)
1105  {
1106  return _Ret(std::forward<_Us>(__us)...);
1107  }
1108  };
1109 
1110  /// tuple_cat
1111  template<typename... _Tpls, typename = typename
1112  enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1113  constexpr auto
1114  tuple_cat(_Tpls&&... __tpls)
1115  -> typename __tuple_cat_result<_Tpls...>::__type
1116  {
1117  typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1118  typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1119  typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1120  return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1121  }
1122 
1123  /// tie
1124  template<typename... _Elements>
1125  inline tuple<_Elements&...>
1126  tie(_Elements&... __args) noexcept
1127  { return tuple<_Elements&...>(__args...); }
1128 
1129  /// swap
1130  template<typename... _Elements>
1131  inline void
1132  swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1133  noexcept(noexcept(__x.swap(__y)))
1134  { __x.swap(__y); }
1135 
1136  // A class (and instance) which can be used in 'tie' when an element
1137  // of a tuple is not required
1138  struct _Swallow_assign
1139  {
1140  template<class _Tp>
1141  const _Swallow_assign&
1142  operator=(const _Tp&) const
1143  { return *this; }
1144  };
1145 
1146  const _Swallow_assign ignore{};
1147 
1148  /// Partial specialization for tuples
1149  template<typename... _Types, typename _Alloc>
1150  struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1151 
1152  // See stl_pair.h...
1153  template<class _T1, class _T2>
1154  template<typename... _Args1, typename... _Args2>
1155  inline
1156  pair<_T1, _T2>::
1157  pair(piecewise_construct_t,
1158  tuple<_Args1...> __first, tuple<_Args2...> __second)
1159  : pair(__first, __second,
1160  typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1161  typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1162  { }
1163 
1164  template<class _T1, class _T2>
1165  template<typename... _Args1, std::size_t... _Indexes1,
1166  typename... _Args2, std::size_t... _Indexes2>
1167  inline
1168  pair<_T1, _T2>::
1169  pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1170  _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1171  : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1172  second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1173  { }
1174 
1175  /// @}
1176 
1177 _GLIBCXX_END_NAMESPACE_VERSION
1178 } // namespace std
1179 
1180 #endif // C++11
1181 
1182 #endif // _GLIBCXX_TUPLE