← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/tuple

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/tuple
 
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
 
 
17
namespace std
 
18
{
 
19
 
 
20
template <class... T>
 
21
class tuple {
 
22
public:
 
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
 
 
73
const unspecified ignore;
 
74
 
 
75
template <class... T> tuple<V...>  make_tuple(T&&...);
 
76
template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
 
77
template <class... T> tuple<T&...> tie(T&...) noexcept;
 
78
template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
 
79
  
 
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
 
 
86
// 20.4.1.5, element access:
 
87
template <intsize_t I, class... T>
 
88
    typename tuple_element<I, tuple<T...>>::type&
 
89
    get(tuple<T...>&) noexcept;
 
90
template <intsize_t I, class... T>
 
91
    typename tuple_element<I, tuple<T...>>::type const&
 
92
    get(const tuple<T...>&) noexcept;
 
93
template <intsize_t I, class... T>
 
94
    typename tuple_element<I, tuple<T...>>::type&&
 
95
    get(tuple<T...>&&) noexcept;
 
96
 
 
97
// 20.4.1.6, relational operators:
 
98
template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
 
99
template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
 
100
template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
 
101
template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
 
102
template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
 
103
template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
 
104
 
 
105
template <class... Types, class Alloc>
 
106
  struct uses_allocator<tuple<Types...>, Alloc>;
 
107
 
 
108
template <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 <type_traits>
 
120
#include <__functional_base>
 
121
#include <utility>
 
122
 
 
123
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 
124
#pragma GCC system_header
 
125
#endif
 
126
 
 
127
_LIBCPP_BEGIN_NAMESPACE_STD
 
128
 
 
129
// allocator_arg_t
 
130
 
 
131
struct _LIBCPP_TYPE_VIS allocator_arg_t { };
 
132
 
 
133
#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
 
134
extern const allocator_arg_t allocator_arg;
 
135
#else
 
136
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 
137
#endif
 
138
 
 
139
// uses_allocator
 
140
 
 
141
template <class _Tp>
 
142
struct __has_allocator_type
 
143
{
 
144
private:
 
145
    struct __two {char __lx; char __lxx;};
 
146
    template <class _Up> static __two __test(...);
 
147
    template <class _Up> static char __test(typename _Up::allocator_type* = 0);
 
148
public:
 
149
    static const bool value = sizeof(__test<_Tp>(0)) == 1;
 
150
};
 
151
 
 
152
template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
 
153
struct __uses_allocator
 
154
    : public integral_constant<bool,
 
155
        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
 
156
{
 
157
};
 
158
 
 
159
template <class _Tp, class _Alloc>
 
160
struct __uses_allocator<_Tp, _Alloc, false>
 
161
    : public false_type
 
162
{
 
163
};
 
164
 
 
165
template <class _Tp, class _Alloc>
 
166
struct _LIBCPP_TYPE_VIS uses_allocator
 
167
    : public __uses_allocator<_Tp, _Alloc>
 
168
{
 
169
};
 
170
 
 
171
#ifndef _LIBCPP_HAS_NO_VARIADICS
 
172
 
 
173
// uses-allocator construction
 
174
 
 
175
template <class _Tp, class _Alloc, class ..._Args>
 
176
struct __uses_alloc_ctor_imp
 
177
{
 
178
    static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
 
179
    static const bool __ic =
 
180
        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
 
181
    static const int value = __ua ? 2 - __ic : 0;
 
182
};
 
183
 
 
184
template <class _Tp, class _Alloc, class ..._Args>
 
185
struct __uses_alloc_ctor
 
186
    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
 
187
    {};
 
188
 
 
189
#endif  // _LIBCPP_HAS_NO_VARIADICS
 
190
 
 
191
#ifndef _LIBCPP_HAS_NO_VARIADICS
 
192
 
 
193
// tuple_size
 
194
 
 
195
template <class ..._Tp>
 
196
class _LIBCPP_TYPE_VIS tuple_size<tuple<_Tp...> >
 
197
    : public integral_constant<size_t, sizeof...(_Tp)>
 
198
{
 
199
};
 
200
 
 
201
// tuple_element
 
202
 
 
203
template <size_t _Ip, class ..._Tp>
 
204
class _LIBCPP_TYPE_VIS tuple_element<_Ip, tuple<_Tp...> >
 
205
{
 
206
public:
 
207
    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
 
208
};
 
209
 
 
210
// __tuple_leaf
 
211
 
 
212
template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value
 
213
#if __has_feature(is_final)
 
214
                                 && !__is_final(_Hp)
 
215
#endif
 
216
         >
 
217
class __tuple_leaf;
 
218
 
 
219
template <size_t _Ip, class _Hp, bool _Ep>
 
220
inline _LIBCPP_INLINE_VISIBILITY
 
221
void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
 
222
    _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 
223
{
 
224
    swap(__x.get(), __y.get());
 
225
}
 
226
 
 
227
template <size_t _Ip, class _Hp, bool>
 
228
class __tuple_leaf
 
229
{
 
230
    _Hp value;
 
231
 
 
232
    __tuple_leaf& operator=(const __tuple_leaf&);
 
233
public:
 
234
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
 
235
             _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value()
 
236
       {static_assert(!is_reference<_Hp>::value,
 
237
              "Attempted to default construct a reference element in a tuple");}
 
238
 
 
239
    template <class _Alloc>
 
240
        _LIBCPP_INLINE_VISIBILITY
 
241
        __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
 
242
            : value()
 
243
        {static_assert(!is_reference<_Hp>::value,
 
244
              "Attempted to default construct a reference element in a tuple");}
 
245
 
 
246
    template <class _Alloc>
 
247
        _LIBCPP_INLINE_VISIBILITY
 
248
        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
 
249
            : value(allocator_arg_t(), __a)
 
250
        {static_assert(!is_reference<_Hp>::value,
 
251
              "Attempted to default construct a reference element in a tuple");}
 
252
 
 
253
    template <class _Alloc>
 
254
        _LIBCPP_INLINE_VISIBILITY
 
255
        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
 
256
            : value(__a)
 
257
        {static_assert(!is_reference<_Hp>::value,
 
258
              "Attempted to default construct a reference element in a tuple");}
 
259
 
 
260
    template <class _Tp,
 
261
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
 
262
        _LIBCPP_INLINE_VISIBILITY
 
263
        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
 
264
            : value(_VSTD::forward<_Tp>(__t))
 
265
        {static_assert(!is_reference<_Hp>::value ||
 
266
                       (is_lvalue_reference<_Hp>::value &&
 
267
                        (is_lvalue_reference<_Tp>::value ||
 
268
                         is_same<typename remove_reference<_Tp>::type,
 
269
                                 reference_wrapper<
 
270
                                    typename remove_reference<_Hp>::type
 
271
                                 >
 
272
                                >::value)) ||
 
273
                        (is_rvalue_reference<_Hp>::value &&
 
274
                         !is_lvalue_reference<_Tp>::value),
 
275
       "Attempted to construct a reference element in a tuple with an rvalue");}
 
276
 
 
277
    template <class _Tp, class _Alloc>
 
278
        _LIBCPP_INLINE_VISIBILITY
 
279
        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
 
280
            : value(_VSTD::forward<_Tp>(__t))
 
281
        {static_assert(!is_lvalue_reference<_Hp>::value ||
 
282
                       (is_lvalue_reference<_Hp>::value &&
 
283
                        (is_lvalue_reference<_Tp>::value ||
 
284
                         is_same<typename remove_reference<_Tp>::type,
 
285
                                 reference_wrapper<
 
286
                                    typename remove_reference<_Hp>::type
 
287
                                 >
 
288
                                >::value)),
 
289
       "Attempted to construct a reference element in a tuple with an rvalue");}
 
290
 
 
291
    template <class _Tp, class _Alloc>
 
292
        _LIBCPP_INLINE_VISIBILITY
 
293
        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
 
294
            : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
 
295
        {static_assert(!is_lvalue_reference<_Hp>::value ||
 
296
                       (is_lvalue_reference<_Hp>::value &&
 
297
                        (is_lvalue_reference<_Tp>::value ||
 
298
                         is_same<typename remove_reference<_Tp>::type,
 
299
                                 reference_wrapper<
 
300
                                    typename remove_reference<_Hp>::type
 
301
                                 >
 
302
                                >::value)),
 
303
       "Attempted to construct a reference element in a tuple with an rvalue");}
 
304
 
 
305
    template <class _Tp, class _Alloc>
 
306
        _LIBCPP_INLINE_VISIBILITY
 
307
        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
 
308
            : value(_VSTD::forward<_Tp>(__t), __a)
 
309
        {static_assert(!is_lvalue_reference<_Hp>::value ||
 
310
                       (is_lvalue_reference<_Hp>::value &&
 
311
                        (is_lvalue_reference<_Tp>::value ||
 
312
                         is_same<typename remove_reference<_Tp>::type,
 
313
                                 reference_wrapper<
 
314
                                    typename remove_reference<_Hp>::type
 
315
                                 >
 
316
                                >::value)),
 
317
       "Attempted to construct a reference element in a tuple with an rvalue");}
 
318
 
 
319
    __tuple_leaf(const __tuple_leaf& __t) _NOEXCEPT_(is_nothrow_copy_constructible<_Hp>::value)
 
320
        : value(__t.get())
 
321
        {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
 
322
 
 
323
    template <class _Tp>
 
324
        _LIBCPP_INLINE_VISIBILITY
 
325
        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
 
326
                           _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
 
327
            : value(__t.get()) {}
 
328
 
 
329
    template <class _Tp>
 
330
        _LIBCPP_INLINE_VISIBILITY
 
331
        __tuple_leaf&
 
332
        operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
 
333
        {
 
334
            value = _VSTD::forward<_Tp>(__t);
 
335
            return *this;
 
336
        }
 
337
 
 
338
    _LIBCPP_INLINE_VISIBILITY
 
339
    int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
 
340
    {
 
341
        _VSTD::swap(*this, __t);
 
342
        return 0;
 
343
    }
 
344
 
 
345
    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       _NOEXCEPT {return value;}
 
346
    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return value;}
 
347
};
 
348
 
 
349
template <size_t _Ip, class _Hp>
 
350
class __tuple_leaf<_Ip, _Hp, true>
 
351
    : private _Hp
 
352
{
 
353
 
 
354
    __tuple_leaf& operator=(const __tuple_leaf&);
 
355
public:
 
356
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
 
357
             _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
 
358
 
 
359
    template <class _Alloc>
 
360
        _LIBCPP_INLINE_VISIBILITY
 
361
        __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 
362
 
 
363
    template <class _Alloc>
 
364
        _LIBCPP_INLINE_VISIBILITY
 
365
        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
 
366
            : _Hp(allocator_arg_t(), __a) {}
 
367
 
 
368
    template <class _Alloc>
 
369
        _LIBCPP_INLINE_VISIBILITY
 
370
        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
 
371
            : _Hp(__a) {}
 
372
 
 
373
    template <class _Tp,
 
374
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
 
375
        _LIBCPP_INLINE_VISIBILITY
 
376
        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
 
377
            : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
378
 
 
379
    template <class _Tp, class _Alloc>
 
380
        _LIBCPP_INLINE_VISIBILITY
 
381
        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
 
382
            : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
383
 
 
384
    template <class _Tp, class _Alloc>
 
385
        _LIBCPP_INLINE_VISIBILITY
 
386
        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
 
387
            : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 
388
 
 
389
    template <class _Tp, class _Alloc>
 
390
        _LIBCPP_INLINE_VISIBILITY
 
391
        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
 
392
            : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
393
 
 
394
    template <class _Tp>
 
395
        _LIBCPP_INLINE_VISIBILITY
 
396
        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
 
397
            _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
 
398
            : _Hp(__t.get()) {}
 
399
 
 
400
    template <class _Tp>
 
401
        _LIBCPP_INLINE_VISIBILITY
 
402
        __tuple_leaf&
 
403
        operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
 
404
        {
 
405
            _Hp::operator=(_VSTD::forward<_Tp>(__t));
 
406
            return *this;
 
407
        }
 
408
 
 
409
    _LIBCPP_INLINE_VISIBILITY
 
410
    int
 
411
    swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
 
412
    {
 
413
        _VSTD::swap(*this, __t);
 
414
        return 0;
 
415
    }
 
416
 
 
417
    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
 
418
    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 
419
};
 
420
 
 
421
template <class ..._Tp>
 
422
_LIBCPP_INLINE_VISIBILITY
 
423
void __swallow(_Tp&&...) _NOEXCEPT {}
 
424
 
 
425
template <bool ...> struct __all;
 
426
 
 
427
template <>
 
428
struct __all<>
 
429
{
 
430
    static const bool value = true;
 
431
};
 
432
 
 
433
template <bool _B0, bool ... _Bp>
 
434
struct __all<_B0, _Bp...>
 
435
{
 
436
    static const bool value = _B0 && __all<_Bp...>::value;
 
437
};
 
438
 
 
439
// __tuple_impl
 
440
 
 
441
template<class _Indx, class ..._Tp> struct __tuple_impl;
 
442
 
 
443
template<size_t ..._Indx, class ..._Tp>
 
444
struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
 
445
    : public __tuple_leaf<_Indx, _Tp>...
 
446
{
 
447
    _LIBCPP_INLINE_VISIBILITY
 
448
    _LIBCPP_CONSTEXPR __tuple_impl()
 
449
        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
450
 
 
451
    template <size_t ..._Uf, class ..._Tf,
 
452
              size_t ..._Ul, class ..._Tl, class ..._Up>
 
453
        _LIBCPP_INLINE_VISIBILITY
 
454
        explicit
 
455
        __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
 
456
                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
 
457
                     _Up&&... __u)
 
458
                     _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
 
459
                                 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
 
460
            __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
 
461
            __tuple_leaf<_Ul, _Tl>()...
 
462
            {}
 
463
 
 
464
    template <class _Alloc, size_t ..._Uf, class ..._Tf,
 
465
              size_t ..._Ul, class ..._Tl, class ..._Up>
 
466
        _LIBCPP_INLINE_VISIBILITY
 
467
        explicit
 
468
        __tuple_impl(allocator_arg_t, const _Alloc& __a,
 
469
                     __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
 
470
                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
 
471
                     _Up&&... __u) :
 
472
            __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
 
473
            _VSTD::forward<_Up>(__u))...,
 
474
            __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
 
475
            {}
 
476
 
 
477
    template <class _Tuple,
 
478
              class = typename enable_if
 
479
                      <
 
480
                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
 
481
                      >::type
 
482
             >
 
483
        _LIBCPP_INLINE_VISIBILITY
 
484
        __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
 
485
                                       typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
 
486
            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
 
487
                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
 
488
            {}
 
489
 
 
490
    template <class _Alloc, class _Tuple,
 
491
              class = typename enable_if
 
492
                      <
 
493
                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
 
494
                      >::type
 
495
             >
 
496
        _LIBCPP_INLINE_VISIBILITY
 
497
        __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
 
498
            : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
 
499
                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a,
 
500
                                       _VSTD::forward<typename tuple_element<_Indx,
 
501
                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
 
502
            {}
 
503
 
 
504
    template <class _Tuple>
 
505
        _LIBCPP_INLINE_VISIBILITY
 
506
        typename enable_if
 
507
        <
 
508
            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
 
509
            __tuple_impl&
 
510
        >::type
 
511
        operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
 
512
                                       typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
 
513
        {
 
514
            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
 
515
                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
 
516
            return *this;
 
517
        }
 
518
 
 
519
        _LIBCPP_INLINE_VISIBILITY
 
520
        __tuple_impl&
 
521
        operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
 
522
        {
 
523
            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
 
524
            return *this;
 
525
        }
 
526
 
 
527
    _LIBCPP_INLINE_VISIBILITY
 
528
    void swap(__tuple_impl& __t)
 
529
        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 
530
    {
 
531
        __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
 
532
    }
 
533
};
 
