tuple revision 227825 
1// -*- C++ -*-
2//===--------------------------- tuple ------------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is distributed under the University of Illinois Open Source
7// License. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_TUPLE
12#define _LIBCPP_TUPLE
13
14/*
15    tuple synopsis
16
17namespace std
18{
19
20template <class... T>
21class tuple {
22public:
23    constexpr tuple();
24    explicit tuple(const T&...);
25    template <class... U>
26        explicit tuple(U&&...);
27    tuple(const tuple&) = default;
28    tuple(tuple&&) = default;
29    template <class... U>
30        tuple(const tuple<U...>&);
31    template <class... U>
32        tuple(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
37
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>&&);
57
58    tuple& operator=(const tuple&);
59    tuple&
60        operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
61    template <class... U>
62        tuple& operator=(const tuple<U...>&);
63    template <class... 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
69
70    void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
71};
72
73const unspecified ignore;
74
75template <class... T> tuple<V...>  make_tuple(T&&...);
76template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
77template <class... T> tuple<T&...> tie(T&...) noexcept;
78template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
79  
80// 20.4.1.4, tuple helper classes:
81template <class T> class tuple_size; // undefined
82template <class... T> class tuple_size<tuple<T...>>;
83template <intsize_t I, class T> class tuple_element; // undefined
84template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>;
85
86// 20.4.1.5, element access:
87template <intsize_t I, class... T>
88    typename tuple_element<I, tuple<T...>>::type&
89    get(tuple<T...>&) noexcept;
90template <intsize_t I, class... T>
91    typename tuple_element<I, tuple<T...>>::type const&
92    get(const tuple<T...>&) noexcept;
93template <intsize_t I, class... T>
94    typename tuple_element<I, tuple<T...>>::type&&
95    get(tuple<T...>&&) noexcept;
96
97// 20.4.1.6, relational operators:
98template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
99template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
100template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
101template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
102template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
103template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
104
105template <class... Types, class Alloc>
106  struct uses_allocator<tuple<Types...>, Alloc>;
107
108template <class... Types>
109  void
110  swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
111
112}  // std
113
114*/
115
116#include <__config>
117#include <__tuple>
118#include <cstddef>
119#include <memory>
120#include <type_traits>
121
122#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
123#pragma GCC system_header
124#endif
125
126_LIBCPP_BEGIN_NAMESPACE_STD
127
128#ifndef _LIBCPP_HAS_NO_VARIADICS
129
130// tuple_size
131
132template <class ..._Tp>
133class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
134    : public integral_constant<size_t, sizeof...(_Tp)>
135{
136};
137
138// tuple_element
139
140template <size_t _Ip, class ..._Tp>
141class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> >
142{
143public:
144    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
145};
146
147// __tuple_leaf
148
149template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value>
150class __tuple_leaf;
151
152template <size_t _Ip, class _Hp, bool _Ep>
153inline _LIBCPP_INLINE_VISIBILITY
154void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
155    _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
156{
157    swap(__x.get(), __y.get());
158}
159
160template <size_t _Ip, class _Hp, bool>
161class __tuple_leaf
162{
163    _Hp value;
164
165    __tuple_leaf& operator=(const __tuple_leaf&);
166public:
167    _LIBCPP_INLINE_VISIBILITY __tuple_leaf() : value()
168       {static_assert(!is_reference<_Hp>::value,
169              "Attempted to default construct a reference element in a tuple");}
170
171    template <class _Alloc>
172        _LIBCPP_INLINE_VISIBILITY
173        __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
174            : value()
175        {static_assert(!is_reference<_Hp>::value,
176              "Attempted to default construct a reference element in a tuple");}
177
178    template <class _Alloc>
179        _LIBCPP_INLINE_VISIBILITY
180        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
181            : value(allocator_arg_t(), __a)
182        {static_assert(!is_reference<_Hp>::value,
183              "Attempted to default construct a reference element in a tuple");}
184
185    template <class _Alloc>
186        _LIBCPP_INLINE_VISIBILITY
187        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
188            : value(__a)
189        {static_assert(!is_reference<_Hp>::value,
190              "Attempted to default construct a reference element in a tuple");}
191
192    template <class _Tp,
193              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
194        _LIBCPP_INLINE_VISIBILITY
195        explicit __tuple_leaf(_Tp&& __t)
196            : value(_VSTD::forward<_Tp>(__t))
197        {static_assert(!is_reference<_Hp>::value ||
198                        is_lvalue_reference<_Hp>::value &&
199                        (is_lvalue_reference<_Tp>::value ||
200                         is_same<typename remove_reference<_Tp>::type,
201                                 reference_wrapper<
202                                    typename remove_reference<_Hp>::type
203                                 >
204                                >::value) ||
205                        (is_rvalue_reference<_Hp>::value &&
206                         !is_lvalue_reference<_Tp>::value),
207       "Attempted to construct a reference element in a tuple with an rvalue");}
208
209    template <class _Tp, class _Alloc>
210        _LIBCPP_INLINE_VISIBILITY
211        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
212            : value(_VSTD::forward<_Tp>(__t))
213        {static_assert(!is_lvalue_reference<_Hp>::value ||
214                        is_lvalue_reference<_Hp>::value &&
215                        (is_lvalue_reference<_Tp>::value ||
216                         is_same<typename remove_reference<_Tp>::type,
217                                 reference_wrapper<
218                                    typename remove_reference<_Hp>::type
219                                 >
220                                >::value),
221       "Attempted to construct a reference element in a tuple with an rvalue");}
222
223    template <class _Tp, class _Alloc>
224        _LIBCPP_INLINE_VISIBILITY
225        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
226            : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
227        {static_assert(!is_lvalue_reference<_Hp>::value ||
228                        is_lvalue_reference<_Hp>::value &&
229                        (is_lvalue_reference<_Tp>::value ||
230                         is_same<typename remove_reference<_Tp>::type,
231                                 reference_wrapper<
232                                    typename remove_reference<_Hp>::type
233                                 >
234                                >::value),
235       "Attempted to construct a reference element in a tuple with an rvalue");}
236
237    template <class _Tp, class _Alloc>
238        _LIBCPP_INLINE_VISIBILITY
239        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
240            : value(_VSTD::forward<_Tp>(__t), __a)
241        {static_assert(!is_lvalue_reference<_Hp>::value ||
242                        is_lvalue_reference<_Hp>::value &&
243                        (is_lvalue_reference<_Tp>::value ||
244                         is_same<typename remove_reference<_Tp>::type,
245                                 reference_wrapper<
246                                    typename remove_reference<_Hp>::type
247                                 >
248                                >::value),
249       "Attempted to construct a reference element in a tuple with an rvalue");}
250
251    __tuple_leaf(const __tuple_leaf& __t)
252        : value(__t.get())
253        {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
254
255    template <class _Tp>
256        _LIBCPP_INLINE_VISIBILITY
257        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
258            : value(__t.get()) {}
259
260    template <class _Tp>
261        _LIBCPP_INLINE_VISIBILITY
262        __tuple_leaf&
263        operator=(_Tp&& __t)
264        {
265            value = _VSTD::forward<_Tp>(__t);
266            return *this;
267        }
268
269    _LIBCPP_INLINE_VISIBILITY
270    int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
271    {
272        _VSTD::swap(*this, __t);
273        return 0;
274    }
275
276    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       {return value;}
277    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return value;}
278};
279
280template <size_t _Ip, class _Hp>
281class __tuple_leaf<_Ip, _Hp, true>
282    : private _Hp
283{
284
285    __tuple_leaf& operator=(const __tuple_leaf&);
286public:
287    _LIBCPP_INLINE_VISIBILITY __tuple_leaf() {}
288
289    template <class _Alloc>
290        _LIBCPP_INLINE_VISIBILITY
291        __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
292
293    template <class _Alloc>
294        _LIBCPP_INLINE_VISIBILITY
295        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
296            : _Hp(allocator_arg_t(), __a) {}
297
298    template <class _Alloc>
299        _LIBCPP_INLINE_VISIBILITY
300        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
301            : _Hp(__a) {}
302
303    template <class _Tp,
304              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
305        _LIBCPP_INLINE_VISIBILITY
306        explicit __tuple_leaf(_Tp&& __t)
307            : _Hp(_VSTD::forward<_Tp>(__t)) {}
308
309    template <class _Tp, class _Alloc>
310        _LIBCPP_INLINE_VISIBILITY
311        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
312            : _Hp(_VSTD::forward<_Tp>(__t)) {}
313
314    template <class _Tp, class _Alloc>
315        _LIBCPP_INLINE_VISIBILITY
316        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
317            : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
318
319    template <class _Tp, class _Alloc>
320        _LIBCPP_INLINE_VISIBILITY
321        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
322            : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
323
324    template <class _Tp>
325        _LIBCPP_INLINE_VISIBILITY
326        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
327            : _Hp(__t.get()) {}
328
329    template <class _Tp>
330        _LIBCPP_INLINE_VISIBILITY
331        __tuple_leaf&
332        operator=(_Tp&& __t)
333        {
334            _Hp::operator=(_VSTD::forward<_Tp>(__t));
335            return *this;
336        }
337
338    _LIBCPP_INLINE_VISIBILITY
339    int
340    swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
341    {
342        _VSTD::swap(*this, __t);
343        return 0;
344    }
345
346    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       {return static_cast<_Hp&>(*this);}
347    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast<const _Hp&>(*this);}
348};
349
350template <class ..._Tp>
351_LIBCPP_INLINE_VISIBILITY
352void __swallow(_Tp&&...) {}
353
354template <bool ...> struct __all;
355
356template <>
357struct __all<>
358{
359    static const bool value = true;
360};
361
362template <bool _B0, bool ... _B>
363struct __all<_B0, _B...>
364{
365    static const bool value = _B0 && __all<_B...>::value;
366};
367
368// __tuple_impl
369
370template<class _Indx, class ..._Tp> struct __tuple_impl;
371
372template<size_t ..._Indx, class ..._Tp>
373struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
374    : public __tuple_leaf<_Indx, _Tp>...
375{
376    template <size_t ..._Uf, class ..._Tf,
377              size_t ..._Ul, class ..._Tl, class ..._Up>
378        _LIBCPP_INLINE_VISIBILITY
379        explicit
380        __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
381                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
382                     _Up&&... __u) :
383            __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
384            __tuple_leaf<_Ul, _Tl>()...
385            {}
386
387    template <class _Alloc, size_t ..._Uf, class ..._Tf,
388              size_t ..._Ul, class ..._Tl, class ..._Up>
389        _LIBCPP_INLINE_VISIBILITY
390        explicit
391        __tuple_impl(allocator_arg_t, const _Alloc& __a,
392                     __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
393                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
394                     _Up&&... __u) :
395            __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
396            _VSTD::forward<_Up>(__u))...,
397            __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
398            {}
399
400    template <class _Tuple,
401              class = typename enable_if
402                      <
403                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
404                      >::type
405             >
406        _LIBCPP_INLINE_VISIBILITY
407        __tuple_impl(_Tuple&& __t)
408            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
409                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
410            {}
411
412    template <class _Alloc, class _Tuple,
413              class = typename enable_if
414                      <
415                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
416                      >::type
417             >
418        _LIBCPP_INLINE_VISIBILITY
419        __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
420            : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
421                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a,
422                                       _VSTD::forward<typename tuple_element<_Indx,
423                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
424            {}
425
426    template <class _Tuple>
427        _LIBCPP_INLINE_VISIBILITY
428        typename enable_if
429        <
430            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
431            __tuple_impl&
432        >::type
433        operator=(_Tuple&& __t)
434        {
435            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
436                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
437            return *this;
438        }
439
440    _LIBCPP_INLINE_VISIBILITY
441    void swap(__tuple_impl& __t)
442        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
443    {
444        __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
445    }
446};
447
448template <class ..._Tp>
449class _LIBCPP_VISIBLE tuple
450{
451    typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
452
453    base base_;
454
455    template <size_t _Jp, class ..._Up> friend
456        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&);
457    template <size_t _Jp, class ..._Up> friend
458        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&);
459    template <size_t _Jp, class ..._Up> friend
460        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&);
461public:
462
463    _LIBCPP_INLINE_VISIBILITY
464    explicit tuple(const _Tp& ... __t)
465        : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
466                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
467                typename __make_tuple_indices<0>::type(),
468                typename __make_tuple_types<tuple, 0>::type(),
469                __t...
470               ) {}
471
472    template <class _Alloc>
473      _LIBCPP_INLINE_VISIBILITY
474      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
475        : base_(allocator_arg_t(), __a,
476                typename __make_tuple_indices<sizeof...(_Tp)>::type(),
477                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
478                typename __make_tuple_indices<0>::type(),
479                typename __make_tuple_types<tuple, 0>::type(),
480                __t...
481               ) {}
482
483    template <class ..._Up,
484              class = typename enable_if
485                      <
486                         sizeof...(_Up) <= sizeof...(_Tp) &&
487                         __tuple_convertible
488                         <
489                            tuple<_Up...>,
490                            typename __make_tuple_types<tuple,
491                                     sizeof...(_Up) < sizeof...(_Tp) ?
492                                        sizeof...(_Up) :
493                                        sizeof...(_Tp)>::type
494                         >::value
495                      >::type
496             >
497        _LIBCPP_INLINE_VISIBILITY
498        explicit
499        tuple(_Up&&... __u)
500            : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
501                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
502                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
503                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
504                    _VSTD::forward<_Up>(__u)...) {}
505
506    template <class _Alloc, class ..._Up,
507              class = typename enable_if
508                      <
509                         sizeof...(_Up) <= sizeof...(_Tp) &&
510                         __tuple_convertible
511                         <
512                            tuple<_Up...>,
513                            typename __make_tuple_types<tuple,
514                                     sizeof...(_Up) < sizeof...(_Tp) ?
515                                        sizeof...(_Up) :
516                                        sizeof...(_Tp)>::type
517                         >::value
518                      >::type
519             >
520        _LIBCPP_INLINE_VISIBILITY
521        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
522            : base_(allocator_arg_t(), __a,
523                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
524                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
525                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
526                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
527                    _VSTD::forward<_Up>(__u)...) {}
528
529    template <class _Tuple,
530              class = typename enable_if
531                      <
532                         __tuple_convertible<_Tuple, tuple>::value
533                      >::type
534             >
535        _LIBCPP_INLINE_VISIBILITY
536        tuple(_Tuple&& __t)
537            : base_(_VSTD::forward<_Tuple>(__t)) {}
538
539    template <class _Alloc, class _Tuple,
540              class = typename enable_if
541                      <
542                         __tuple_convertible<_Tuple, tuple>::value
543                      >::type
544             >
545        _LIBCPP_INLINE_VISIBILITY
546        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
547            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
548
549    template <class _Tuple,
550              class = typename enable_if
551                      <
552                         __tuple_assignable<_Tuple, tuple>::value
553                      >::type
554             >
555        _LIBCPP_INLINE_VISIBILITY
556        tuple&
557        operator=(_Tuple&& __t)
558        {
559            base_.operator=(_VSTD::forward<_Tuple>(__t));
560            return *this;
561        }
562
563    _LIBCPP_INLINE_VISIBILITY
564    void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
565        {base_.swap(__t.base_);}
566};
567
568template <>
569class _LIBCPP_VISIBLE tuple<>
570{
571public:
572    _LIBCPP_INLINE_VISIBILITY
573    tuple() {}
574    template <class _Alloc>
575    _LIBCPP_INLINE_VISIBILITY
576        tuple(allocator_arg_t, const _Alloc&) {}
577    template <class _Alloc>
578    _LIBCPP_INLINE_VISIBILITY
579        tuple(allocator_arg_t, const _Alloc&, const tuple&) {}
580    template <class _U>
581    _LIBCPP_INLINE_VISIBILITY
582        tuple(array<_U, 0>) {}
583    template <class _Alloc, class _U>
584    _LIBCPP_INLINE_VISIBILITY
585        tuple(allocator_arg_t, const _Alloc&, array<_U, 0>) {}
586    _LIBCPP_INLINE_VISIBILITY
587    void swap(tuple&) _NOEXCEPT {}
588};
589
590template <class ..._Tp>
591inline _LIBCPP_INLINE_VISIBILITY
592typename enable_if
593<
594    __all<__is_swappable<_Tp>::value...>::value,
595    void
596>::type
597swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
598                 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
599    {__t.swap(__u);}
600
601// get
602
603template <size_t _Ip, class ..._Tp>
604inline _LIBCPP_INLINE_VISIBILITY
605typename tuple_element<_Ip, tuple<_Tp...> >::type&
606get(tuple<_Tp...>& __t)
607{
608    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
609    return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
610}
611
612template <size_t _Ip, class ..._Tp>
613inline _LIBCPP_INLINE_VISIBILITY
614const typename tuple_element<_Ip, tuple<_Tp...> >::type&
615get(const tuple<_Tp...>& __t)
616{
617    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
618    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
619}
620
621template <size_t _Ip, class ..._Tp>
622inline _LIBCPP_INLINE_VISIBILITY
623typename tuple_element<_Ip, tuple<_Tp...> >::type&&
624get(tuple<_Tp...>&& __t)
625{
626    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
627    return static_cast<type&&>(
628             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
629}
630
631// tie
632
633template <class ..._Tp>
634inline _LIBCPP_INLINE_VISIBILITY
635tuple<_Tp&...>
636tie(_Tp&... __t)
637{
638    return tuple<_Tp&...>(__t...);
639}
640
641template <class _Up>
642struct __ignore_t
643{
644    template <class _Tp>
645        _LIBCPP_INLINE_VISIBILITY
646        const __ignore_t& operator=(_Tp&&) const {return *this;}
647};
648
649namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
650
651template <class _Tp> class reference_wrapper;
652
653template <class _Tp>
654struct ___make_tuple_return
655{
656    typedef _Tp type;
657};
658
659template <class _Tp>
660struct ___make_tuple_return<reference_wrapper<_Tp> >
661{
662    typedef _Tp& type;
663};
664
665template <class _Tp>
666struct __make_tuple_return
667{
668    typedef typename ___make_tuple_return<typename decay<_Tp>::type>::type type;
669};
670
671template <class... _Tp>
672inline _LIBCPP_INLINE_VISIBILITY
673tuple<typename __make_tuple_return<_Tp>::type...>
674make_tuple(_Tp&&... __t)
675{
676    return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
677}
678
679template <class... _Tp>
680inline _LIBCPP_INLINE_VISIBILITY
681tuple<_Tp&&...>
682forward_as_tuple(_Tp&&... __t)
683{
684    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
685}
686
687template <size_t _I>
688struct __tuple_equal
689{
690    template <class _Tp, class _Up>
691    _LIBCPP_INLINE_VISIBILITY
692    bool operator()(const _Tp& __x, const _Up& __y)
693    {
694        return __tuple_equal<_I - 1>()(__x, __y) && get<_I-1>(__x) == get<_I-1>(__y);
695    }
696};
697
698template <>
699struct __tuple_equal<0>
700{
701    template <class _Tp, class _Up>
702    _LIBCPP_INLINE_VISIBILITY
703    bool operator()(const _Tp&, const _Up&)
704    {
705        return true;
706    }
707};
708
709template <class ..._Tp, class ..._Up>
710inline _LIBCPP_INLINE_VISIBILITY
711bool
712operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
713{
714    return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
715}
716
717template <class ..._Tp, class ..._Up>
718inline _LIBCPP_INLINE_VISIBILITY
719bool
720operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
721{
722    return !(__x == __y);
723}
724
725template <size_t _I>
726struct __tuple_less
727{
728    template <class _Tp, class _Up>
729    _LIBCPP_INLINE_VISIBILITY
730    bool operator()(const _Tp& __x, const _Up& __y)
731    {
732        return __tuple_less<_I-1>()(__x, __y) ||
733             (!__tuple_less<_I-1>()(__y, __x) && get<_I-1>(__x) < get<_I-1>(__y));
734    }
735};
736
737template <>
738struct __tuple_less<0>
739{
740    template <class _Tp, class _Up>
741    _LIBCPP_INLINE_VISIBILITY
742    bool operator()(const _Tp&, const _Up&)
743    {
744        return false;
745    }
746};
747
748template <class ..._Tp, class ..._Up>
749inline _LIBCPP_INLINE_VISIBILITY
750bool
751operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
752{
753    return __tuple_less<sizeof...(_Tp)>()(__x, __y);
754}
755
756template <class ..._Tp, class ..._Up>
757inline _LIBCPP_INLINE_VISIBILITY
758bool
759operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
760{
761    return __y < __x;
762}
763
764template <class ..._Tp, class ..._Up>
765inline _LIBCPP_INLINE_VISIBILITY
766bool
767operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
768{
769    return !(__x < __y);
770}
771
772template <class ..._Tp, class ..._Up>
773inline _LIBCPP_INLINE_VISIBILITY
774bool
775operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
776{
777    return !(__y < __x);
778}
779
780// tuple_cat
781
782template <class _Tp, class _Up> struct __tuple_cat_type;
783
784template <class ..._Ttypes, class ..._Utypes>
785struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
786{
787    typedef tuple<_Ttypes..., _Utypes...> type;
788};
789
790template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
791struct __tuple_cat_return_1
792{
793};
794
795template <class ..._Types, class _Tuple0>
796struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
797{
798    typedef typename __tuple_cat_type<tuple<_Types...>,
799            typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
800                                                                           type;
801};
802
803template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
804struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
805    : public __tuple_cat_return_1<
806                 typename __tuple_cat_type<
807                     tuple<_Types...>,
808                     typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
809                 >::type,
810                 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
811                 _Tuple1, _Tuples...>
812{
813};
814
815template <class ..._Tuples> struct __tuple_cat_return;
816
817template <class _Tuple0, class ..._Tuples>
818struct __tuple_cat_return<_Tuple0, _Tuples...>
819    : public __tuple_cat_return_1<tuple<>,
820         __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
821                                                                     _Tuples...>
822{
823};
824
825template <>
826struct __tuple_cat_return<>
827{
828    typedef tuple<> type;
829};
830
831inline _LIBCPP_INLINE_VISIBILITY
832tuple<>
833tuple_cat()
834{
835    return tuple<>();
836}
837
838template <class _R, class _Indices, class _Tuple0, class ..._Tuples>
839struct __tuple_cat_return_ref_imp;
840
841template <class ..._Types, size_t ..._I0, class _Tuple0>
842struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
843{
844    typedef typename remove_reference<_Tuple0>::type _T0;
845    typedef tuple<_Types..., typename __apply_cv<_Tuple0,
846                          typename tuple_element<_I0, _T0>::type>::type&&...> type;
847};
848
849template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
850struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
851                                  _Tuple0, _Tuple1, _Tuples...>
852    : public __tuple_cat_return_ref_imp<
853         tuple<_Types..., typename __apply_cv<_Tuple0,
854               typename tuple_element<_I0,
855                  typename remove_reference<_Tuple0>::type>::type>::type&&...>,
856         typename __make_tuple_indices<tuple_size<typename
857                                 remove_reference<_Tuple1>::type>::value>::type,
858         _Tuple1, _Tuples...>
859{
860};
861
862template <class _Tuple0, class ..._Tuples>
863struct __tuple_cat_return_ref
864    : public __tuple_cat_return_ref_imp<tuple<>,
865               typename __make_tuple_indices<
866                        tuple_size<typename remove_reference<_Tuple0>::type>::value
867               >::type, _Tuple0, _Tuples...>
868{
869};
870
871template <class _Types, class _I0, class _J0>
872struct __tuple_cat;
873
874template <class ..._Types, size_t ..._I0, size_t ..._J0>
875struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
876{
877    template <class _Tuple0>
878    _LIBCPP_INLINE_VISIBILITY
879    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
880    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
881    {
882        return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
883                                      get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
884    }
885
886    template <class _Tuple0, class _Tuple1, class ..._Tuples>
887    _LIBCPP_INLINE_VISIBILITY
888    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
889    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
890    {
891        typedef typename remove_reference<_Tuple0>::type _T0;
892        typedef typename remove_reference<_Tuple1>::type _T1;
893        return __tuple_cat<
894           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
895           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
896           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
897                           (_VSTD::forward_as_tuple(
898                              _VSTD::forward<_Types>(get<_I0>(__t))...,
899                              get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
900                            ),
901                            _VSTD::forward<_Tuple1>(__t1),
902                            _VSTD::forward<_Tuples>(__tpls)...);
903    }
904};
905
906template <class _Tuple0, class... _Tuples>
907inline _LIBCPP_INLINE_VISIBILITY
908typename __tuple_cat_return<_Tuple0, _Tuples...>::type
909tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
910{
911    typedef typename remove_reference<_Tuple0>::type _T0;
912    return __tuple_cat<tuple<>, __tuple_indices<>,
913                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
914                  (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
915                                            _VSTD::forward<_Tuples>(__tpls)...);
916}
917
918template <class ..._Tp, class _Alloc>
919struct _LIBCPP_VISIBLE uses_allocator<tuple<_Tp...>, _Alloc>
920    : true_type {};
921
922template <class _T1, class _T2>
923template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
924inline _LIBCPP_INLINE_VISIBILITY
925pair<_T1, _T2>::pair(piecewise_construct_t,
926                     tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
927                     __tuple_indices<_I1...>, __tuple_indices<_I2...>)
928    :  first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
929      second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
930{
931}
932
933#endif  // _LIBCPP_HAS_NO_VARIADICS
934
935_LIBCPP_END_NAMESPACE_STD
936
937#endif  // _LIBCPP_TUPLE
938