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&...); // constexpr in C++14
26 explicit tuple(U&&...); // constexpr in C++14
27 tuple(const tuple&) = default;
28 tuple(tuple&&) = default;
30 tuple(const tuple<U...>&); // constexpr in C++14
32 tuple(tuple<U...>&&); // constexpr in C++14
33 template <class U1, class U2>
34 tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
35 template <class U1, class U2>
36 tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14
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&&...); // constexpr in C++14
76 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
77 template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
78 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
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...>>;
85 template <size_t _Ip, class ..._Tp>
86 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type; // C++14
88 // 20.4.1.5, element access:
89 template <intsize_t I, class... T>
90 typename tuple_element<I, tuple<T...>>::type&
91 get(tuple<T...>&) noexcept; // constexpr in C++14
92 template <intsize_t I, class... T>
93 typename const tuple_element<I, tuple<T...>>::type &
94 get(const tuple<T...>&) noexcept; // constexpr in C++14
95 template <intsize_t I, class... T>
96 typename tuple_element<I, tuple<T...>>::type&&
97 get(tuple<T...>&&) noexcept; // constexpr in C++14
99 template <class T1, class... T>
100 constexpr T1& get(tuple<T...>&) noexcept; // C++14
101 template <class T1, class... T>
102 constexpr T1 const& get(const tuple<T...>&) noexcept; // C++14
103 template <class T1, class... T>
104 constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
106 // 20.4.1.6, relational operators:
107 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
108 template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
109 template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
110 template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
111 template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
112 template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
114 template <class... Types, class Alloc>
115 struct uses_allocator<tuple<Types...>, Alloc>;
117 template <class... Types>
119 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
128 #include <type_traits>
129 #include <__functional_base>
132 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
133 #pragma GCC system_header
136 _LIBCPP_BEGIN_NAMESPACE_STD
138 #ifndef _LIBCPP_HAS_NO_VARIADICS
142 template <class ..._Tp>
143 class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
144 : public integral_constant<size_t, sizeof...(_Tp)>
150 template <size_t _Ip, class ..._Tp>
151 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
154 typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
157 #if _LIBCPP_STD_VER > 11
158 template <size_t _Ip, class ..._Tp>
159 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type;
164 template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value
165 #if __has_feature(is_final)
171 template <size_t _Ip, class _Hp, bool _Ep>
172 inline _LIBCPP_INLINE_VISIBILITY
173 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
174 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
176 swap(__x.get(), __y.get());
179 template <size_t _Ip, class _Hp, bool>
184 __tuple_leaf& operator=(const __tuple_leaf&);
186 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
187 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value()
188 {static_assert(!is_reference<_Hp>::value,
189 "Attempted to default construct a reference element in a tuple");}
191 template <class _Alloc>
192 _LIBCPP_INLINE_VISIBILITY
193 __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
195 {static_assert(!is_reference<_Hp>::value,
196 "Attempted to default construct a reference element in a tuple");}
198 template <class _Alloc>
199 _LIBCPP_INLINE_VISIBILITY
200 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
201 : value(allocator_arg_t(), __a)
202 {static_assert(!is_reference<_Hp>::value,
203 "Attempted to default construct a reference element in a tuple");}
205 template <class _Alloc>
206 _LIBCPP_INLINE_VISIBILITY
207 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
209 {static_assert(!is_reference<_Hp>::value,
210 "Attempted to default construct a reference element in a tuple");}
213 class = typename enable_if<
215 __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
216 , is_constructible<_Hp, _Tp>
220 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
221 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
222 : value(_VSTD::forward<_Tp>(__t))
223 {static_assert(!is_reference<_Hp>::value ||
224 (is_lvalue_reference<_Hp>::value &&
225 (is_lvalue_reference<_Tp>::value ||
226 is_same<typename remove_reference<_Tp>::type,
228 typename remove_reference<_Hp>::type
231 (is_rvalue_reference<_Hp>::value &&
232 !is_lvalue_reference<_Tp>::value),
233 "Attempted to construct a reference element in a tuple with an rvalue");}
235 template <class _Tp, class _Alloc>
236 _LIBCPP_INLINE_VISIBILITY
237 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
238 : value(_VSTD::forward<_Tp>(__t))
239 {static_assert(!is_lvalue_reference<_Hp>::value ||
240 (is_lvalue_reference<_Hp>::value &&
241 (is_lvalue_reference<_Tp>::value ||
242 is_same<typename remove_reference<_Tp>::type,
244 typename remove_reference<_Hp>::type
247 "Attempted to construct a reference element in a tuple with an rvalue");}
249 template <class _Tp, class _Alloc>
250 _LIBCPP_INLINE_VISIBILITY
251 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
252 : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
253 {static_assert(!is_lvalue_reference<_Hp>::value ||
254 (is_lvalue_reference<_Hp>::value &&
255 (is_lvalue_reference<_Tp>::value ||
256 is_same<typename remove_reference<_Tp>::type,
258 typename remove_reference<_Hp>::type
261 "Attempted to construct a reference element in a tuple with an rvalue");}
263 template <class _Tp, class _Alloc>
264 _LIBCPP_INLINE_VISIBILITY
265 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
266 : value(_VSTD::forward<_Tp>(__t), __a)
267 {static_assert(!is_lvalue_reference<_Hp>::value ||
268 (is_lvalue_reference<_Hp>::value &&
269 (is_lvalue_reference<_Tp>::value ||
270 is_same<typename remove_reference<_Tp>::type,
272 typename remove_reference<_Hp>::type
275 "Attempted to construct a reference element in a tuple with an rvalue");}
277 __tuple_leaf(const __tuple_leaf& __t) = default;
278 __tuple_leaf(__tuple_leaf&& __t) = default;
281 _LIBCPP_INLINE_VISIBILITY
283 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
285 value = _VSTD::forward<_Tp>(__t);
289 _LIBCPP_INLINE_VISIBILITY
290 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
292 _VSTD::swap(*this, __t);
296 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return value;}
297 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return value;}
300 template <size_t _Ip, class _Hp>
301 class __tuple_leaf<_Ip, _Hp, true>
305 __tuple_leaf& operator=(const __tuple_leaf&);
307 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
308 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
310 template <class _Alloc>
311 _LIBCPP_INLINE_VISIBILITY
312 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
314 template <class _Alloc>
315 _LIBCPP_INLINE_VISIBILITY
316 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
317 : _Hp(allocator_arg_t(), __a) {}
319 template <class _Alloc>
320 _LIBCPP_INLINE_VISIBILITY
321 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
325 class = typename enable_if<
327 __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
328 , is_constructible<_Hp, _Tp>
332 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
333 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
334 : _Hp(_VSTD::forward<_Tp>(__t)) {}
336 template <class _Tp, class _Alloc>
337 _LIBCPP_INLINE_VISIBILITY
338 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
339 : _Hp(_VSTD::forward<_Tp>(__t)) {}
341 template <class _Tp, class _Alloc>
342 _LIBCPP_INLINE_VISIBILITY
343 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
344 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
346 template <class _Tp, class _Alloc>
347 _LIBCPP_INLINE_VISIBILITY
348 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
349 : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
351 __tuple_leaf(__tuple_leaf const &) = default;
352 __tuple_leaf(__tuple_leaf &&) = default;
355 _LIBCPP_INLINE_VISIBILITY
357 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
359 _Hp::operator=(_VSTD::forward<_Tp>(__t));
363 _LIBCPP_INLINE_VISIBILITY
365 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
367 _VSTD::swap(*this, __t);
371 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
372 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
375 template <class ..._Tp>
376 _LIBCPP_INLINE_VISIBILITY
377 void __swallow(_Tp&&...) _NOEXCEPT {}
379 template <bool ..._Pred>
381 : is_same<__all<_Pred...>, __all<(_Pred, true)...>>
385 struct __all_default_constructible;
387 template <class ..._Tp>
388 struct __all_default_constructible<__tuple_types<_Tp...>>
389 : __all<is_default_constructible<_Tp>::value...>
394 template<class _Indx, class ..._Tp> struct __tuple_impl;
396 template<size_t ..._Indx, class ..._Tp>
397 struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
398 : public __tuple_leaf<_Indx, _Tp>...
400 _LIBCPP_INLINE_VISIBILITY
401 _LIBCPP_CONSTEXPR __tuple_impl()
402 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
404 template <size_t ..._Uf, class ..._Tf,
405 size_t ..._Ul, class ..._Tl, class ..._Up>
406 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
408 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
409 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
411 _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
412 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
413 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
414 __tuple_leaf<_Ul, _Tl>()...
417 template <class _Alloc, size_t ..._Uf, class ..._Tf,
418 size_t ..._Ul, class ..._Tl, class ..._Up>
419 _LIBCPP_INLINE_VISIBILITY
421 __tuple_impl(allocator_arg_t, const _Alloc& __a,
422 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
423 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
425 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
426 _VSTD::forward<_Up>(__u))...,
427 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
430 template <class _Tuple,
431 class = typename enable_if
433 __tuple_constructible<_Tuple, tuple<_Tp...> >::value
436 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
437 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
438 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
439 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
440 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
443 template <class _Alloc, class _Tuple,
444 class = typename enable_if
446 __tuple_convertible<_Tuple, tuple<_Tp...> >::value
449 _LIBCPP_INLINE_VISIBILITY
450 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
451 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
452 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
453 _VSTD::forward<typename tuple_element<_Indx,
454 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
457 template <class _Tuple>
458 _LIBCPP_INLINE_VISIBILITY
461 __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
464 operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
465 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
467 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
468 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
472 __tuple_impl(const __tuple_impl&) = default;
473 __tuple_impl(__tuple_impl&&) = default;
475 _LIBCPP_INLINE_VISIBILITY
477 operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
479 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
483 _LIBCPP_INLINE_VISIBILITY
485 operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
487 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
491 _LIBCPP_INLINE_VISIBILITY
492 void swap(__tuple_impl& __t)
493 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
495 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
499 template <class ..._Tp>
500 class _LIBCPP_TYPE_VIS_ONLY tuple
502 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
506 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
507 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
508 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
509 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
510 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
511 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
514 template <bool _Dummy = true, class _Up = typename enable_if<
515 __all<(_Dummy && is_default_constructible<_Tp>::value)...>::value
517 _LIBCPP_INLINE_VISIBILITY
518 _LIBCPP_CONSTEXPR tuple()
519 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
521 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
522 explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
523 : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
524 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
525 typename __make_tuple_indices<0>::type(),
526 typename __make_tuple_types<tuple, 0>::type(),
530 template <class _Alloc>
531 _LIBCPP_INLINE_VISIBILITY
532 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
533 : base_(allocator_arg_t(), __a,
534 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
535 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
536 typename __make_tuple_indices<0>::type(),
537 typename __make_tuple_types<tuple, 0>::type(),
541 template <class ..._Up,
544 sizeof...(_Up) <= sizeof...(_Tp) &&
548 typename __make_tuple_types<tuple,
549 sizeof...(_Up) < sizeof...(_Tp) ?
551 sizeof...(_Tp)>::type
553 __all_default_constructible<
554 typename __make_tuple_types<tuple, sizeof...(_Tp),
555 sizeof...(_Up) < sizeof...(_Tp) ?
557 sizeof...(_Tp)>::type
562 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
565 is_nothrow_constructible<base,
566 typename __make_tuple_indices<sizeof...(_Up)>::type,
567 typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
568 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
569 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
573 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
574 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
575 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
576 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
577 _VSTD::forward<_Up>(__u)...) {}
579 template <class ..._Up,
582 sizeof...(_Up) <= sizeof...(_Tp) &&
583 __tuple_constructible
586 typename __make_tuple_types<tuple,
587 sizeof...(_Up) < sizeof...(_Tp) ?
589 sizeof...(_Tp)>::type
594 typename __make_tuple_types<tuple,
595 sizeof...(_Up) < sizeof...(_Tp) ?
597 sizeof...(_Tp)>::type
599 __all_default_constructible<
600 typename __make_tuple_types<tuple, sizeof...(_Tp),
601 sizeof...(_Up) < sizeof...(_Tp) ?
603 sizeof...(_Tp)>::type
608 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
612 is_nothrow_constructible<base,
613 typename __make_tuple_indices<sizeof...(_Up)>::type,
614 typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
615 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
616 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
620 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
621 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
622 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
623 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
624 _VSTD::forward<_Up>(__u)...) {}
626 template <class _Alloc, class ..._Up,
627 class = typename enable_if
629 sizeof...(_Up) <= sizeof...(_Tp) &&
633 typename __make_tuple_types<tuple,
634 sizeof...(_Up) < sizeof...(_Tp) ?
636 sizeof...(_Tp)>::type
638 __all_default_constructible<
639 typename __make_tuple_types<tuple, sizeof...(_Tp),
640 sizeof...(_Up) < sizeof...(_Tp) ?
642 sizeof...(_Tp)>::type
646 _LIBCPP_INLINE_VISIBILITY
647 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
648 : base_(allocator_arg_t(), __a,
649 typename __make_tuple_indices<sizeof...(_Up)>::type(),
650 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
651 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
652 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
653 _VSTD::forward<_Up>(__u)...) {}
655 template <class _Tuple,
658 __tuple_convertible<_Tuple, tuple>::value,
662 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
663 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
664 : base_(_VSTD::forward<_Tuple>(__t)) {}
666 template <class _Tuple,
669 __tuple_constructible<_Tuple, tuple>::value &&
670 !__tuple_convertible<_Tuple, tuple>::value,
674 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
676 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
677 : base_(_VSTD::forward<_Tuple>(__t)) {}
679 template <class _Alloc, class _Tuple,
680 class = typename enable_if
682 __tuple_convertible<_Tuple, tuple>::value
685 _LIBCPP_INLINE_VISIBILITY
686 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
687 : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
689 template <class _Tuple,
690 class = typename enable_if
692 __tuple_assignable<_Tuple, tuple>::value
695 _LIBCPP_INLINE_VISIBILITY
697 operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
699 base_.operator=(_VSTD::forward<_Tuple>(__t));
703 _LIBCPP_INLINE_VISIBILITY
704 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
705 {base_.swap(__t.base_);}
709 class _LIBCPP_TYPE_VIS_ONLY tuple<>
712 _LIBCPP_INLINE_VISIBILITY
713 _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
714 template <class _Alloc>
715 _LIBCPP_INLINE_VISIBILITY
716 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
717 template <class _Alloc>
718 _LIBCPP_INLINE_VISIBILITY
719 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
721 _LIBCPP_INLINE_VISIBILITY
722 tuple(array<_Up, 0>) _NOEXCEPT {}
723 template <class _Alloc, class _Up>
724 _LIBCPP_INLINE_VISIBILITY
725 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
726 _LIBCPP_INLINE_VISIBILITY
727 void swap(tuple&) _NOEXCEPT {}
730 template <class ..._Tp>
731 inline _LIBCPP_INLINE_VISIBILITY
734 __all<__is_swappable<_Tp>::value...>::value,
737 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
738 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
743 template <size_t _Ip, class ..._Tp>
744 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
745 typename tuple_element<_Ip, tuple<_Tp...> >::type&
746 get(tuple<_Tp...>& __t) _NOEXCEPT
748 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
749 return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
752 template <size_t _Ip, class ..._Tp>
753 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
754 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
755 get(const tuple<_Tp...>& __t) _NOEXCEPT
757 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
758 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
761 template <size_t _Ip, class ..._Tp>
762 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
763 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
764 get(tuple<_Tp...>&& __t) _NOEXCEPT
766 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
767 return static_cast<type&&>(
768 static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
771 #if _LIBCPP_STD_VER > 11
773 template <typename _T1, size_t _Idx, typename... _Args>
774 struct __find_exactly_one_t_helper;
776 // -- find exactly one
777 template <typename _T1, size_t _Idx, typename... _Args>
778 struct __find_exactly_one_t_checker {
779 static constexpr size_t value = _Idx;
780 // Check the rest of the list to make sure there's only one
781 static_assert ( __find_exactly_one_t_helper<_T1, 0, _Args...>::value == -1, "type can only occur once in type list" );
785 template <typename _T1, size_t _Idx>
786 struct __find_exactly_one_t_helper <_T1, _Idx> {
787 static constexpr size_t value = -1;
790 template <typename _T1, size_t _Idx, typename _Head, typename... _Args>
791 struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> {
792 static constexpr size_t value =
794 std::is_same<_T1, _Head>::value,
795 __find_exactly_one_t_checker<_T1, _Idx, _Args...>,
796 __find_exactly_one_t_helper <_T1, _Idx+1, _Args...>
800 template <typename _T1, typename... _Args>
801 struct __find_exactly_one_t {
802 static constexpr size_t value = __find_exactly_one_t_helper<_T1, 0, _Args...>::value;
803 static_assert ( value != -1, "type not found in type list" );
806 template <class _T1, class... _Args>
807 inline _LIBCPP_INLINE_VISIBILITY
808 constexpr _T1& get(tuple<_Args...>& __tup) noexcept
810 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
813 template <class _T1, class... _Args>
814 inline _LIBCPP_INLINE_VISIBILITY
815 constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
817 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
820 template <class _T1, class... _Args>
821 inline _LIBCPP_INLINE_VISIBILITY
822 constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
824 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
831 template <class ..._Tp>
832 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
834 tie(_Tp&... __t) _NOEXCEPT
836 return tuple<_Tp&...>(__t...);
843 _LIBCPP_INLINE_VISIBILITY
844 const __ignore_t& operator=(_Tp&&) const {return *this;}
847 namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
849 template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
852 struct __make_tuple_return_impl
858 struct __make_tuple_return_impl<reference_wrapper<_Tp> >
864 struct __make_tuple_return
866 typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type;
869 template <class... _Tp>
870 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
871 tuple<typename __make_tuple_return<_Tp>::type...>
872 make_tuple(_Tp&&... __t)
874 return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
877 template <class... _Tp>
878 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
880 forward_as_tuple(_Tp&&... __t) _NOEXCEPT
882 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
885 template <size_t _Ip>
888 template <class _Tp, class _Up>
889 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
890 bool operator()(const _Tp& __x, const _Up& __y)
892 return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
897 struct __tuple_equal<0>
899 template <class _Tp, class _Up>
900 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
901 bool operator()(const _Tp&, const _Up&)
907 template <class ..._Tp, class ..._Up>
908 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
910 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
912 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
915 template <class ..._Tp, class ..._Up>
916 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
918 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
920 return !(__x == __y);
923 template <size_t _Ip>
926 template <class _Tp, class _Up>
927 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
928 bool operator()(const _Tp& __x, const _Up& __y)
930 return __tuple_less<_Ip-1>()(__x, __y) ||
931 (!__tuple_less<_Ip-1>()(__y, __x) && _VSTD::get<_Ip-1>(__x) < _VSTD::get<_Ip-1>(__y));
936 struct __tuple_less<0>
938 template <class _Tp, class _Up>
939 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
940 bool operator()(const _Tp&, const _Up&)
946 template <class ..._Tp, class ..._Up>
947 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
949 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
951 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
954 template <class ..._Tp, class ..._Up>
955 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
957 operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
962 template <class ..._Tp, class ..._Up>
963 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
965 operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
970 template <class ..._Tp, class ..._Up>
971 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
973 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
980 template <class _Tp, class _Up> struct __tuple_cat_type;
982 template <class ..._Ttypes, class ..._Utypes>
983 struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
985 typedef tuple<_Ttypes..., _Utypes...> type;
988 template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
989 struct __tuple_cat_return_1
993 template <class ..._Types, class _Tuple0>
994 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
996 typedef typename __tuple_cat_type<tuple<_Types...>,
997 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
1001 template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
1002 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1003 : public __tuple_cat_return_1<
1004 typename __tuple_cat_type<
1006 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
1008 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
1009 _Tuple1, _Tuples...>
1013 template <class ..._Tuples> struct __tuple_cat_return;
1015 template <class _Tuple0, class ..._Tuples>
1016 struct __tuple_cat_return<_Tuple0, _Tuples...>
1017 : public __tuple_cat_return_1<tuple<>,
1018 __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
1024 struct __tuple_cat_return<>
1026 typedef tuple<> type;
1029 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1036 template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
1037 struct __tuple_cat_return_ref_imp;
1039 template <class ..._Types, size_t ..._I0, class _Tuple0>
1040 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
1042 typedef typename remove_reference<_Tuple0>::type _T0;
1043 typedef tuple<_Types..., typename __apply_cv<_Tuple0,
1044 typename tuple_element<_I0, _T0>::type>::type&&...> type;
1047 template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
1048 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
1049 _Tuple0, _Tuple1, _Tuples...>
1050 : public __tuple_cat_return_ref_imp<
1051 tuple<_Types..., typename __apply_cv<_Tuple0,
1052 typename tuple_element<_I0,
1053 typename remove_reference<_Tuple0>::type>::type>::type&&...>,
1054 typename __make_tuple_indices<tuple_size<typename
1055 remove_reference<_Tuple1>::type>::value>::type,
1056 _Tuple1, _Tuples...>
1060 template <class _Tuple0, class ..._Tuples>
1061 struct __tuple_cat_return_ref
1062 : public __tuple_cat_return_ref_imp<tuple<>,
1063 typename __make_tuple_indices<
1064 tuple_size<typename remove_reference<_Tuple0>::type>::value
1065 >::type, _Tuple0, _Tuples...>
1069 template <class _Types, class _I0, class _J0>
1072 template <class ..._Types, size_t ..._I0, size_t ..._J0>
1073 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
1075 template <class _Tuple0>
1076 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1077 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1078 operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1080 return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1081 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
1084 template <class _Tuple0, class _Tuple1, class ..._Tuples>
1085 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1086 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1087 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1089 typedef typename remove_reference<_Tuple0>::type _T0;
1090 typedef typename remove_reference<_Tuple1>::type _T1;
1092 tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1093 typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1094 typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
1096 _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1097 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
1099 _VSTD::forward<_Tuple1>(__t1),
1100 _VSTD::forward<_Tuples>(__tpls)...);
1104 template <class _Tuple0, class... _Tuples>
1105 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1106 typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1107 tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1109 typedef typename remove_reference<_Tuple0>::type _T0;
1110 return __tuple_cat<tuple<>, __tuple_indices<>,
1111 typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
1112 (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1113 _VSTD::forward<_Tuples>(__tpls)...);
1116 template <class ..._Tp, class _Alloc>
1117 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<tuple<_Tp...>, _Alloc>
1120 template <class _T1, class _T2>
1121 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
1122 inline _LIBCPP_INLINE_VISIBILITY
1123 pair<_T1, _T2>::pair(piecewise_construct_t,
1124 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1125 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
1126 : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
1127 second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
1131 #endif // _LIBCPP_HAS_NO_VARIADICS
1133 _LIBCPP_END_NAMESPACE_STD
1135 #endif // _LIBCPP_TUPLE