534
 
 
535
template <class ..._Tp>
 
536
class _LIBCPP_TYPE_VIS tuple
 
537
{
 
538
    typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
 
539
 
 
540
    base base_;
 
541
 
 
542
    template <size_t _Jp, class ..._Up> friend
 
543
        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
 
544
    template <size_t _Jp, class ..._Up> friend
 
545
        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
 
546
    template <size_t _Jp, class ..._Up> friend
 
547
        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
 
548
public:
 
549
 
 
550
    _LIBCPP_INLINE_VISIBILITY
 
551
    _LIBCPP_CONSTEXPR tuple()
 
552
        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
553
 
 
554
    _LIBCPP_INLINE_VISIBILITY
 
555
    explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value)) 
 
556
        : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 
557
                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 
558
                typename __make_tuple_indices<0>::type(),
 
559
                typename __make_tuple_types<tuple, 0>::type(),
 
560
                __t...
 
561
               ) {}
 
562
 
 
563
    template <class _Alloc>
 
564
      _LIBCPP_INLINE_VISIBILITY
 
565
      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
 
566
        : base_(allocator_arg_t(), __a,
 
567
                typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 
568
                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 
569
                typename __make_tuple_indices<0>::type(),
 
570
                typename __make_tuple_types<tuple, 0>::type(),
 
571
                __t...
 
572
               ) {}
 
