1// -*- C++ -*-
2//===--------------------------- tuple ------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_TUPLE
11#define _LIBCPP_TUPLE
12
13/*
14 tuple synopsis
15
16namespace std
17{
18
19template <class... T>
20class tuple {
21public:
22 constexpr tuple();
23 explicit tuple(const T&...); // constexpr in C++14
24 template <class... U>
25 explicit tuple(U&&...); // constexpr in C++14
26 tuple(const tuple&) = default;
27 tuple(tuple&&) = default;
28 template <class... U>
29 tuple(const tuple<U...>&); // constexpr in C++14
30 template <class... U>
31 tuple(tuple<U...>&&); // constexpr in C++14
32 template <class U1, class U2>
33 tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
34 template <class U1, class U2>
35 tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14
36
37 // allocator-extended constructors
38 template <class Alloc>
39 tuple(allocator_arg_t, const Alloc& a);
40 template <class Alloc>
41 tuple(allocator_arg_t, const Alloc& a, const T&...);
42 template <class Alloc, class... U>
43 tuple(allocator_arg_t, const Alloc& a, U&&...);
44 template <class Alloc>
45 tuple(allocator_arg_t, const Alloc& a, const tuple&);
46 template <class Alloc>
47 tuple(allocator_arg_t, const Alloc& a, tuple&&);
48 template <class Alloc, class... U>
49 tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
50 template <class Alloc, class... U>
51 tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
52 template <class Alloc, class U1, class U2>
53 tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
54 template <class Alloc, class U1, class U2>
55 tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
56
57 tuple& operator=(const tuple&);
58 tuple&
59 operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
60 template <class... U>
61 tuple& operator=(const tuple<U...>&);
62 template <class... U>
63 tuple& operator=(tuple<U...>&&);
64 template <class U1, class U2>
65 tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
66 template <class U1, class U2>
67 tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2
68
69 void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
70};
71
72inline constexpr unspecified ignore;
73
74template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14
75template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
76template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
77template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
78
79// [tuple.apply], calling a function with a tuple of arguments:
80template <class F, class Tuple>
81 constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
82template <class T, class Tuple>
83 constexpr T make_from_tuple(Tuple&& t); // C++17
84
85// 20.4.1.4, tuple helper classes:
86template <class T> struct tuple_size; // undefined
87template <class... T> struct tuple_size<tuple<T...>>;
88template <class T>
89 inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
90template <size_t I, class T> struct tuple_element; // undefined
91template <size_t I, class... T> struct tuple_element<I, tuple<T...>>;
92template <size_t I, class T>
93 using tuple_element_t = typename tuple_element <I, T>::type; // C++14
94
95// 20.4.1.5, element access:
96template <size_t I, class... T>
97 typename tuple_element<I, tuple<T...>>::type&
98 get(tuple<T...>&) noexcept; // constexpr in C++14
99template <size_t I, class... T>
100 const typename tuple_element<I, tuple<T...>>::type&
101 get(const tuple<T...>&) noexcept; // constexpr in C++14
102template <size_t I, class... T>
103 typename tuple_element<I, tuple<T...>>::type&&
104 get(tuple<T...>&&) noexcept; // constexpr in C++14
105template <size_t I, class... T>
106 const typename tuple_element<I, tuple<T...>>::type&&
107 get(const tuple<T...>&&) noexcept; // constexpr in C++14
108
109template <class T1, class... T>
110 constexpr T1& get(tuple<T...>&) noexcept; // C++14
111template <class T1, class... T>
112 constexpr const T1& get(const tuple<T...>&) noexcept; // C++14
113template <class T1, class... T>
114 constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
115template <class T1, class... T>
116 constexpr const T1&& get(const tuple<T...>&&) noexcept; // C++14
117
118// 20.4.1.6, relational operators:
119template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
120template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
121template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
122template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
123template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
124template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
125
126template <class... Types, class Alloc>
127 struct uses_allocator<tuple<Types...>, Alloc>;
128
129template <class... Types>
130 void
131 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
132
133} // std
134
135*/
136
137#include <__config>
138#include <__tuple>
139#include <cstddef>
140#include <type_traits>
141#include <__functional_base>
142#include <utility>
143#include <version>
144
145#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
146#pragma GCC system_header
147#endif
148
149_LIBCPP_BEGIN_NAMESPACE_STD
150
151#ifndef _LIBCPP_CXX03_LANG
152
153
154// __tuple_leaf
155
156template <size_t _Ip, class _Hp,
157 bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
158 >
159class __tuple_leaf;
160
161template <size_t _Ip, class _Hp, bool _Ep>
162inline _LIBCPP_INLINE_VISIBILITY
163void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
164 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
165{
166 swap(__x.get(), __y.get());
167}
168
169template <size_t _Ip, class _Hp, bool>
170class __tuple_leaf
171{
172 _Hp __value_;
173
174 template <class _Tp>
175 static constexpr bool __can_bind_reference() {
176#if __has_keyword(__reference_binds_to_temporary)
177 return !__reference_binds_to_temporary(_Hp, _Tp);
178#else
179 return true;
180#endif
181 }
182
183 __tuple_leaf& operator=(const __tuple_leaf&);
184public:
185 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
186 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
187 {static_assert(!is_reference<_Hp>::value,
188 "Attempted to default construct a reference element in a tuple");}
189
190 template <class _Alloc>
191 _LIBCPP_INLINE_VISIBILITY
192 __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
193 : __value_()
194 {static_assert(!is_reference<_Hp>::value,
195 "Attempted to default construct a reference element in a tuple");}
196
197 template <class _Alloc>
198 _LIBCPP_INLINE_VISIBILITY
199 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
200 : __value_(allocator_arg_t(), __a)
201 {static_assert(!is_reference<_Hp>::value,
202 "Attempted to default construct a reference element in a tuple");}
203
204 template <class _Alloc>
205 _LIBCPP_INLINE_VISIBILITY
206 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
207 : __value_(__a)
208 {static_assert(!is_reference<_Hp>::value,
209 "Attempted to default construct a reference element in a tuple");}
210
211 template <class _Tp,
212 class = _EnableIf<
213 _And<
214 _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
215 is_constructible<_Hp, _Tp>
216 >::value
217 >
218 >
219 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
220 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
221 : __value_(_VSTD::forward<_Tp>(__t))
222 {static_assert(__can_bind_reference<_Tp&&>(),
223 "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
224
225 template <class _Tp, class _Alloc>
226 _LIBCPP_INLINE_VISIBILITY
227 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
228 : __value_(_VSTD::forward<_Tp>(__t))
229 {static_assert(__can_bind_reference<_Tp&&>(),
230 "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
231
232 template <class _Tp, class _Alloc>
233 _LIBCPP_INLINE_VISIBILITY
234 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
235 : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
236 {static_assert(!is_reference<_Hp>::value,
237 "Attempted to uses-allocator construct a reference element in a tuple");}
238
239 template <class _Tp, class _Alloc>
240 _LIBCPP_INLINE_VISIBILITY
241 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
242 : __value_(_VSTD::forward<_Tp>(__t), __a)
243 {static_assert(!is_reference<_Hp>::value,
244 "Attempted to uses-allocator construct a reference element in a tuple");}
245
246 __tuple_leaf(const __tuple_leaf& __t) = default;
247 __tuple_leaf(__tuple_leaf&& __t) = default;
248
249 template <class _Tp>
250 _LIBCPP_INLINE_VISIBILITY
251 __tuple_leaf&
252 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
253 {
254 __value_ = _VSTD::forward<_Tp>(__t);
255 return *this;
256 }
257
258 _LIBCPP_INLINE_VISIBILITY
259 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
260 {
261 _VSTD::swap(*this, __t);
262 return 0;
263 }
264
265 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return __value_;}
266 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
267};
268
269template <size_t _Ip, class _Hp>
270class __tuple_leaf<_Ip, _Hp, true>
271 : private _Hp
272{
273
274 __tuple_leaf& operator=(const __tuple_leaf&);
275public:
276 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
277 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
278
279 template <class _Alloc>
280 _LIBCPP_INLINE_VISIBILITY
281 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
282
283 template <class _Alloc>
284 _LIBCPP_INLINE_VISIBILITY
285 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
286 : _Hp(allocator_arg_t(), __a) {}
287
288 template <class _Alloc>
289 _LIBCPP_INLINE_VISIBILITY
290 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
291 : _Hp(__a) {}
292
293 template <class _Tp,
294 class = _EnableIf<
295 _And<
296 _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
297 is_constructible<_Hp, _Tp>
298 >::value
299 >
300 >
301 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
302 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
303 : _Hp(_VSTD::forward<_Tp>(__t)) {}
304
305 template <class _Tp, class _Alloc>
306 _LIBCPP_INLINE_VISIBILITY
307 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
308 : _Hp(_VSTD::forward<_Tp>(__t)) {}
309
310 template <class _Tp, class _Alloc>
311 _LIBCPP_INLINE_VISIBILITY
312 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
313 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
314
315 template <class _Tp, class _Alloc>
316 _LIBCPP_INLINE_VISIBILITY
317 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
318 : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
319
320 __tuple_leaf(__tuple_leaf const &) = default;
321 __tuple_leaf(__tuple_leaf &&) = default;
322
323 template <class _Tp>
324 _LIBCPP_INLINE_VISIBILITY
325 __tuple_leaf&
326 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
327 {
328 _Hp::operator=(_VSTD::forward<_Tp>(__t));
329 return *this;
330 }
331
332 _LIBCPP_INLINE_VISIBILITY
333 int
334 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
335 {
336 _VSTD::swap(*this, __t);
337 return 0;
338 }
339
340 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
341 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
342};
343
344template <class ..._Tp>
345_LIBCPP_INLINE_VISIBILITY
346void __swallow(_Tp&&...) _NOEXCEPT {}
347
348template <class _Tp>
349struct __all_default_constructible;
350
351template <class ..._Tp>
352struct __all_default_constructible<__tuple_types<_Tp...>>
353 : __all<is_default_constructible<_Tp>::value...>
354{ };
355
356// __tuple_impl
357
358template<class _Indx, class ..._Tp> struct __tuple_impl;
359
360template<size_t ..._Indx, class ..._Tp>
361struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
362 : public __tuple_leaf<_Indx, _Tp>...
363{
364 _LIBCPP_INLINE_VISIBILITY
365 _LIBCPP_CONSTEXPR __tuple_impl()
366 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
367
368 template <size_t ..._Uf, class ..._Tf,
369 size_t ..._Ul, class ..._Tl, class ..._Up>
370 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
371 explicit
372 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
373 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
374 _Up&&... __u)
375 _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
376 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
377 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
378 __tuple_leaf<_Ul, _Tl>()...
379 {}
380
381 template <class _Alloc, size_t ..._Uf, class ..._Tf,
382 size_t ..._Ul, class ..._Tl, class ..._Up>
383 _LIBCPP_INLINE_VISIBILITY
384 explicit
385 __tuple_impl(allocator_arg_t, const _Alloc& __a,
386 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
387 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
388 _Up&&... __u) :
389 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
390 _VSTD::forward<_Up>(__u))...,
391 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
392 {}
393
394 template <class _Tuple,
395 class = typename enable_if
396 <
397 __tuple_constructible<_Tuple, tuple<_Tp...> >::value
398 >::type
399 >
400 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
401 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
402 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
403 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
404 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
405 {}
406
407 template <class _Alloc, class _Tuple,
408 class = typename enable_if
409 <
410 __tuple_constructible<_Tuple, tuple<_Tp...> >::value
411 >::type
412 >
413 _LIBCPP_INLINE_VISIBILITY
414 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
415 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
416 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
417 _VSTD::forward<typename tuple_element<_Indx,
418 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
419 {}
420
421 template <class _Tuple>
422 _LIBCPP_INLINE_VISIBILITY
423 typename enable_if
424 <
425 __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
426 __tuple_impl&
427 >::type
428 operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
429 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
430 {
431 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
432 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
433 return *this;
434 }
435
436 __tuple_impl(const __tuple_impl&) = default;
437 __tuple_impl(__tuple_impl&&) = default;
438
439 _LIBCPP_INLINE_VISIBILITY
440 __tuple_impl&
441 operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
442 {
443 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
444 return *this;
445 }
446
447 _LIBCPP_INLINE_VISIBILITY
448 __tuple_impl&
449 operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
450 {
451 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
452 return *this;
453 }
454
455 _LIBCPP_INLINE_VISIBILITY
456 void swap(__tuple_impl& __t)
457 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
458 {
459 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
460 }
461};
462
463
464
465template <class ..._Tp>
466class _LIBCPP_TEMPLATE_VIS tuple
467{
468 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
469
470 _BaseT __base_;
471
472#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
473 static constexpr bool _EnableImplicitReducedArityExtension = true;
474#else
475 static constexpr bool _EnableImplicitReducedArityExtension = false;
476#endif
477
478 template <class ..._Args>
479 struct _PackExpandsToThisTuple : false_type {};
480
481 template <class _Arg>
482 struct _PackExpandsToThisTuple<_Arg>
483 : is_same<typename __uncvref<_Arg>::type, tuple> {};
484
485 template <bool _MaybeEnable, class _Dummy = void>
486 struct _CheckArgsConstructor : __check_tuple_constructor_fail {};
487
488 template <class _Dummy>
489 struct _CheckArgsConstructor<true, _Dummy>
490 {
491 template <class ..._Args>
492 static constexpr bool __enable_default() {
493 return __all<is_default_constructible<_Args>::value...>::value;
494 }
495
496 template <class ..._Args>
497 static constexpr bool __enable_explicit() {
498 return
499 __tuple_constructible<
500 tuple<_Args...>,
501 typename __make_tuple_types<tuple,
502 sizeof...(_Args) < sizeof...(_Tp) ?
503 sizeof...(_Args) :
504 sizeof...(_Tp)>::type
505 >::value &&
506 !__tuple_convertible<
507 tuple<_Args...>,
508 typename __make_tuple_types<tuple,
509 sizeof...(_Args) < sizeof...(_Tp) ?
510 sizeof...(_Args) :
511 sizeof...(_Tp)>::type
512 >::value &&
513 __all_default_constructible<
514 typename __make_tuple_types<tuple, sizeof...(_Tp),
515 sizeof...(_Args) < sizeof...(_Tp) ?
516 sizeof...(_Args) :
517 sizeof...(_Tp)>::type
518 >::value;
519 }
520
521 template <class ..._Args>
522 static constexpr bool __enable_implicit() {
523 return
524 __tuple_constructible<
525 tuple<_Args...>,
526 typename __make_tuple_types<tuple,
527 sizeof...(_Args) < sizeof...(_Tp) ?
528 sizeof...(_Args) :
529 sizeof...(_Tp)>::type
530 >::value &&
531 __tuple_convertible<
532 tuple<_Args...>,
533 typename __make_tuple_types<tuple,
534 sizeof...(_Args) < sizeof...(_Tp) ?
535 sizeof...(_Args) :
536 sizeof...(_Tp)>::type
537 >::value &&
538 __all_default_constructible<
539 typename __make_tuple_types<tuple, sizeof...(_Tp),
540 sizeof...(_Args) < sizeof...(_Tp) ?
541 sizeof...(_Args) :
542 sizeof...(_Tp)>::type
543 >::value;
544 }
545 };
546
547 template <bool _MaybeEnable,
548 bool = sizeof...(_Tp) == 1,
549 class _Dummy = void>
550 struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
551
552 template <class _Dummy>
553 struct _CheckTupleLikeConstructor<true, false, _Dummy>
554 {
555 template <class _Tuple>
556 static constexpr bool __enable_implicit() {
557 return __tuple_constructible<_Tuple, tuple>::value
558 && __tuple_convertible<_Tuple, tuple>::value;
559 }
560
561 template <class _Tuple>
562 static constexpr bool __enable_explicit() {
563 return __tuple_constructible<_Tuple, tuple>::value
564 && !__tuple_convertible<_Tuple, tuple>::value;
565 }
566 };
567
568 template <class _Dummy>
569 struct _CheckTupleLikeConstructor<true, true, _Dummy>
570 {
571 // This trait is used to disable the tuple-like constructor when
572 // the UTypes... constructor should be selected instead.
573 // See LWG issue #2549.
574 template <class _Tuple>
575 using _PreferTupleLikeConstructor = _Or<
576 // Don't attempt the two checks below if the tuple we are given
577 // has the same type as this tuple.
578 _IsSame<__uncvref_t<_Tuple>, tuple>,
579 _Lazy<_And,
580 _Not<is_constructible<_Tp..., _Tuple>>,
581 _Not<is_convertible<_Tuple, _Tp...>>
582 >
583 >;
584
585 template <class _Tuple>
586 static constexpr bool __enable_implicit() {
587 return _And<
588 __tuple_constructible<_Tuple, tuple>,
589 __tuple_convertible<_Tuple, tuple>,
590 _PreferTupleLikeConstructor<_Tuple>
591 >::value;
592 }
593
594 template <class _Tuple>
595 static constexpr bool __enable_explicit() {
596 return _And<
597 __tuple_constructible<_Tuple, tuple>,
598 _PreferTupleLikeConstructor<_Tuple>,
599 _Not<__tuple_convertible<_Tuple, tuple>>
600 >::value;
601 }
602 };
603
604 template <class _Tuple, bool _DisableIfLValue>
605 using _EnableImplicitTupleLikeConstructor = _EnableIf<
606 _CheckTupleLikeConstructor<
607 __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
608 && !_PackExpandsToThisTuple<_Tuple>::value
609 && (!is_lvalue_reference<_Tuple>::value || !_DisableIfLValue)
610 >::template __enable_implicit<_Tuple>(),
611 bool
612 >;
613
614 template <class _Tuple, bool _DisableIfLValue>
615 using _EnableExplicitTupleLikeConstructor = _EnableIf<
616 _CheckTupleLikeConstructor<
617 __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
618 && !_PackExpandsToThisTuple<_Tuple>::value
619 && (!is_lvalue_reference<_Tuple>::value || !_DisableIfLValue)
620 >::template __enable_explicit<_Tuple>(),
621 bool
622 >;
623 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
624 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
625 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
626 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
627 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
628 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
629 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
630 const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
631public:
632
633 template <bool _Dummy = true, class = typename enable_if<
634 _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
635 >::type>
636 _LIBCPP_INLINE_VISIBILITY
637 _LIBCPP_CONSTEXPR tuple()
638 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
639
640 tuple(tuple const&) = default;
641 tuple(tuple&&) = default;
642
643 template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = _EnableIf<
644 _And<
645 _IsSame<allocator_arg_t, _AllocArgT>,
646 __dependent_type<is_default_constructible<_Tp>, _Dummy>...
647 >::value
648 >
649 >
650 _LIBCPP_INLINE_VISIBILITY
651 tuple(_AllocArgT, _Alloc const& __a)
652 : __base_(allocator_arg_t(), __a,
653 __tuple_indices<>(), __tuple_types<>(),
654 typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
655 __tuple_types<_Tp...>()) {}
656
657 template <bool _Dummy = true,
658 typename enable_if
659 <
660 _CheckArgsConstructor<
661 _Dummy
662 >::template __enable_implicit<_Tp const&...>(),
663 bool
664 >::type = false
665 >
666 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
667 tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
668 : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
669 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
670 typename __make_tuple_indices<0>::type(),
671 typename __make_tuple_types<tuple, 0>::type(),
672 __t...
673 ) {}
674
675 template <bool _Dummy = true,
676 typename enable_if
677 <
678 _CheckArgsConstructor<
679 _Dummy
680 >::template __enable_explicit<_Tp const&...>(),
681 bool
682 >::type = false
683 >
684 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
685 explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
686 : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
687 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
688 typename __make_tuple_indices<0>::type(),
689 typename __make_tuple_types<tuple, 0>::type(),
690 __t...
691 ) {}
692
693 template <class _Alloc, bool _Dummy = true,
694 typename enable_if
695 <
696 _CheckArgsConstructor<
697 _Dummy
698 >::template __enable_implicit<_Tp const&...>(),
699 bool
700 >::type = false
701 >
702 _LIBCPP_INLINE_VISIBILITY
703 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
704 : __base_(allocator_arg_t(), __a,
705 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
706 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
707 typename __make_tuple_indices<0>::type(),
708 typename __make_tuple_types<tuple, 0>::type(),
709 __t...
710 ) {}
711
712 template <class _Alloc, bool _Dummy = true,
713 typename enable_if
714 <
715 _CheckArgsConstructor<
716 _Dummy
717 >::template __enable_explicit<_Tp const&...>(),
718 bool
719 >::type = false
720 >
721 _LIBCPP_INLINE_VISIBILITY
722 explicit
723 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
724 : __base_(allocator_arg_t(), __a,
725 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
726 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
727 typename __make_tuple_indices<0>::type(),
728 typename __make_tuple_types<tuple, 0>::type(),
729 __t...
730 ) {}
731
732 template <class ..._Up,
733 bool _PackIsTuple = _PackExpandsToThisTuple<_Up...>::value,
734 typename enable_if
735 <
736 _CheckArgsConstructor<
737 sizeof...(_Up) == sizeof...(_Tp)
738 && !_PackIsTuple
739 >::template __enable_implicit<_Up...>() ||
740 _CheckArgsConstructor<
741 _EnableImplicitReducedArityExtension
742 && sizeof...(_Up) < sizeof...(_Tp)
743 && !_PackIsTuple
744 >::template __enable_implicit<_Up...>(),
745 bool
746 >::type = false
747 >
748 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
749 tuple(_Up&&... __u)
750 _NOEXCEPT_((
751 is_nothrow_constructible<_BaseT,
752 typename __make_tuple_indices<sizeof...(_Up)>::type,
753 typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
754 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
755 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
756 _Up...
757 >::value
758 ))
759 : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
760 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
761 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
762 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
763 _VSTD::forward<_Up>(__u)...) {}
764
765 template <class ..._Up,
766 typename enable_if
767 <
768 _CheckArgsConstructor<
769 sizeof...(_Up) <= sizeof...(_Tp)
770 && !_PackExpandsToThisTuple<_Up...>::value
771 >::template __enable_explicit<_Up...>() ||
772 _CheckArgsConstructor<
773 !_EnableImplicitReducedArityExtension
774 && sizeof...(_Up) < sizeof...(_Tp)
775 && !_PackExpandsToThisTuple<_Up...>::value
776 >::template __enable_implicit<_Up...>(),
777 bool
778 >::type = false
779 >
780 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
781 explicit
782 tuple(_Up&&... __u)
783 _NOEXCEPT_((
784 is_nothrow_constructible<_BaseT,
785 typename __make_tuple_indices<sizeof...(_Up)>::type,
786 typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
787 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
788 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
789 _Up...
790 >::value
791 ))
792 : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
793 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
794 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
795 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
796 _VSTD::forward<_Up>(__u)...) {}
797
798 template <class _Alloc, class ..._Up,
799 typename enable_if
800 <
801 _CheckArgsConstructor<
802 sizeof...(_Up) == sizeof...(_Tp) &&
803 !_PackExpandsToThisTuple<_Up...>::value
804 >::template __enable_implicit<_Up...>(),
805 bool
806 >::type = false
807 >
808 _LIBCPP_INLINE_VISIBILITY
809 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
810 : __base_(allocator_arg_t(), __a,
811 typename __make_tuple_indices<sizeof...(_Up)>::type(),
812 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
813 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
814 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
815 _VSTD::forward<_Up>(__u)...) {}
816
817 template <class _Alloc, class ..._Up,
818 typename enable_if
819 <
820 _CheckArgsConstructor<
821 sizeof...(_Up) == sizeof...(_Tp) &&
822 !_PackExpandsToThisTuple<_Up...>::value
823 >::template __enable_explicit<_Up...>(),
824 bool
825 >::type = false
826 >
827 _LIBCPP_INLINE_VISIBILITY
828 explicit
829 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
830 : __base_(allocator_arg_t(), __a,
831 typename __make_tuple_indices<sizeof...(_Up)>::type(),
832 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
833 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
834 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
835 _VSTD::forward<_Up>(__u)...) {}
836
837 template <class _Tuple, _EnableImplicitTupleLikeConstructor<_Tuple, true> = false>
838 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
839 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
840 : __base_(_VSTD::forward<_Tuple>(__t)) {}
841
842 template <class _Tuple, _EnableImplicitTupleLikeConstructor<const _Tuple&, false> = false>
843 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
844 tuple(const _Tuple& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, const _Tuple&>::value))
845 : __base_(__t) {}
846 template <class _Tuple, _EnableExplicitTupleLikeConstructor<_Tuple, true> = false>
847 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
848 explicit
849 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
850 : __base_(_VSTD::forward<_Tuple>(__t)) {}
851
852 template <class _Tuple, _EnableExplicitTupleLikeConstructor<const _Tuple&, false> = false>
853 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
854 explicit
855 tuple(const _Tuple& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, const _Tuple&>::value))
856 : __base_(__t) {}
857
858 template <class _Alloc, class _Tuple,
859 typename enable_if
860 <
861 _CheckTupleLikeConstructor<
862 __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
863 >::template __enable_implicit<_Tuple>(),
864 bool
865 >::type = false
866 >
867 _LIBCPP_INLINE_VISIBILITY
868 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
869 : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
870
871 template <class _Alloc, class _Tuple,
872 typename enable_if
873 <
874 _CheckTupleLikeConstructor<
875 __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
876 >::template __enable_explicit<_Tuple>(),
877 bool
878 >::type = false
879 >
880 _LIBCPP_INLINE_VISIBILITY
881 explicit
882 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
883 : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
884
885 using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
886 using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
887
888 _LIBCPP_INLINE_VISIBILITY
889 tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
890 _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
891 {
892 __base_.operator=(__t.__base_);
893 return *this;
894 }
895
896 _LIBCPP_INLINE_VISIBILITY
897 tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
898 _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
899 {
900 __base_.operator=(static_cast<_BaseT&&>(__t.__base_));
901 return *this;
902 }
903
904 template <class _Tuple,
905 class = typename enable_if
906 <
907 __tuple_assignable<_Tuple, tuple>::value
908 >::type
909 >
910 _LIBCPP_INLINE_VISIBILITY
911 tuple&
912 operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value))
913 {
914 __base_.operator=(_VSTD::forward<_Tuple>(__t));
915 return *this;
916 }
917
918 _LIBCPP_INLINE_VISIBILITY
919 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
920 {__base_.swap(__t.__base_);}
921};
922
923template <>
924class _LIBCPP_TEMPLATE_VIS tuple<>
925{
926public:
927 _LIBCPP_INLINE_VISIBILITY
928 _LIBCPP_CONSTEXPR tuple() _NOEXCEPT = default;
929 template <class _Alloc>
930 _LIBCPP_INLINE_VISIBILITY
931 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
932 template <class _Alloc>
933 _LIBCPP_INLINE_VISIBILITY
934 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
935 template <class _Up>
936 _LIBCPP_INLINE_VISIBILITY
937 tuple(array<_Up, 0>) _NOEXCEPT {}
938 template <class _Alloc, class _Up>
939 _LIBCPP_INLINE_VISIBILITY
940 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
941 _LIBCPP_INLINE_VISIBILITY
942 void swap(tuple&) _NOEXCEPT {}
943};
944
945#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
946// NOTE: These are not yet standardized, but are required to simulate the
947// implicit deduction guide that should be generated had libc++ declared the
948// tuple-like constructors "correctly"
949template <class _Alloc, class ..._Args>
950tuple(allocator_arg_t, const _Alloc&, tuple<_Args...> const&) -> tuple<_Args...>;
951template <class _Alloc, class ..._Args>
952tuple(allocator_arg_t, const _Alloc&, tuple<_Args...>&&) -> tuple<_Args...>;
953#endif
954
955template <class ..._Tp>
956inline _LIBCPP_INLINE_VISIBILITY
957typename enable_if
958<
959 __all<__is_swappable<_Tp>::value...>::value,
960 void
961>::type
962swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
963 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
964 {__t.swap(__u);}
965
966// get
967
968template <size_t _Ip, class ..._Tp>
969inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
970typename tuple_element<_Ip, tuple<_Tp...> >::type&
971get(tuple<_Tp...>& __t) _NOEXCEPT
972{
973 typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
974 return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
975}
976
977template <size_t _Ip, class ..._Tp>
978inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
979const typename tuple_element<_Ip, tuple<_Tp...> >::type&
980get(const tuple<_Tp...>& __t) _NOEXCEPT
981{
982 typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
983 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
984}
985
986template <size_t _Ip, class ..._Tp>
987inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
988typename tuple_element<_Ip, tuple<_Tp...> >::type&&
989get(tuple<_Tp...>&& __t) _NOEXCEPT
990{
991 typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
992 return static_cast<type&&>(
993 static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
994}
995
996template <size_t _Ip, class ..._Tp>
997inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
998const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
999get(const tuple<_Tp...>&& __t) _NOEXCEPT
1000{
1001 typedef _LIBCPP_NODEBUG_TYPE typename tuple_element<_Ip, tuple<_Tp...> >::type type;
1002 return static_cast<const type&&>(
1003 static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
1004}
1005
1006#if _LIBCPP_STD_VER > 11
1007
1008namespace __find_detail {
1009
1010static constexpr size_t __not_found = -1;
1011static constexpr size_t __ambiguous = __not_found - 1;
1012
1013inline _LIBCPP_INLINE_VISIBILITY
1014constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
1015 return !__matches ? __res :
1016 (__res == __not_found ? __curr_i : __ambiguous);
1017}
1018
1019template <size_t _Nx>
1020inline _LIBCPP_INLINE_VISIBILITY
1021constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
1022 return __i == _Nx ? __not_found :
1023 __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
1024}
1025
1026template <class _T1, class ..._Args>
1027struct __find_exactly_one_checked {
1028 static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
1029 static constexpr size_t value = __find_detail::__find_idx(0, __matches);
1030 static_assert(value != __not_found, "type not found in type list" );
1031 static_assert(value != __ambiguous, "type occurs more than once in type list");
1032};
1033
1034template <class _T1>
1035struct __find_exactly_one_checked<_T1> {
1036 static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
1037};
1038
1039} // namespace __find_detail;
1040
1041template <typename _T1, typename... _Args>
1042struct __find_exactly_one_t
1043 : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
1044};
1045
1046template <class _T1, class... _Args>
1047inline _LIBCPP_INLINE_VISIBILITY
1048constexpr _T1& get(tuple<_Args...>& __tup) noexcept
1049{
1050 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1051}
1052
1053template <class _T1, class... _Args>
1054inline _LIBCPP_INLINE_VISIBILITY
1055constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
1056{
1057 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1058}
1059
1060template <class _T1, class... _Args>
1061inline _LIBCPP_INLINE_VISIBILITY
1062constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
1063{
1064 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
1065}
1066
1067template <class _T1, class... _Args>
1068inline _LIBCPP_INLINE_VISIBILITY
1069constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
1070{
1071 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
1072}
1073
1074#endif
1075
1076// tie
1077
1078template <class ..._Tp>
1079inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1080tuple<_Tp&...>
1081tie(_Tp&... __t) _NOEXCEPT
1082{
1083 return tuple<_Tp&...>(__t...);
1084}
1085
1086template <class _Up>
1087struct __ignore_t
1088{
1089 template <class _Tp>
1090 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1091 const __ignore_t& operator=(_Tp&&) const {return *this;}
1092};
1093
1094namespace {
1095 _LIBCPP_INLINE_VAR constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
1096}
1097
1098template <class... _Tp>
1099inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1100tuple<typename __unwrap_ref_decay<_Tp>::type...>
1101make_tuple(_Tp&&... __t)
1102{
1103 return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
1104}
1105
1106template <class... _Tp>
1107inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1108tuple<_Tp&&...>
1109forward_as_tuple(_Tp&&... __t) _NOEXCEPT
1110{
1111 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
1112}
1113
1114template <size_t _Ip>
1115struct __tuple_equal
1116{
1117 template <class _Tp, class _Up>
1118 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1119 bool operator()(const _Tp& __x, const _Up& __y)
1120 {
1121 return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
1122 }
1123};
1124
1125template <>
1126struct __tuple_equal<0>
1127{
1128 template <class _Tp, class _Up>
1129 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1130 bool operator()(const _Tp&, const _Up&)
1131 {
1132 return true;
1133 }
1134};
1135
1136template <class ..._Tp, class ..._Up>
1137inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1138bool
1139operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1140{
1141 static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
1142 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
1143}
1144
1145template <class ..._Tp, class ..._Up>
1146inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1147bool
1148operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1149{
1150 return !(__x == __y);
1151}
1152
1153template <size_t _Ip>
1154struct __tuple_less
1155{
1156 template <class _Tp, class _Up>
1157 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1158 bool operator()(const _Tp& __x, const _Up& __y)
1159 {
1160 const size_t __idx = tuple_size<_Tp>::value - _Ip;
1161 if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
1162 return true;
1163 if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
1164 return false;
1165 return __tuple_less<_Ip-1>()(__x, __y);
1166 }
1167};
1168
1169template <>
1170struct __tuple_less<0>
1171{
1172 template <class _Tp, class _Up>
1173 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1174 bool operator()(const _Tp&, const _Up&)
1175 {
1176 return false;
1177 }
1178};
1179
1180template <class ..._Tp, class ..._Up>
1181inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1182bool
1183operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1184{
1185 static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
1186 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
1187}
1188
1189template <class ..._Tp, class ..._Up>
1190inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1191bool
1192operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1193{
1194 return __y < __x;
1195}
1196
1197template <class ..._Tp, class ..._Up>
1198inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1199bool
1200operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1201{
1202 return !(__x < __y);
1203}
1204
1205template <class ..._Tp, class ..._Up>
1206inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1207bool
1208operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1209{
1210 return !(__y < __x);
1211}
1212
1213// tuple_cat
1214
1215template <class _Tp, class _Up> struct __tuple_cat_type;
1216
1217template <class ..._Ttypes, class ..._Utypes>
1218struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
1219{
1220 typedef _LIBCPP_NODEBUG_TYPE tuple<_Ttypes..., _Utypes...> type;
1221};
1222
1223template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
1224struct __tuple_cat_return_1
1225{
1226};
1227
1228template <class ..._Types, class _Tuple0>
1229struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
1230{
1231 typedef _LIBCPP_NODEBUG_TYPE typename __tuple_cat_type<tuple<_Types...>,
1232 typename __make_tuple_types<typename __uncvref<_Tuple0>::type>::type>::type
1233 type;
1234};
1235
1236template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
1237struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1238 : public __tuple_cat_return_1<
1239 typename __tuple_cat_type<
1240 tuple<_Types...>,
1241 typename __make_tuple_types<typename __uncvref<_Tuple0>::type>::type
1242 >::type,
1243 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
1244 _Tuple1, _Tuples...>
1245{
1246};
1247
1248template <class ..._Tuples> struct __tuple_cat_return;
1249
1250template <class _Tuple0, class ..._Tuples>
1251struct __tuple_cat_return<_Tuple0, _Tuples...>
1252 : public __tuple_cat_return_1<tuple<>,
1253 __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
1254 _Tuples...>
1255{
1256};
1257
1258template <>
1259struct __tuple_cat_return<>
1260{
1261 typedef _LIBCPP_NODEBUG_TYPE tuple<> type;
1262};
1263
1264inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1265tuple<>
1266tuple_cat()
1267{
1268 return tuple<>();
1269}
1270
1271template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
1272struct __tuple_cat_return_ref_imp;
1273
1274template <class ..._Types, size_t ..._I0, class _Tuple0>
1275struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
1276{
1277 typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
1278 typedef tuple<_Types..., typename __apply_cv<_Tuple0,
1279 typename tuple_element<_I0, _T0>::type>::type&&...> type;
1280};
1281
1282template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
1283struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
1284 _Tuple0, _Tuple1, _Tuples...>
1285 : public __tuple_cat_return_ref_imp<
1286 tuple<_Types..., typename __apply_cv<_Tuple0,
1287 typename tuple_element<_I0,
1288 typename remove_reference<_Tuple0>::type>::type>::type&&...>,
1289 typename __make_tuple_indices<tuple_size<typename
1290 remove_reference<_Tuple1>::type>::value>::type,
1291 _Tuple1, _Tuples...>
1292{
1293};
1294
1295template <class _Tuple0, class ..._Tuples>
1296struct __tuple_cat_return_ref
1297 : public __tuple_cat_return_ref_imp<tuple<>,
1298 typename __make_tuple_indices<
1299 tuple_size<typename remove_reference<_Tuple0>::type>::value
1300 >::type, _Tuple0, _Tuples...>
1301{
1302};
1303
1304template <class _Types, class _I0, class _J0>
1305struct __tuple_cat;
1306
1307template <class ..._Types, size_t ..._I0, size_t ..._J0>
1308struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
1309{
1310 template <class _Tuple0>
1311 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1312 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1313 operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1314 {
1315 return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1316 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
1317 }
1318
1319 template <class _Tuple0, class _Tuple1, class ..._Tuples>
1320 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1321 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1322 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1323 {
1324 typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
1325 typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple1>::type _T1;
1326 return __tuple_cat<
1327 tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1328 typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1329 typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
1330 (forward_as_tuple(
1331 _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1332 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
1333 ),
1334 _VSTD::forward<_Tuple1>(__t1),
1335 _VSTD::forward<_Tuples>(__tpls)...);
1336 }
1337};
1338
1339template <class _Tuple0, class... _Tuples>
1340inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1341typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1342tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1343{
1344 typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
1345 return __tuple_cat<tuple<>, __tuple_indices<>,
1346 typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
1347 (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1348 _VSTD::forward<_Tuples>(__tpls)...);
1349}
1350
1351template <class ..._Tp, class _Alloc>
1352struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
1353 : true_type {};
1354
1355template <class _T1, class _T2>
1356template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
1357inline _LIBCPP_INLINE_VISIBILITY
1358pair<_T1, _T2>::pair(piecewise_construct_t,
1359 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1360 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
1361 : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
1362 second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
1363{
1364}
1365
1366#if _LIBCPP_STD_VER > 14
1367template <class _Tp>
1368_LIBCPP_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1369
1370#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
1371
1372template <class _Fn, class _Tuple, size_t ..._Id>
1373inline _LIBCPP_INLINE_VISIBILITY
1374constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
1375 __tuple_indices<_Id...>)
1376_LIBCPP_NOEXCEPT_RETURN(
1377 _VSTD::__invoke_constexpr(
1378 _VSTD::forward<_Fn>(__f),
1379 _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
1380)
1381
1382template <class _Fn, class _Tuple>
1383inline _LIBCPP_INLINE_VISIBILITY
1384constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
1385_LIBCPP_NOEXCEPT_RETURN(
1386 _VSTD::__apply_tuple_impl(
1387 _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
1388 typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
1389)
1390
1391template <class _Tp, class _Tuple, size_t... _Idx>
1392inline _LIBCPP_INLINE_VISIBILITY
1393constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
1394_LIBCPP_NOEXCEPT_RETURN(
1395 _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
1396)
1397
1398template <class _Tp, class _Tuple>
1399inline _LIBCPP_INLINE_VISIBILITY
1400constexpr _Tp make_from_tuple(_Tuple&& __t)
1401_LIBCPP_NOEXCEPT_RETURN(
1402 _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
1403 typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
1404)
1405
1406#undef _LIBCPP_NOEXCEPT_RETURN
1407
1408#endif // _LIBCPP_STD_VER > 14
1409
1410#endif // !defined(_LIBCPP_CXX03_LANG)
1411
1412_LIBCPP_END_NAMESPACE_STD
1413
1414#endif // _LIBCPP_TUPLE
1415