Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 324bb03bb94f67ae7f9092810e4e4f6bd8bf506e / . / include / tuple
blob: 492b2542589d6e9cd148a54b66d3fdbdeced8854 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1// -*- C++ -*-
2//===--------------------------- tuple ------------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +0000[diff] [blame]4// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]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&&);
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& operator=(tuple&&);
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>&&); //iffsizeof...(T) == 2
68
69 void swap(tuple&);
70};
71
72const unspecified ignore;
73
74template <class... T> tuple<V...> make_tuple(T&&...);
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000[diff] [blame]75template <class... T> tuple<ATypes...> forward_as_tuple(T&&...);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]76template <class... T> tuple<T&...> tie(T&...);
77template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, const tuple<U...>&);
78template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, const tuple<U...>&);
79template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, tuple<U...>&&);
80template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, tuple<U...>&&);
81
82// 20.4.1.4, tuple helper classes:
83template <class T> class tuple_size; // undefined
84template <class... T> class tuple_size<tuple<T...>>;
85template <intsize_t I, class T> class tuple_element; // undefined
86template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>;
87
88// 20.4.1.5, element access:
89template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type& get(tuple<T...>&);
90template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type const& get(const tuple<T...>&);
91
92// 20.4.1.6, relational operators:
93template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
94template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
95template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
96template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
97template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
98template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
99
100template <class... Types, class Alloc>
101 struct uses_allocator<tuple<Types...>, Alloc>;
102
103template <class... Types>
104 void swap(tuple<Types...>& x, tuple<Types...>& y);
105
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]106} // std
107
108*/
109
110#include <__config>
111#include <__tuple>
112#include <cstddef>
113#include <memory>
114#include <type_traits>
115
116#pragma GCC system_header
117
118_LIBCPP_BEGIN_NAMESPACE_STD
119
120#ifndef _LIBCPP_HAS_NO_VARIADICS
121
122// tuple_size
123
124template <class ..._Tp>
125class tuple_size<tuple<_Tp...>>
126 : public integral_constant<size_t, sizeof...(_Tp)>
127{
128};
129
130template <class ..._Tp>
131class tuple_size<const tuple<_Tp...>>
132 : public integral_constant<size_t, sizeof...(_Tp)>
133{
134};
135
136// tuple_element
137
138template <size_t _Ip, class ..._Tp>
139class tuple_element<_Ip, tuple<_Tp...>>
140{
141public:
142 typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
143};
144
145template <size_t _Ip, class ..._Tp>
146class tuple_element<_Ip, const tuple<_Tp...>>
147{
148public:
149 typedef const typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
150};
151
152// __tuple_leaf
153
154template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value>
155class __tuple_leaf;
156
157template <size_t _Ip, class _Hp, bool _Ep>
158inline
159void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
160{
161 swap(__x.get(), __y.get());
162}
163
164template <size_t _Ip, class _Hp, bool>
165class __tuple_leaf
166{
167 _Hp value;
168
169 __tuple_leaf& operator=(const __tuple_leaf&);
170public:
171 _LIBCPP_INLINE_VISIBILITY __tuple_leaf() : value()
172 {static_assert(!is_reference<_Hp>::value,
173 "Attempted to default construct a reference element in a tuple");}
174
175 template <class _Alloc>
176 _LIBCPP_INLINE_VISIBILITY
177 __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
178 : value()
179 {static_assert(!is_reference<_Hp>::value,
180 "Attempted to default construct a reference element in a tuple");}
181
182 template <class _Alloc>
183 _LIBCPP_INLINE_VISIBILITY
184 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
185 : value(allocator_arg_t(), __a)
186 {static_assert(!is_reference<_Hp>::value,
187 "Attempted to default construct a reference element in a tuple");}
188
189 template <class _Alloc>
190 _LIBCPP_INLINE_VISIBILITY
191 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
192 : value(__a)
193 {static_assert(!is_reference<_Hp>::value,
194 "Attempted to default construct a reference element in a tuple");}
195
196 template <class _Tp>
197 _LIBCPP_INLINE_VISIBILITY
198 explicit __tuple_leaf(_Tp&& __t)
199 : value(_STD::forward<_Tp>(__t))
200 {static_assert(!is_lvalue_reference<_Hp>::value ||
201 is_lvalue_reference<_Hp>::value &&
202 (is_lvalue_reference<_Tp>::value ||
203 is_same<typename remove_reference<_Tp>::type,
204 reference_wrapper<
205 typename remove_reference<_Hp>::type
206 >
207 >::value),
208 "Attempted to construct a reference element in a tuple with an rvalue");}
209
210 template <class _Tp, class _Alloc>
211 _LIBCPP_INLINE_VISIBILITY
212 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
213 : value(_STD::forward<_Tp>(__t))
214 {static_assert(!is_lvalue_reference<_Hp>::value ||
215 is_lvalue_reference<_Hp>::value &&
216 (is_lvalue_reference<_Tp>::value ||
217 is_same<typename remove_reference<_Tp>::type,
218 reference_wrapper<
219 typename remove_reference<_Hp>::type
220 >
221 >::value),
222 "Attempted to construct a reference element in a tuple with an rvalue");}
223
224 template <class _Tp, class _Alloc>
225 _LIBCPP_INLINE_VISIBILITY
226 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
227 : value(allocator_arg_t(), __a, _STD::forward<_Tp>(__t))
228 {static_assert(!is_lvalue_reference<_Hp>::value ||
229 is_lvalue_reference<_Hp>::value &&
230 (is_lvalue_reference<_Tp>::value ||
231 is_same<typename remove_reference<_Tp>::type,
232 reference_wrapper<
233 typename remove_reference<_Hp>::type
234 >
235 >::value),
236 "Attempted to construct a reference element in a tuple with an rvalue");}
237
238 template <class _Tp, class _Alloc>
239 _LIBCPP_INLINE_VISIBILITY
240 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
241 : value(_STD::forward<_Tp>(__t), __a)
242 {static_assert(!is_lvalue_reference<_Hp>::value ||
243 is_lvalue_reference<_Hp>::value &&
244 (is_lvalue_reference<_Tp>::value ||
245 is_same<typename remove_reference<_Tp>::type,
246 reference_wrapper<
247 typename remove_reference<_Hp>::type
248 >
249 >::value),
250 "Attempted to construct a reference element in a tuple with an rvalue");}
251
252 template <class _Tp>
253 _LIBCPP_INLINE_VISIBILITY
254 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
255 : value(__t.get()) {}
256
257 template <class _Tp>
258 _LIBCPP_INLINE_VISIBILITY
259 __tuple_leaf&
260 operator=(_Tp&& __t)
261 {
262 value = _STD::forward<_Tp>(__t);
263 return *this;
264 }
265
266 _LIBCPP_INLINE_VISIBILITY
267 int swap(__tuple_leaf& __t)
268 {
269 _STD::swap(*this, __t);
270 return 0;
271 }
272
273 _LIBCPP_INLINE_VISIBILITY _Hp& get() {return value;}
274 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return value;}
275};
276
277template <size_t _Ip, class _Hp>
278class __tuple_leaf<_Ip, _Hp, true>
279 : private _Hp
280{
281
282 __tuple_leaf& operator=(const __tuple_leaf&);
283public:
284 _LIBCPP_INLINE_VISIBILITY __tuple_leaf() {}
285
286 template <class _Alloc>
287 _LIBCPP_INLINE_VISIBILITY
288 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
289
290 template <class _Alloc>
291 _LIBCPP_INLINE_VISIBILITY
292 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
293 : _Hp(allocator_arg_t(), __a) {}
294
295 template <class _Alloc>
296 _LIBCPP_INLINE_VISIBILITY
297 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
298 : _Hp(__a) {}
299
300 template <class _Tp>
301 _LIBCPP_INLINE_VISIBILITY
302 explicit __tuple_leaf(_Tp&& __t)
303 : _Hp(_STD::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(_STD::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, _STD::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(_STD::forward<_Tp>(__t), __a) {}
319
320 template <class _Tp>
321 _LIBCPP_INLINE_VISIBILITY
322 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
323 : _Hp(__t.get()) {}
324
325 template <class _Tp>
326 _LIBCPP_INLINE_VISIBILITY
327 __tuple_leaf&
328 operator=(_Tp&& __t)
329 {
330 _Hp::operator=(_STD::forward<_Tp>(__t));
331 return *this;
332 }
333
334 _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t)
335 {
336 _STD::swap(*this, __t);
337 return 0;
338 }
339
340 _LIBCPP_INLINE_VISIBILITY _Hp& get() {return static_cast<_Hp&>(*this);}
341 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast<const _Hp&>(*this);}
342};
343
344template <class ..._Tp> void __swallow(_Tp&&...) {}
345
346// __tuple_impl
347
348template<class _Indx, class ..._Tp> struct __tuple_impl;
349
350template<size_t ..._Indx, class ..._Tp>
351struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
352 : public __tuple_leaf<_Indx, _Tp>...
353{
354 template <size_t ..._Uf, class ..._Tf,
355 size_t ..._Ul, class ..._Tl, class ..._Up>
356 explicit
357 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
358 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
359 _Up&&... __u) :
360 __tuple_leaf<_Uf, _Tf>(_STD::forward<_Up>(__u))...,
361 __tuple_leaf<_Ul, _Tl>()...
362 {}
363
364 template <class _Alloc, size_t ..._Uf, class ..._Tf,
365 size_t ..._Ul, class ..._Tl, class ..._Up>
366 explicit
367 __tuple_impl(allocator_arg_t, const _Alloc& __a,
368 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
369 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
370 _Up&&... __u) :
371 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
372 _STD::forward<_Up>(__u))...,
373 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
374 {}
375
376 template <class _Tuple,
377 class = typename enable_if
378 <
379 __tuple_convertible<_Tuple, tuple<_Tp...>>::value
380 >::type
381 >
382 __tuple_impl(_Tuple&& __t)
383 : __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
384 typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
385 {}
386
387 template <class _Alloc, class _Tuple,
388 class = typename enable_if
389 <
390 __tuple_convertible<_Tuple, tuple<_Tp...>>::value
391 >::type
392 >
393 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
394 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame^]395 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]396 _STD::forward<typename tuple_element<_Indx,
397 typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
398 {}
399
400 template <class _Tuple>
401 typename enable_if
402 <
403 __tuple_assignable<_Tuple, tuple<_Tp...>>::value,
404 __tuple_impl&
405 >::type
406 operator=(_Tuple&& __t)
407 {
408 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_STD::forward<typename tuple_element<_Indx,
409 typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...);
410 return *this;
411 }
412
413 void swap(__tuple_impl& __t)
414 {
415 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
416 }
417};
418
419template <class ..._Tp>
420class tuple
421{
422 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
423
424 base base_;
425
426 template <size_t _Jp, class ..._Up> friend
427 typename tuple_element<_Jp, tuple<_Up...>>::type& get(tuple<_Up...>&);
428 template <size_t _Jp, class ..._Up> friend
429 const typename tuple_element<_Jp, tuple<_Up...>>::type& get(const tuple<_Up...>&);
430public:
431
432 explicit tuple(const _Tp& ... __t)
433 : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
434 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
435 typename __make_tuple_indices<0>::type(),
436 typename __make_tuple_types<tuple, 0>::type(),
437 __t...
438 ) {}
439
440 template <class _Alloc>
441 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
442 : base_(allocator_arg_t(), __a,
443 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
444 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
445 typename __make_tuple_indices<0>::type(),
446 typename __make_tuple_types<tuple, 0>::type(),
447 __t...
448 ) {}
449
450 template <class ..._Up,
451 class = typename enable_if
452 <
453 sizeof...(_Up) <= sizeof...(_Tp) &&
454 __tuple_convertible
455 <
456 tuple<_Up...>,
457 typename __make_tuple_types<tuple,
458 sizeof...(_Up) < sizeof...(_Tp) ?
459 sizeof...(_Up) :
460 sizeof...(_Tp)>::type
461 >::value
462 >::type
463 >
464 explicit
465 tuple(_Up&&... __u)
466 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
467 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
468 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
469 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
470 _STD::forward<_Up>(__u)...) {}
471
472 template <class _Alloc, class ..._Up,
473 class = typename enable_if
474 <
475 sizeof...(_Up) <= sizeof...(_Tp) &&
476 __tuple_convertible
477 <
478 tuple<_Up...>,
479 typename __make_tuple_types<tuple,
480 sizeof...(_Up) < sizeof...(_Tp) ?
481 sizeof...(_Up) :
482 sizeof...(_Tp)>::type
483 >::value
484 >::type
485 >
486 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
487 : base_(allocator_arg_t(), __a,
488 typename __make_tuple_indices<sizeof...(_Up)>::type(),
489 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
490 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
491 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
492 _STD::forward<_Up>(__u)...) {}
493
494 template <class _Tuple,
495 class = typename enable_if
496 <
497 __tuple_convertible<_Tuple, tuple>::value
498 >::type
499 >
500 tuple(_Tuple&& __t)
501 : base_(_STD::forward<_Tuple>(__t)) {}
502
503 template <class _Alloc, class _Tuple,
504 class = typename enable_if
505 <
506 __tuple_convertible<_Tuple, tuple>::value
507 >::type
508 >
509 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
510 : base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}
511
512 template <class _Tuple,
513 class = typename enable_if
514 <
515 __tuple_assignable<_Tuple, tuple>::value
516 >::type
517 >
518 tuple&
519 operator=(_Tuple&& __t)
520 {
521 base_.operator=(_STD::forward<_Tuple>(__t));
522 return *this;
523 }
524
525 void swap(tuple& __t) {base_.swap(__t.base_);}
526};
527
528template <>
529class tuple<>
530{
531public:
532 tuple() {}
533 template <class _Alloc>
534 tuple(allocator_arg_t, const _Alloc&) {}
535 template <class _Alloc>
536 tuple(allocator_arg_t, const _Alloc&, const tuple&) {}
537 template <class _U>
538 tuple(array<_U, 0>) {}
539 template <class _Alloc, class _U>
540 tuple(allocator_arg_t, const _Alloc&, array<_U, 0>) {}
541 void swap(tuple&) {}
542};
543
544template <class ..._Tp>
545inline _LIBCPP_INLINE_VISIBILITY
546void
547swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}
548
549// get
550
551template <size_t _Ip, class ..._Tp>
552inline
553typename tuple_element<_Ip, tuple<_Tp...>>::type&
554get(tuple<_Tp...>& __t)
555{
556 typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
557 return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
558}
559
560template <size_t _Ip, class ..._Tp>
561inline
562const typename tuple_element<_Ip, tuple<_Tp...>>::type&
563get(const tuple<_Tp...>& __t)
564{
565 typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
566 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
567}
568
569// tie
570
571template <class ..._Tp>
572inline
573tuple<_Tp&...>
574tie(_Tp&... __t)
575{
576 return tuple<_Tp&...>(__t...);
577}
578
579template <class _Up>
580struct __ignore_t
581{
582 __ignore_t() {}
583 template <class _Tp>
584 __ignore_t(_Tp&&) {}
585 template <class _Tp>
586 const __ignore_t& operator=(_Tp&&) const {return *this;}
587};
588
589namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
590
591template <class _Tp> class reference_wrapper;
592
593template <class _Tp>
594struct ___make_tuple_return
595{
596 typedef _Tp type;
597};
598
599template <class _Tp>
600struct ___make_tuple_return<reference_wrapper<_Tp>>
601{
602 typedef _Tp& type;
603};
604
605template <class _Tp>
606struct __make_tuple_return
607{
608 typedef typename ___make_tuple_return<typename decay<_Tp>::type>::type type;
609};
610
611template <class... _Tp>
612inline
613tuple<typename __make_tuple_return<_Tp>::type...>
614make_tuple(_Tp&&... __t)
615{
616 return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
617}
618
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000[diff] [blame]619template <class... _Tp>
620inline
621tuple<_Tp&&...>
622forward_as_tuple(_Tp&&... __t)
623{
624 return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
625}
626
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]627template <size_t _I>
628struct __tuple_equal
629{
630 template <class _Tp, class _Up>
631 bool operator()(const _Tp& __x, const _Up& __y)
632 {
633 return __tuple_equal<_I - 1>()(__x, __y) && get<_I-1>(__x) == get<_I-1>(__y);
634 }
635};
636
637template <>
638struct __tuple_equal<0>
639{
640 template <class _Tp, class _Up>
641 bool operator()(const _Tp&, const _Up&)
642 {
643 return true;
644 }
645};
646
647template <class ..._Tp, class ..._Up>
648inline
649bool
650operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
651{
652 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
653}
654
655template <class ..._Tp, class ..._Up>
656inline
657bool
658operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
659{
660 return !(__x == __y);
661}
662
663template <size_t _I>
664struct __tuple_less
665{
666 template <class _Tp, class _Up>
667 bool operator()(const _Tp& __x, const _Up& __y)
668 {
669 return __tuple_less<_I-1>()(__x, __y) ||
670 (!__tuple_less<_I-1>()(__y, __x) && get<_I-1>(__x) < get<_I-1>(__y));
671 }
672};
673
674template <>
675struct __tuple_less<0>
676{
677 template <class _Tp, class _Up>
678 bool operator()(const _Tp&, const _Up&)
679 {
680 return false;
681 }
682};
683
684template <class ..._Tp, class ..._Up>
685inline
686bool
687operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
688{
689 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
690}
691
692template <class ..._Tp, class ..._Up>
693inline
694bool
695operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
696{
697 return __y < __x;
698}
699
700template <class ..._Tp, class ..._Up>
701inline
702bool
703operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
704{
705 return !(__x < __y);
706}
707
708template <class ..._Tp, class ..._Up>
709inline
710bool
711operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
712{
713 return !(__y < __x);
714}
715
716// tuple_cat
717
718template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
719inline
720tuple<_Tp..., _Up...>
721__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
722{
723 return tuple<_Tp..., _Up...>(get<_I1>(__x)..., get<_I2>(__y)...);
724}
725
726template <class... _Tp, class... _Up>
727inline
728tuple<_Tp..., _Up...>
729tuple_cat(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
730{
731 return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
732 __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
733}
734
735template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
736inline
737tuple<_Tp..., _Up...>
738__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
739{
740 return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., get<_I2>(__y)...);
741}
742
743template <class... _Tp, class... _Up>
744inline
745tuple<_Tp..., _Up...>
746tuple_cat(tuple<_Tp...>&& __x, const tuple<_Up...>& __y)
747{
748 return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
749 __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
750}
751
752template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
753inline
754tuple<_Tp..., _Up...>
755__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
756{
757 return tuple<_Tp..., _Up...>(get<_I1>(__x)..., _STD::forward<_Up>(get<_I2>(__y))...);
758}
759
760template <class... _Tp, class... _Up>
761inline
762tuple<_Tp..., _Up...>
763tuple_cat(const tuple<_Tp...>& __x, tuple<_Up...>&& __y)
764{
765 return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
766 _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
767}
768
769template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
770inline
771tuple<_Tp..., _Up...>
772__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
773{
774 return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., _STD::forward<_Up>(get<_I2>(__y))...);
775}
776
777template <class... _Tp, class... _Up>
778inline
779tuple<_Tp..., _Up...>
780tuple_cat(tuple<_Tp...>&& __x, tuple<_Up...>&& __y)
781{
782 return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
783 _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
784}
785
786template <class ..._Tp, class _Alloc>
787struct uses_allocator<tuple<_Tp...>, _Alloc>
788 : true_type {};
789
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]790template <class _T1, class _T2>
791template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
792inline _LIBCPP_INLINE_VISIBILITY
793pair<_T1, _T2>::pair(piecewise_construct_t,
794 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
795 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
796 : first(_STD::forward<_Args1>(get<_I1>( __first_args))...),
797 second(_STD::forward<_Args2>(get<_I2>(__second_args))...)
798{
799}
800
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame^]801#endif // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]802
803_LIBCPP_END_NAMESPACE_STD
804
805#endif // _LIBCPP_TUPLE