573
 
 
574
    template <class ..._Up,
 
575
              typename enable_if
 
576
                      <
 
577
                         sizeof...(_Up) <= sizeof...(_Tp) &&
 
578
                         __tuple_convertible
 
579
                         <
 
580
                            tuple<_Up...>,
 
581
                            typename __make_tuple_types<tuple,
 
582
                                     sizeof...(_Up) < sizeof...(_Tp) ?
 
583
                                        sizeof...(_Up) :
 
584
                                        sizeof...(_Tp)>::type
 
585
                         >::value,
 
586
                         bool
 
587
                      >::type = false
 
588
             >
 
589
        _LIBCPP_INLINE_VISIBILITY
 
590
        tuple(_Up&&... __u)
 
591
            _NOEXCEPT_((
 
592
                is_nothrow_constructible<
 
593
                    typename __make_tuple_indices<sizeof...(_Up)>::type,
 
594
                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
 
595
                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
 
596
                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
 
597
                    _Up...
 
598
                >::value
 
599
            ))
 
600
            : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
 
601
                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 
602
                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 
603
                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 
604
                    _VSTD::forward<_Up>(__u)...) {}
 
605
 
 
606
    template <class ..._Up,
 
607
              typename enable_if
 
608
                      <
 
609
                         sizeof...(_Up) <= sizeof...(_Tp) &&
 
