2 //===--------------------------- tuple ------------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
24 explicit tuple(const T&...);
26 explicit tuple(U&&...);
27 tuple(const tuple&) = default;
28 tuple(tuple&&) = default;
30 tuple(const tuple<U...>&);
33 template <class U1, class U2>
34 tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2
35 template <class U1, class U2>
36 tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2
38 // allocator-extended constructors
39 template <class Alloc>
40 tuple(allocator_arg_t, const Alloc& a);
41 template <class Alloc>
42 tuple(allocator_arg_t, const Alloc& a, const T&...);
43 template <class Alloc, class... U>
44 tuple(allocator_arg_t, const Alloc& a, U&&...);
45 template <class Alloc>
46 tuple(allocator_arg_t, const Alloc& a, const tuple&);
47 template <class Alloc>
48 tuple(allocator_arg_t, const Alloc& a, tuple&&);
49 template <class Alloc, class... U>
50 tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
51 template <class Alloc, class... U>
52 tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
53 template <class Alloc, class U1, class U2>
54 tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
55 template <class Alloc, class U1, class U2>
56 tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
58 tuple& operator=(const tuple&);
60 operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
62 tuple& operator=(const tuple<U...>&);
64 tuple& operator=(tuple<U...>&&);
65 template <class U1, class U2>
66 tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
67 template <class U1, class U2>
68 tuple& operator=(pair<U1, U2>&&); //iffsizeof...(T) == 2
70 void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
73 const unspecified ignore;
75 template <class... T> tuple<V...> make_tuple(T&&...);
76 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
77 template <class... T> tuple<T&...> tie(T&...) noexcept;
78 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
80 // 20.4.1.4, tuple helper classes:
81 template <class T> class tuple_size; // undefined
82 template <class... T> class tuple_size<tuple<T...>>;
83 template <intsize_t I, class T> class tuple_element; // undefined
84 template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>;
86 // 20.4.1.5, element access:
87 template <intsize_t I, class... T>
88 typename tuple_element<I, tuple<T...>>::type&
89 get(tuple<T...>&) noexcept;
90 template <intsize_t I, class... T>
91 typename tuple_element<I, tuple<T...>>::type const&
92 get(const tuple<T...>&) noexcept;
93 template <intsize_t I, class... T>
94 typename tuple_element<I, tuple<T...>>::type&&
95 get(tuple<T...>&&) noexcept;
97 // 20.4.1.6, relational operators:
98 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
99 template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
100 template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
101 template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
102 template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
103 template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
105 template <class... Types, class Alloc>
106 struct uses_allocator<tuple<Types...>, Alloc>;
108 template <class... Types>
110 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
119 #include <type_traits>
120 #include <__functional_base>
123 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
124 #pragma GCC system_header
127 _LIBCPP_BEGIN_NAMESPACE_STD
131 struct _LIBCPP_VISIBLE allocator_arg_t { };
133 extern const allocator_arg_t allocator_arg;
138 struct __has_allocator_type
141 struct __two {char _; char __;};
142 template <class _Up> static __two __test(...);
143 template <class _Up> static char __test(typename _Up::allocator_type* = 0);
145 static const bool value = sizeof(__test<_Tp>(0)) == 1;
148 template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
149 struct __uses_allocator
150 : public integral_constant<bool,
151 is_convertible<_Alloc, typename _Tp::allocator_type>::value>
155 template <class _Tp, class _Alloc>
156 struct __uses_allocator<_Tp, _Alloc, false>
161 template <class _Tp, class _Alloc>
162 struct _LIBCPP_VISIBLE uses_allocator
163 : public __uses_allocator<_Tp, _Alloc>
167 #ifndef _LIBCPP_HAS_NO_VARIADICS
169 // uses-allocator construction
171 template <class _Tp, class _Alloc, class ..._Args>
172 struct __uses_alloc_ctor_imp
174 static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
175 static const bool __ic =
176 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
177 static const int value = __ua ? 2 - __ic : 0;
180 template <class _Tp, class _Alloc, class ..._Args>
181 struct __uses_alloc_ctor
182 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
185 #endif // _LIBCPP_HAS_NO_VARIADICS
187 #ifndef _LIBCPP_HAS_NO_VARIADICS
191 template <class ..._Tp>
192 class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
193 : public integral_constant<size_t, sizeof...(_Tp)>
199 template <size_t _Ip, class ..._Tp>
200 class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> >
203 typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
208 template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value
209 #if __has_feature(is_final)
215 template <size_t _Ip, class _Hp, bool _Ep>
216 inline _LIBCPP_INLINE_VISIBILITY
217 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
218 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
220 swap(__x.get(), __y.get());
223 template <size_t _Ip, class _Hp, bool>
228 __tuple_leaf& operator=(const __tuple_leaf&);
230 _LIBCPP_INLINE_VISIBILITY __tuple_leaf() : value()
231 {static_assert(!is_reference<_Hp>::value,
232 "Attempted to default construct a reference element in a tuple");}
234 template <class _Alloc>
235 _LIBCPP_INLINE_VISIBILITY
236 __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
238 {static_assert(!is_reference<_Hp>::value,
239 "Attempted to default construct a reference element in a tuple");}
241 template <class _Alloc>
242 _LIBCPP_INLINE_VISIBILITY
243 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
244 : value(allocator_arg_t(), __a)
245 {static_assert(!is_reference<_Hp>::value,
246 "Attempted to default construct a reference element in a tuple");}
248 template <class _Alloc>
249 _LIBCPP_INLINE_VISIBILITY
250 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
252 {static_assert(!is_reference<_Hp>::value,
253 "Attempted to default construct a reference element in a tuple");}
256 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
257 _LIBCPP_INLINE_VISIBILITY
258 explicit __tuple_leaf(_Tp&& __t)
259 : value(_VSTD::forward<_Tp>(__t))
260 {static_assert(!is_reference<_Hp>::value ||
261 (is_lvalue_reference<_Hp>::value &&
262 (is_lvalue_reference<_Tp>::value ||
263 is_same<typename remove_reference<_Tp>::type,
265 typename remove_reference<_Hp>::type
268 (is_rvalue_reference<_Hp>::value &&
269 !is_lvalue_reference<_Tp>::value),
270 "Attempted to construct a reference element in a tuple with an rvalue");}
272 template <class _Tp, class _Alloc>
273 _LIBCPP_INLINE_VISIBILITY
274 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
275 : value(_VSTD::forward<_Tp>(__t))
276 {static_assert(!is_lvalue_reference<_Hp>::value ||
277 (is_lvalue_reference<_Hp>::value &&
278 (is_lvalue_reference<_Tp>::value ||
279 is_same<typename remove_reference<_Tp>::type,
281 typename remove_reference<_Hp>::type
284 "Attempted to construct a reference element in a tuple with an rvalue");}
286 template <class _Tp, class _Alloc>
287 _LIBCPP_INLINE_VISIBILITY
288 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
289 : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
290 {static_assert(!is_lvalue_reference<_Hp>::value ||
291 (is_lvalue_reference<_Hp>::value &&
292 (is_lvalue_reference<_Tp>::value ||
293 is_same<typename remove_reference<_Tp>::type,
295 typename remove_reference<_Hp>::type
298 "Attempted to construct a reference element in a tuple with an rvalue");}
300 template <class _Tp, class _Alloc>
301 _LIBCPP_INLINE_VISIBILITY
302 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
303 : value(_VSTD::forward<_Tp>(__t), __a)
304 {static_assert(!is_lvalue_reference<_Hp>::value ||
305 (is_lvalue_reference<_Hp>::value &&
306 (is_lvalue_reference<_Tp>::value ||
307 is_same<typename remove_reference<_Tp>::type,
309 typename remove_reference<_Hp>::type
312 "Attempted to construct a reference element in a tuple with an rvalue");}
314 __tuple_leaf(const __tuple_leaf& __t)
316 {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
319 _LIBCPP_INLINE_VISIBILITY
320 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
321 : value(__t.get()) {}
324 _LIBCPP_INLINE_VISIBILITY
328 value = _VSTD::forward<_Tp>(__t);
332 _LIBCPP_INLINE_VISIBILITY
333 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
335 _VSTD::swap(*this, __t);
339 _LIBCPP_INLINE_VISIBILITY _Hp& get() {return value;}
340 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return value;}
343 template <size_t _Ip, class _Hp>
344 class __tuple_leaf<_Ip, _Hp, true>
348 __tuple_leaf& operator=(const __tuple_leaf&);
350 _LIBCPP_INLINE_VISIBILITY __tuple_leaf() {}
352 template <class _Alloc>
353 _LIBCPP_INLINE_VISIBILITY
354 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
356 template <class _Alloc>
357 _LIBCPP_INLINE_VISIBILITY
358 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
359 : _Hp(allocator_arg_t(), __a) {}
361 template <class _Alloc>
362 _LIBCPP_INLINE_VISIBILITY
363 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
367 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
368 _LIBCPP_INLINE_VISIBILITY
369 explicit __tuple_leaf(_Tp&& __t)
370 : _Hp(_VSTD::forward<_Tp>(__t)) {}
372 template <class _Tp, class _Alloc>
373 _LIBCPP_INLINE_VISIBILITY
374 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
375 : _Hp(_VSTD::forward<_Tp>(__t)) {}
377 template <class _Tp, class _Alloc>
378 _LIBCPP_INLINE_VISIBILITY
379 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
380 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
382 template <class _Tp, class _Alloc>
383 _LIBCPP_INLINE_VISIBILITY
384 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
385 : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
388 _LIBCPP_INLINE_VISIBILITY
389 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
393 _LIBCPP_INLINE_VISIBILITY
397 _Hp::operator=(_VSTD::forward<_Tp>(__t));
401 _LIBCPP_INLINE_VISIBILITY
403 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
405 _VSTD::swap(*this, __t);
409 _LIBCPP_INLINE_VISIBILITY _Hp& get() {return static_cast<_Hp&>(*this);}
410 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast<const _Hp&>(*this);}
413 template <class ..._Tp>
414 _LIBCPP_INLINE_VISIBILITY
415 void __swallow(_Tp&&...) {}
417 template <bool ...> struct __all;
422 static const bool value = true;
425 template <bool _B0, bool ... _Bp>
426 struct __all<_B0, _Bp...>
428 static const bool value = _B0 && __all<_Bp...>::value;
433 template<class _Indx, class ..._Tp> struct __tuple_impl;
435 template<size_t ..._Indx, class ..._Tp>
436 struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
437 : public __tuple_leaf<_Indx, _Tp>...
439 template <size_t ..._Uf, class ..._Tf,
440 size_t ..._Ul, class ..._Tl, class ..._Up>
441 _LIBCPP_INLINE_VISIBILITY
443 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
444 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
446 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
447 __tuple_leaf<_Ul, _Tl>()...
450 template <class _Alloc, size_t ..._Uf, class ..._Tf,
451 size_t ..._Ul, class ..._Tl, class ..._Up>
452 _LIBCPP_INLINE_VISIBILITY
454 __tuple_impl(allocator_arg_t, const _Alloc& __a,
455 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
456 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
458 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
459 _VSTD::forward<_Up>(__u))...,
460 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
463 template <class _Tuple,
464 class = typename enable_if
466 __tuple_convertible<_Tuple, tuple<_Tp...> >::value
469 _LIBCPP_INLINE_VISIBILITY
470 __tuple_impl(_Tuple&& __t)
471 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
472 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
475 template <class _Alloc, class _Tuple,
476 class = typename enable_if
478 __tuple_convertible<_Tuple, tuple<_Tp...> >::value
481 _LIBCPP_INLINE_VISIBILITY
482 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
483 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
484 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
485 _VSTD::forward<typename tuple_element<_Indx,
486 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
489 template <class _Tuple>
490 _LIBCPP_INLINE_VISIBILITY
493 __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
496 operator=(_Tuple&& __t)
498 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
499 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
503 _LIBCPP_INLINE_VISIBILITY
505 operator=(const __tuple_impl& __t)
507 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
511 _LIBCPP_INLINE_VISIBILITY
512 void swap(__tuple_impl& __t)
513 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
515 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
519 template <class ..._Tp>
520 class _LIBCPP_VISIBLE tuple
522 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
526 template <size_t _Jp, class ..._Up> friend
527 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
528 template <size_t _Jp, class ..._Up> friend
529 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
530 template <size_t _Jp, class ..._Up> friend
531 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
534 _LIBCPP_INLINE_VISIBILITY
535 explicit tuple(const _Tp& ... __t)
536 : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
537 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
538 typename __make_tuple_indices<0>::type(),
539 typename __make_tuple_types<tuple, 0>::type(),
543 template <class _Alloc>
544 _LIBCPP_INLINE_VISIBILITY
545 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
546 : base_(allocator_arg_t(), __a,
547 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
548 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
549 typename __make_tuple_indices<0>::type(),
550 typename __make_tuple_types<tuple, 0>::type(),
554 template <class ..._Up,
557 sizeof...(_Up) <= sizeof...(_Tp) &&
561 typename __make_tuple_types<tuple,
562 sizeof...(_Up) < sizeof...(_Tp) ?
564 sizeof...(_Tp)>::type
569 _LIBCPP_INLINE_VISIBILITY
571 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
572 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
573 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
574 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
575 _VSTD::forward<_Up>(__u)...) {}
577 template <class ..._Up,
580 sizeof...(_Up) <= sizeof...(_Tp) &&
581 __tuple_constructible
584 typename __make_tuple_types<tuple,
585 sizeof...(_Up) < sizeof...(_Tp) ?
587 sizeof...(_Tp)>::type
592 typename __make_tuple_types<tuple,
593 sizeof...(_Up) < sizeof...(_Tp) ?
595 sizeof...(_Tp)>::type
600 _LIBCPP_INLINE_VISIBILITY
603 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
604 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
605 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
606 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
607 _VSTD::forward<_Up>(__u)...) {}
609 template <class _Alloc, class ..._Up,
610 class = typename enable_if
612 sizeof...(_Up) <= sizeof...(_Tp) &&
616 typename __make_tuple_types<tuple,
617 sizeof...(_Up) < sizeof...(_Tp) ?
619 sizeof...(_Tp)>::type
623 _LIBCPP_INLINE_VISIBILITY
624 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
625 : base_(allocator_arg_t(), __a,
626 typename __make_tuple_indices<sizeof...(_Up)>::type(),
627 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
628 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
629 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
630 _VSTD::forward<_Up>(__u)...) {}
632 template <class _Tuple,
635 __tuple_convertible<_Tuple, tuple>::value,
639 _LIBCPP_INLINE_VISIBILITY
641 : base_(_VSTD::forward<_Tuple>(__t)) {}
643 template <class _Tuple,
646 __tuple_constructible<_Tuple, tuple>::value &&
647 !__tuple_convertible<_Tuple, tuple>::value,
651 _LIBCPP_INLINE_VISIBILITY
654 : base_(_VSTD::forward<_Tuple>(__t)) {}
656 template <class _Alloc, class _Tuple,
657 class = typename enable_if
659 __tuple_convertible<_Tuple, tuple>::value
662 _LIBCPP_INLINE_VISIBILITY
663 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
664 : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
666 template <class _Tuple,
667 class = typename enable_if
669 __tuple_assignable<_Tuple, tuple>::value
672 _LIBCPP_INLINE_VISIBILITY
674 operator=(_Tuple&& __t)
676 base_.operator=(_VSTD::forward<_Tuple>(__t));
680 _LIBCPP_INLINE_VISIBILITY
681 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
682 {base_.swap(__t.base_);}
686 class _LIBCPP_VISIBLE tuple<>
689 _LIBCPP_INLINE_VISIBILITY
691 template <class _Alloc>
692 _LIBCPP_INLINE_VISIBILITY
693 tuple(allocator_arg_t, const _Alloc&) {}
694 template <class _Alloc>
695 _LIBCPP_INLINE_VISIBILITY
696 tuple(allocator_arg_t, const _Alloc&, const tuple&) {}
698 _LIBCPP_INLINE_VISIBILITY
699 tuple(array<_Up, 0>) {}
700 template <class _Alloc, class _Up>
701 _LIBCPP_INLINE_VISIBILITY
702 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) {}
703 _LIBCPP_INLINE_VISIBILITY
704 void swap(tuple&) _NOEXCEPT {}
707 template <class ..._Tp>
708 inline _LIBCPP_INLINE_VISIBILITY
711 __all<__is_swappable<_Tp>::value...>::value,
714 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
715 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
720 template <size_t _Ip, class ..._Tp>
721 inline _LIBCPP_INLINE_VISIBILITY
722 typename tuple_element<_Ip, tuple<_Tp...> >::type&
723 get(tuple<_Tp...>& __t) _NOEXCEPT
725 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
726 return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
729 template <size_t _Ip, class ..._Tp>
730 inline _LIBCPP_INLINE_VISIBILITY
731 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
732 get(const tuple<_Tp...>& __t) _NOEXCEPT
734 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
735 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
738 template <size_t _Ip, class ..._Tp>
739 inline _LIBCPP_INLINE_VISIBILITY
740 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
741 get(tuple<_Tp...>&& __t) _NOEXCEPT
743 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
744 return static_cast<type&&>(
745 static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
750 template <class ..._Tp>
751 inline _LIBCPP_INLINE_VISIBILITY
755 return tuple<_Tp&...>(__t...);
762 _LIBCPP_INLINE_VISIBILITY
763 const __ignore_t& operator=(_Tp&&) const {return *this;}
766 namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
768 template <class _Tp> class reference_wrapper;
771 struct ___make_tuple_return
777 struct ___make_tuple_return<reference_wrapper<_Tp> >
783 struct __make_tuple_return
785 typedef typename ___make_tuple_return<typename decay<_Tp>::type>::type type;
788 template <class... _Tp>
789 inline _LIBCPP_INLINE_VISIBILITY
790 tuple<typename __make_tuple_return<_Tp>::type...>
791 make_tuple(_Tp&&... __t)
793 return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
796 template <class... _Tp>
797 inline _LIBCPP_INLINE_VISIBILITY
799 forward_as_tuple(_Tp&&... __t)
801 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
804 template <size_t _Ip>
807 template <class _Tp, class _Up>
808 _LIBCPP_INLINE_VISIBILITY
809 bool operator()(const _Tp& __x, const _Up& __y)
811 return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y);
816 struct __tuple_equal<0>
818 template <class _Tp, class _Up>
819 _LIBCPP_INLINE_VISIBILITY
820 bool operator()(const _Tp&, const _Up&)
826 template <class ..._Tp, class ..._Up>
827 inline _LIBCPP_INLINE_VISIBILITY
829 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
831 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
834 template <class ..._Tp, class ..._Up>
835 inline _LIBCPP_INLINE_VISIBILITY
837 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
839 return !(__x == __y);
842 template <size_t _Ip>
845 template <class _Tp, class _Up>
846 _LIBCPP_INLINE_VISIBILITY
847 bool operator()(const _Tp& __x, const _Up& __y)
849 return __tuple_less<_Ip-1>()(__x, __y) ||
850 (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y));
855 struct __tuple_less<0>
857 template <class _Tp, class _Up>
858 _LIBCPP_INLINE_VISIBILITY
859 bool operator()(const _Tp&, const _Up&)
865 template <class ..._Tp, class ..._Up>
866 inline _LIBCPP_INLINE_VISIBILITY
868 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
870 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
873 template <class ..._Tp, class ..._Up>
874 inline _LIBCPP_INLINE_VISIBILITY
876 operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
881 template <class ..._Tp, class ..._Up>
882 inline _LIBCPP_INLINE_VISIBILITY
884 operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
889 template <class ..._Tp, class ..._Up>
890 inline _LIBCPP_INLINE_VISIBILITY
892 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
899 template <class _Tp, class _Up> struct __tuple_cat_type;
901 template <class ..._Ttypes, class ..._Utypes>
902 struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
904 typedef tuple<_Ttypes..., _Utypes...> type;
907 template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
908 struct __tuple_cat_return_1
912 template <class ..._Types, class _Tuple0>
913 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
915 typedef typename __tuple_cat_type<tuple<_Types...>,
916 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
920 template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
921 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
922 : public __tuple_cat_return_1<
923 typename __tuple_cat_type<
925 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
927 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
932 template <class ..._Tuples> struct __tuple_cat_return;
934 template <class _Tuple0, class ..._Tuples>
935 struct __tuple_cat_return<_Tuple0, _Tuples...>
936 : public __tuple_cat_return_1<tuple<>,
937 __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
943 struct __tuple_cat_return<>
945 typedef tuple<> type;
948 inline _LIBCPP_INLINE_VISIBILITY
955 template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
956 struct __tuple_cat_return_ref_imp;
958 template <class ..._Types, size_t ..._I0, class _Tuple0>
959 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
961 typedef typename remove_reference<_Tuple0>::type _T0;
962 typedef tuple<_Types..., typename __apply_cv<_Tuple0,
963 typename tuple_element<_I0, _T0>::type>::type&&...> type;
966 template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
967 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
968 _Tuple0, _Tuple1, _Tuples...>
969 : public __tuple_cat_return_ref_imp<
970 tuple<_Types..., typename __apply_cv<_Tuple0,
971 typename tuple_element<_I0,
972 typename remove_reference<_Tuple0>::type>::type>::type&&...>,
973 typename __make_tuple_indices<tuple_size<typename
974 remove_reference<_Tuple1>::type>::value>::type,
979 template <class _Tuple0, class ..._Tuples>
980 struct __tuple_cat_return_ref
981 : public __tuple_cat_return_ref_imp<tuple<>,
982 typename __make_tuple_indices<
983 tuple_size<typename remove_reference<_Tuple0>::type>::value
984 >::type, _Tuple0, _Tuples...>
988 template <class _Types, class _I0, class _J0>
991 template <class ..._Types, size_t ..._I0, size_t ..._J0>
992 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
994 template <class _Tuple0>
995 _LIBCPP_INLINE_VISIBILITY
996 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
997 operator()(tuple<_Types...> __t, _Tuple0&& __t0)
999 return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
1000 get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
1003 template <class _Tuple0, class _Tuple1, class ..._Tuples>
1004 _LIBCPP_INLINE_VISIBILITY
1005 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1006 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1008 typedef typename remove_reference<_Tuple0>::type _T0;
1009 typedef typename remove_reference<_Tuple1>::type _T1;
1011 tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1012 typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1013 typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
1014 (_VSTD::forward_as_tuple(
1015 _VSTD::forward<_Types>(get<_I0>(__t))...,
1016 get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
1018 _VSTD::forward<_Tuple1>(__t1),
1019 _VSTD::forward<_Tuples>(__tpls)...);
1023 template <class _Tuple0, class... _Tuples>
1024 inline _LIBCPP_INLINE_VISIBILITY
1025 typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1026 tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1028 typedef typename remove_reference<_Tuple0>::type _T0;
1029 return __tuple_cat<tuple<>, __tuple_indices<>,
1030 typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
1031 (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1032 _VSTD::forward<_Tuples>(__tpls)...);
1035 template <class ..._Tp, class _Alloc>
1036 struct _LIBCPP_VISIBLE uses_allocator<tuple<_Tp...>, _Alloc>
1039 template <class _T1, class _T2>
1040 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
1041 inline _LIBCPP_INLINE_VISIBILITY
1042 pair<_T1, _T2>::pair(piecewise_construct_t,
1043 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1044 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
1045 : first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
1046 second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
1050 #endif // _LIBCPP_HAS_NO_VARIADICS
1052 _LIBCPP_END_NAMESPACE_STD
1054 #endif // _LIBCPP_TUPLE