610
                         __tuple_constructible
 
611
                         <
 
612
                            tuple<_Up...>,
 
613
                            typename __make_tuple_types<tuple,
 
614
                                     sizeof...(_Up) < sizeof...(_Tp) ?
 
615
                                        sizeof...(_Up) :
 
616
                                        sizeof...(_Tp)>::type
 
617
                         >::value &&
 
618
                         !__tuple_convertible
 
619
                         <
 
620
                            tuple<_Up...>,
 
621
                            typename __make_tuple_types<tuple,
 
622
                                     sizeof...(_Up) < sizeof...(_Tp) ?
 
623
                                        sizeof...(_Up) :
 
624
                                        sizeof...(_Tp)>::type
 
625
                         >::value,
 
626
                         bool
 
627
                      >::type =false
 
628
             >
 
629
        _LIBCPP_INLINE_VISIBILITY
 
630
        explicit
 
631
        tuple(_Up&&... __u)
 
632
            _NOEXCEPT_((
 
633
                is_nothrow_constructible<
 
634
                    typename __make_tuple_indices<sizeof...(_Up)>::type,
 
635
                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
 
636
                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
 
637
                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
 
638
                    _Up...
 
639
                >::value
 
640
            ))
 
641
            : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
 
642
                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 
643
                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 
644
                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 
645
                    _VSTD::forward<_Up>(__u)...) {}
 
646
 
 
647
    template <class _Alloc, class ..._Up,
 
648
              class = typename enable_if
 
649
                      <
 
650
                         sizeof...(_Up) <= sizeof...(_Tp) &&
 
651
                         __tuple_convertible
 
652
                         <
 
653
                            tuple<_Up...>,
 
654
                            typename __make_tuple_types<tuple,
 
655
                                     sizeof...(_Up) < sizeof...(_Tp) ?
 
656
                                        sizeof...(_Up) :
 
657
                                        sizeof...(_Tp)>::type
 
658
                         >::value
 
659
                      >::type
 
660
             >
 
661
        _LIBCPP_INLINE_VISIBILITY
 
662
        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
 
663
            : base_(allocator_arg_t(), __a,
 
664
                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
 
665
                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 
666
                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 
667
                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 
668
                    _VSTD::forward<_Up>(__u)...) {}
 
669
 
 
670
    template <class _Tuple,
 
671
              typename enable_if
 
672
                      <
 
673
                         __tuple_convertible<_Tuple, tuple>::value,
 
674
                         bool
 
675
                      >::type = false
 
676
             >
 
677
        _LIBCPP_INLINE_VISIBILITY
 
678
        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
 
679
            : base_(_VSTD::forward<_Tuple>(__t)) {}
 
680
 
 
681
    template <class _Tuple,
 
682
              typename enable_if
 
683
                      <
 
684
                         __tuple_constructible<_Tuple, tuple>::value &&
 
685
                         !__tuple_convertible<_Tuple, tuple>::value,
 
686
                         bool
 
687
                      >::type = false
 
688
             >
 
689
        _LIBCPP_INLINE_VISIBILITY
 
690
        explicit
 
691
        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
 
692
            : base_(_VSTD::forward<_Tuple>(__t)) {}
 
693
 
 
694
    template <class _Alloc, class _Tuple,
 
695
              class = typename enable_if
 
696
                      <
 
697
                         __tuple_convertible<_Tuple, tuple>::value
 
698
                      >::type
 
699
             >
 
700
        _LIBCPP_INLINE_VISIBILITY
 
701
        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
 
702
            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
703
 
 
704
    template <class _Tuple,
 
705
              class = typename enable_if
 
706
                      <
 
707
                         __tuple_assignable<_Tuple, tuple>::value
 
708
                      >::type
 
709
             >
 
710
        _LIBCPP_INLINE_VISIBILITY
 
711
        tuple&
 
712
        operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
 
713
        {
 
714
            base_.operator=(_VSTD::forward<_Tuple>(__t));
 
715
            return *this;
 
716
        }
 
717
 
 
718
    _LIBCPP_INLINE_VISIBILITY
 
719
    void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 
720
        {base_.swap(__t.base_);}
 
721
};
 
722
 
 
723
template <>
 
724
class _LIBCPP_TYPE_VIS tuple<>
 
725
{
 
726
public:
 
727
    _LIBCPP_INLINE_VISIBILITY
 
728
    _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
 
729
    template <class _Alloc>
 
730
    _LIBCPP_INLINE_VISIBILITY
 
731
        tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
 
732
    template <class _Alloc>
 
733
    _LIBCPP_INLINE_VISIBILITY
 
734
        tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
 
735
    template <class _Up>
 
736
    _LIBCPP_INLINE_VISIBILITY
 
737
        tuple(array<_Up, 0>) _NOEXCEPT {}
 
738
    template <class _Alloc, class _Up>
 
739
    _LIBCPP_INLINE_VISIBILITY
 
740
        tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
 
741
    _LIBCPP_INLINE_VISIBILITY
 
742
    void swap(tuple&) _NOEXCEPT {}
 
743
};
 
744
 
 
745
template <class ..._Tp>
 
746
inline _LIBCPP_INLINE_VISIBILITY
 
747
typename enable_if
 
748
<
 
749
    __all<__is_swappable<_Tp>::value...>::value,
 
750
    void
 
751
>::type
 
752
swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
 
753
                 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 
754
    {__t.swap(__u);}
 
755
 
 
756
// get
 
757
 
 
758
template <size_t _Ip, class ..._Tp>
 
759
inline _LIBCPP_INLINE_VISIBILITY
 
760
typename tuple_element<_Ip, tuple<_Tp...> >::type&
 
761
get(tuple<_Tp...>& __t) _NOEXCEPT
 
762
{
 
763
    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 
764
    return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
 
765
}
 
766
 
 
767
template <size_t _Ip, class ..._Tp>
 
768
inline _LIBCPP_INLINE_VISIBILITY
 
769
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 
770
get(const tuple<_Tp...>& __t) _NOEXCEPT
 
771
{
 
772
    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 
773
    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
 
774
}
 
775
 
 
776
template <size_t _Ip, class ..._Tp>
 
777
inline _LIBCPP_INLINE_VISIBILITY
 
778
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 
779
get(tuple<_Tp...>&& __t) _NOEXCEPT
 
780
{
 
781
    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 
782
    return static_cast<type&&>(
 
783
             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
 
784
}
 
785
 
 
786
// tie
 
787
 
 
788
template <class ..._Tp>
 
789
inline _LIBCPP_INLINE_VISIBILITY
 
790
tuple<_Tp&...>
 
791
tie(_Tp&... __t) _NOEXCEPT
 
792
{
 
793
    return tuple<_Tp&...>(__t...);
 
794
}
 
795
 
 
796
template <class _Up>
 
797
struct __ignore_t
 
798
{
 
799
    template <class _Tp>
 
800
        _LIBCPP_INLINE_VISIBILITY
 
801
        const __ignore_t& operator=(_Tp&&) const {return *this;}
 
802
};
 
803
 
 
804
namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
 
805
 
 
806
template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper;
 
807
 
 
808
template <class _Tp>
 
809
struct ___make_tuple_return
 
810
{
 
811
    typedef _Tp type;
 
812
};
 
813
 
 
814
template <class _Tp>
 
815
struct ___make_tuple_return<reference_wrapper<_Tp> >
 
816
{
 
817
    typedef _Tp& type;
 
818
};
 
819
 
 
820
template <class _Tp>
 
821
struct __make_tuple_return
 
822
{
 
823
    typedef typename ___make_tuple_return<typename decay<_Tp>::type>::type type;
 
824
};
 
825
 
 
826
template <class... _Tp>
 
827
inline _LIBCPP_INLINE_VISIBILITY
 
828
tuple<typename __make_tuple_return<_Tp>::type...>
 
829
make_tuple(_Tp&&... __t)
 
830
{
 
831
    return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
 
832
}
 
833
 
 
834
template <class... _Tp>
 
835
inline _LIBCPP_INLINE_VISIBILITY
 
836
tuple<_Tp&&...>
 
837
forward_as_tuple(_Tp&&... __t) _NOEXCEPT
 
838
{
 
839
    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
 
840
}
 
841
 
 
842
template <size_t _Ip>
 
843
struct __tuple_equal
 
844
{
 
845
    template <class _Tp, class _Up>
 
846
    _LIBCPP_INLINE_VISIBILITY
 
847
    bool operator()(const _Tp& __x, const _Up& __y)
 
848
    {
 
849
        return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y);
 
850
    }
 
851
};
 
852
 
 
853
template <>
 
854
struct __tuple_equal<0>
 
855
{
 
856
    template <class _Tp, class _Up>
 
857
    _LIBCPP_INLINE_VISIBILITY
 
858
    bool operator()(const _Tp&, const _Up&)
 
859
    {
 
860
        return true;
 
861
    }
 
862
};
 
863
 
 
864
template <class ..._Tp, class ..._Up>
 
865
inline _LIBCPP_INLINE_VISIBILITY
 
866
bool
 
867
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
868
{
 
869
    return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
 
870
}
 
871
 
 
872
template <class ..._Tp, class ..._Up>
 
873
inline _LIBCPP_INLINE_VISIBILITY
 
874
bool
 
875
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
876
{
 
877
    return !(__x == __y);
 
878
}
 
879
 
 
880
template <size_t _Ip>
 
881
struct __tuple_less
 
882
{
 
883
    template <class _Tp, class _Up>
 
884
    _LIBCPP_INLINE_VISIBILITY
 
885
    bool operator()(const _Tp& __x, const _Up& __y)
 
886
    {
 
887
        return __tuple_less<_Ip-1>()(__x, __y) ||
 
888
             (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y));
 
889
    }
 
890
};
 
891
 
 
892
template <>
 
893
struct __tuple_less<0>
 
894
{
 
895
    template <class _Tp, class _Up>
 
896
    _LIBCPP_INLINE_VISIBILITY
 
897
    bool operator()(const _Tp&, const _Up&)
 
898
    {
 
899
        return false;
 
900
    }
 
901
};
 
902
 
 
903
template <class ..._Tp, class ..._Up>
 
904
inline _LIBCPP_INLINE_VISIBILITY
 
905
bool
 
906
operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
907
{
 
908
    return __tuple_less<sizeof...(_Tp)>()(__x, __y);
 
909
}
 
910
 
 
911
template <class ..._Tp, class ..._Up>
 
912
inline _LIBCPP_INLINE_VISIBILITY
 
913
bool
 
914
operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
915
{
 
916
    return __y < __x;
 
917
}
 
918
 
 
919
template <class ..._Tp, class ..._Up>
 
920
inline _LIBCPP_INLINE_VISIBILITY
 
921
bool
 
922
operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
923
{
 
924
    return !(__x < __y);
 
925
}
 
926
 
 
927
template <class ..._Tp, class ..._Up>
 
928
inline _LIBCPP_INLINE_VISIBILITY
 
929
bool
 
930
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
931
{
 
932
    return !(__y < __x);
 
933
}
 
934
 
 
935
// tuple_cat
 
936
 
 
937
template <class _Tp, class _Up> struct __tuple_cat_type;
 
938
 
 
939
template <class ..._Ttypes, class ..._Utypes>
 
940
struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
 
941
{
 
942
    typedef tuple<_Ttypes..., _Utypes...> type;
 
943
};
 
944
 
 
945
template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
 
946
struct __tuple_cat_return_1
 
947
{
 
948
};
 
949
 
 
950
template <class ..._Types, class _Tuple0>
 
951
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
 
952
{
 
953
    typedef typename __tuple_cat_type<tuple<_Types...>,
 
954
            typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
 
955
                                                                           type;
 
956
};
 
957
 
 
958
template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
 
959
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
 
960
    : public __tuple_cat_return_1<
 
961
                 typename __tuple_cat_type<
 
962
                     tuple<_Types...>,
 
963
                     typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
 
964
                 >::type,
 
965
                 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
 
966
                 _Tuple1, _Tuples...>
 
967
{
 
968
};
 
969
 
 
970
template <class ..._Tuples> struct __tuple_cat_return;
 
971
 
 
972
template <class _Tuple0, class ..._Tuples>
 
973
struct __tuple_cat_return<_Tuple0, _Tuples...>
 
974
    : public __tuple_cat_return_1<tuple<>,
 
975
         __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
 
976
                                                                     _Tuples...>
 
977
{
 
978
};
 
979
 
 
980
template <>
 
981
struct __tuple_cat_return<>
 
982
{
 
983
    typedef tuple<> type;
 
984
};
 
985
 
 
986
inline _LIBCPP_INLINE_VISIBILITY
 
987
tuple<>
 
988
tuple_cat()
 
989
{
 
990
    return tuple<>();
 
991
}
 
992
 
 
993
template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
 
994
struct __tuple_cat_return_ref_imp;
 
995
 
 
996
template <class ..._Types, size_t ..._I0, class _Tuple0>
 
997
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
 
998
{
 
999
    typedef typename remove_reference<_Tuple0>::type _T0;
 
1000
    typedef tuple<_Types..., typename __apply_cv<_Tuple0,
 
1001
                          typename tuple_element<_I0, _T0>::type>::type&&...> type;
 
1002
};
 
1003
 
 
1004
template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
 
1005
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
 
1006
                                  _Tuple0, _Tuple1, _Tuples...>
 
1007
    : public __tuple_cat_return_ref_imp<
 
1008
         tuple<_Types..., typename __apply_cv<_Tuple0,
 
1009
               typename tuple_element<_I0,
 
1010
                  typename remove_reference<_Tuple0>::type>::type>::type&&...>,
 
1011
         typename __make_tuple_indices<tuple_size<typename
 
1012
                                 remove_reference<_Tuple1>::type>::value>::type,
 
1013
         _Tuple1, _Tuples...>
 
1014
{
 
1015
};
 
1016
 
 
1017
template <class _Tuple0, class ..._Tuples>
 
1018
struct __tuple_cat_return_ref
 
1019
    : public __tuple_cat_return_ref_imp<tuple<>,
 
1020
               typename __make_tuple_indices<
 
1021
                        tuple_size<typename remove_reference<_Tuple0>::type>::value
 
1022
               >::type, _Tuple0, _Tuples...>
 
1023
{
 
1024
};
 
1025
 
 
1026
template <class _Types, class _I0, class _J0>
 
1027
struct __tuple_cat;
 
1028
 
 
1029
template <class ..._Types, size_t ..._I0, size_t ..._J0>
 
1030
struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
 
1031
{
 
1032
    template <class _Tuple0>
 
1033
    _LIBCPP_INLINE_VISIBILITY
 
1034
    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
 
1035
    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
 
1036
    {
 
1037
        return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
 
1038
                                      get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
 
1039
    }
 
1040
 
 
1041
    template <class _Tuple0, class _Tuple1, class ..._Tuples>
 
1042
    _LIBCPP_INLINE_VISIBILITY
 
1043
    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
 
1044
    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
 
1045
    {
 
1046
        typedef typename remove_reference<_Tuple0>::type _T0;
 
1047
        typedef typename remove_reference<_Tuple1>::type _T1;
 
1048
        return __tuple_cat<
 
1049
           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
 
1050
           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
 
1051
           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
 
1052
                           (_VSTD::forward_as_tuple(
 
1053
                              _VSTD::forward<_Types>(get<_I0>(__t))...,
 
1054
                              get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
 
1055
                            ),
 
1056
                            _VSTD::forward<_Tuple1>(__t1),
 
1057
                            _VSTD::forward<_Tuples>(__tpls)...);
 
1058
    }
 
1059
};
 
1060
 
 
1061
template <class _Tuple0, class... _Tuples>
 
1062
inline _LIBCPP_INLINE_VISIBILITY
 
1063
typename __tuple_cat_return<_Tuple0, _Tuples...>::type
 
1064
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
 
1065
{
 
1066
    typedef typename remove_reference<_Tuple0>::type _T0;
 
1067
    return __tuple_cat<tuple<>, __tuple_indices<>,
 
1068
                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
 
1069
                  (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
 
1070
                                            _VSTD::forward<_Tuples>(__tpls)...);
 
1071
}
 
1072
 
 
1073
template <class ..._Tp, class _Alloc>
 
1074
struct _LIBCPP_TYPE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
 
1075
    : true_type {};
 
1076
 
 
1077
template <class _T1, class _T2>
 
1078
template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
 
1079
inline _LIBCPP_INLINE_VISIBILITY
 
1080
pair<_T1, _T2>::pair(piecewise_construct_t,
 
1081
                     tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
 
1082
                     __tuple_indices<_I1...>, __tuple_indices<_I2...>)
 
1083
    :  first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
 
1084
      second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
 
1085
{
 
1086
}
 
1087
 
 
1088
#endif  // _LIBCPP_HAS_NO_VARIADICS
 
1089
 
 
1090
_LIBCPP_END_NAMESPACE_STD
 
1091
 
 
1092
#endif  // _LIBCPP_TUPLE