blob: d8a36e6e9f585d928e78be704f1f8b34ef0a0c7f [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001// -*- C++ -*-
2//===--------------------------- tuple ------------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00005//
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;
Howard Hinnanta5e01212011-05-27 19:08:18 +000028 tuple(tuple&&) = default;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000029 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&);
Howard Hinnanta5e01212011-05-27 19:08:18 +000059 tuple&
60 operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000061 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
Howard Hinnanta5e01212011-05-27 19:08:18 +000070 void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000071};
72
73const unspecified ignore;
74
75template <class... T> tuple<V...> make_tuple(T&&...);
Howard Hinnanta5e01212011-05-27 19:08:18 +000076template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
77template <class... T> tuple<T&...> tie(T&...) noexcept;
Howard Hinnant0e1493e2010-12-11 20:47:50 +000078template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
79
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000080// 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:
Howard Hinnanta5e01212011-05-27 19:08:18 +000087template <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;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000096
Marshall Clowe8029e52013-07-13 02:54:05 +000097template <class T1, class... T>
98 constexpr T1& get(tuple<T...>&) noexcept; // C++14
99template <class T1, class... T>
100 constexpr T1 const& get(const tuple<T...>&) noexcept; // C++14
101template <class T1, class... T>
102 constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
103
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000104// 20.4.1.6, relational operators:
105template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
106template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
107template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
108template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
109template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
110template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
111
112template <class... Types, class Alloc>
113 struct uses_allocator<tuple<Types...>, Alloc>;
114
115template <class... Types>
Howard Hinnanta5e01212011-05-27 19:08:18 +0000116 void
117 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000118
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000119} // std
120
121*/
122
123#include <__config>
124#include <__tuple>
125#include <cstddef>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000126#include <type_traits>
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000127#include <__functional_base>
128#include <utility>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000129
Howard Hinnant08e17472011-10-17 20:05:10 +0000130#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000131#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000132#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000133
134_LIBCPP_BEGIN_NAMESPACE_STD
135
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000136// allocator_arg_t
137
Howard Hinnant83eade62013-03-06 23:30:19 +0000138struct _LIBCPP_TYPE_VIS allocator_arg_t { };
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000139
Howard Hinnant46e94932012-07-07 20:56:04 +0000140#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000141extern const allocator_arg_t allocator_arg;
Howard Hinnant46e94932012-07-07 20:56:04 +0000142#else
143constexpr allocator_arg_t allocator_arg = allocator_arg_t();
144#endif
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000145
146// uses_allocator
147
148template <class _Tp>
149struct __has_allocator_type
150{
151private:
Howard Hinnant9c0df142012-10-30 19:06:59 +0000152 struct __two {char __lx; char __lxx;};
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000153 template <class _Up> static __two __test(...);
154 template <class _Up> static char __test(typename _Up::allocator_type* = 0);
155public:
156 static const bool value = sizeof(__test<_Tp>(0)) == 1;
157};
158
159template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
160struct __uses_allocator
161 : public integral_constant<bool,
162 is_convertible<_Alloc, typename _Tp::allocator_type>::value>
163{
164};
165
166template <class _Tp, class _Alloc>
167struct __uses_allocator<_Tp, _Alloc, false>
168 : public false_type
169{
170};
171
172template <class _Tp, class _Alloc>
Howard Hinnant83eade62013-03-06 23:30:19 +0000173struct _LIBCPP_TYPE_VIS uses_allocator
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000174 : public __uses_allocator<_Tp, _Alloc>
175{
176};
177
178#ifndef _LIBCPP_HAS_NO_VARIADICS
179
180// uses-allocator construction
181
182template <class _Tp, class _Alloc, class ..._Args>
183struct __uses_alloc_ctor_imp
184{
185 static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
186 static const bool __ic =
187 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
188 static const int value = __ua ? 2 - __ic : 0;
189};
190
191template <class _Tp, class _Alloc, class ..._Args>
192struct __uses_alloc_ctor
193 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
194 {};
195
196#endif // _LIBCPP_HAS_NO_VARIADICS
197
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000198#ifndef _LIBCPP_HAS_NO_VARIADICS
199
200// tuple_size
201
202template <class ..._Tp>
Howard Hinnant83eade62013-03-06 23:30:19 +0000203class _LIBCPP_TYPE_VIS tuple_size<tuple<_Tp...> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000204 : public integral_constant<size_t, sizeof...(_Tp)>
205{
206};
207
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000208// tuple_element
209
210template <size_t _Ip, class ..._Tp>
Howard Hinnant83eade62013-03-06 23:30:19 +0000211class _LIBCPP_TYPE_VIS tuple_element<_Ip, tuple<_Tp...> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000212{
213public:
Howard Hinnantf83417b2011-01-24 16:07:25 +0000214 typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000215};
216
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000217// __tuple_leaf
218
Howard Hinnantd4cf2152011-12-11 20:31:33 +0000219template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value
220#if __has_feature(is_final)
221 && !__is_final(_Hp)
222#endif
223 >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000224class __tuple_leaf;
225
226template <size_t _Ip, class _Hp, bool _Ep>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000227inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000228void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
Howard Hinnanta5e01212011-05-27 19:08:18 +0000229 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000230{
231 swap(__x.get(), __y.get());
232}
233
234template <size_t _Ip, class _Hp, bool>
235class __tuple_leaf
236{
237 _Hp value;
238
239 __tuple_leaf& operator=(const __tuple_leaf&);
240public:
Howard Hinnant4eebfc32012-07-06 20:50:27 +0000241 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
242 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value()
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000243 {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, 0>, const _Alloc&)
249 : value()
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, 1>, const _Alloc& __a)
256 : value(allocator_arg_t(), __a)
257 {static_assert(!is_reference<_Hp>::value,
258 "Attempted to default construct a reference element in a tuple");}
259
260 template <class _Alloc>
261 _LIBCPP_INLINE_VISIBILITY
262 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
263 : value(__a)
264 {static_assert(!is_reference<_Hp>::value,
265 "Attempted to default construct a reference element in a tuple");}
266
Howard Hinnante049cc52010-09-27 17:54:17 +0000267 template <class _Tp,
268 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000269 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000270 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
Howard Hinnant0949eed2011-06-30 21:18:19 +0000271 : value(_VSTD::forward<_Tp>(__t))
Howard Hinnante049cc52010-09-27 17:54:17 +0000272 {static_assert(!is_reference<_Hp>::value ||
Howard Hinnantec3773c2011-12-01 20:21:04 +0000273 (is_lvalue_reference<_Hp>::value &&
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000274 (is_lvalue_reference<_Tp>::value ||
275 is_same<typename remove_reference<_Tp>::type,
276 reference_wrapper<
277 typename remove_reference<_Hp>::type
278 >
Howard Hinnantec3773c2011-12-01 20:21:04 +0000279 >::value)) ||
Howard Hinnante049cc52010-09-27 17:54:17 +0000280 (is_rvalue_reference<_Hp>::value &&
281 !is_lvalue_reference<_Tp>::value),
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000282 "Attempted to construct a reference element in a tuple with an rvalue");}
283
284 template <class _Tp, class _Alloc>
285 _LIBCPP_INLINE_VISIBILITY
286 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000287 : value(_VSTD::forward<_Tp>(__t))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000288 {static_assert(!is_lvalue_reference<_Hp>::value ||
Howard Hinnantec3773c2011-12-01 20:21:04 +0000289 (is_lvalue_reference<_Hp>::value &&
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000290 (is_lvalue_reference<_Tp>::value ||
291 is_same<typename remove_reference<_Tp>::type,
292 reference_wrapper<
293 typename remove_reference<_Hp>::type
294 >
Howard Hinnantec3773c2011-12-01 20:21:04 +0000295 >::value)),
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000296 "Attempted to construct a reference element in a tuple with an rvalue");}
297
298 template <class _Tp, class _Alloc>
299 _LIBCPP_INLINE_VISIBILITY
300 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000301 : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000302 {static_assert(!is_lvalue_reference<_Hp>::value ||
Howard Hinnantec3773c2011-12-01 20:21:04 +0000303 (is_lvalue_reference<_Hp>::value &&
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000304 (is_lvalue_reference<_Tp>::value ||
305 is_same<typename remove_reference<_Tp>::type,
306 reference_wrapper<
307 typename remove_reference<_Hp>::type
308 >
Howard Hinnantec3773c2011-12-01 20:21:04 +0000309 >::value)),
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000310 "Attempted to construct a reference element in a tuple with an rvalue");}
311
312 template <class _Tp, class _Alloc>
313 _LIBCPP_INLINE_VISIBILITY
314 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000315 : value(_VSTD::forward<_Tp>(__t), __a)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000316 {static_assert(!is_lvalue_reference<_Hp>::value ||
Howard Hinnantec3773c2011-12-01 20:21:04 +0000317 (is_lvalue_reference<_Hp>::value &&
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000318 (is_lvalue_reference<_Tp>::value ||
319 is_same<typename remove_reference<_Tp>::type,
320 reference_wrapper<
321 typename remove_reference<_Hp>::type
322 >
Howard Hinnantec3773c2011-12-01 20:21:04 +0000323 >::value)),
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000324 "Attempted to construct a reference element in a tuple with an rvalue");}
325
Howard Hinnant74f26f22012-07-06 21:53:48 +0000326 __tuple_leaf(const __tuple_leaf& __t) _NOEXCEPT_(is_nothrow_copy_constructible<_Hp>::value)
Howard Hinnante049cc52010-09-27 17:54:17 +0000327 : value(__t.get())
328 {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
329
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000330 template <class _Tp>
331 _LIBCPP_INLINE_VISIBILITY
332 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
Howard Hinnant74f26f22012-07-06 21:53:48 +0000333 _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000334 : value(__t.get()) {}
335
336 template <class _Tp>
337 _LIBCPP_INLINE_VISIBILITY
338 __tuple_leaf&
Howard Hinnant74f26f22012-07-06 21:53:48 +0000339 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000340 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000341 value = _VSTD::forward<_Tp>(__t);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000342 return *this;
343 }
344
345 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta5e01212011-05-27 19:08:18 +0000346 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000347 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000348 _VSTD::swap(*this, __t);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000349 return 0;
350 }
351
Howard Hinnant74f26f22012-07-06 21:53:48 +0000352 _LIBCPP_INLINE_VISIBILITY _Hp& get() _NOEXCEPT {return value;}
353 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return value;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000354};
355
356template <size_t _Ip, class _Hp>
357class __tuple_leaf<_Ip, _Hp, true>
358 : private _Hp
359{
360
361 __tuple_leaf& operator=(const __tuple_leaf&);
362public:
Howard Hinnant4eebfc32012-07-06 20:50:27 +0000363 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
364 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000365
366 template <class _Alloc>
367 _LIBCPP_INLINE_VISIBILITY
368 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
369
370 template <class _Alloc>
371 _LIBCPP_INLINE_VISIBILITY
372 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
373 : _Hp(allocator_arg_t(), __a) {}
374
375 template <class _Alloc>
376 _LIBCPP_INLINE_VISIBILITY
377 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
378 : _Hp(__a) {}
379
Howard Hinnante049cc52010-09-27 17:54:17 +0000380 template <class _Tp,
381 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000382 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000383 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
Howard Hinnant0949eed2011-06-30 21:18:19 +0000384 : _Hp(_VSTD::forward<_Tp>(__t)) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000385
386 template <class _Tp, class _Alloc>
387 _LIBCPP_INLINE_VISIBILITY
388 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000389 : _Hp(_VSTD::forward<_Tp>(__t)) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000390
391 template <class _Tp, class _Alloc>
392 _LIBCPP_INLINE_VISIBILITY
393 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000394 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000395
396 template <class _Tp, class _Alloc>
397 _LIBCPP_INLINE_VISIBILITY
398 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000399 : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000400
401 template <class _Tp>
402 _LIBCPP_INLINE_VISIBILITY
403 explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
Howard Hinnant74f26f22012-07-06 21:53:48 +0000404 _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000405 : _Hp(__t.get()) {}
406
407 template <class _Tp>
408 _LIBCPP_INLINE_VISIBILITY
409 __tuple_leaf&
Howard Hinnant74f26f22012-07-06 21:53:48 +0000410 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000411 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000412 _Hp::operator=(_VSTD::forward<_Tp>(__t));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000413 return *this;
414 }
415
Howard Hinnanta5e01212011-05-27 19:08:18 +0000416 _LIBCPP_INLINE_VISIBILITY
417 int
418 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000419 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000420 _VSTD::swap(*this, __t);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000421 return 0;
422 }
423
Howard Hinnant74f26f22012-07-06 21:53:48 +0000424 _LIBCPP_INLINE_VISIBILITY _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
425 _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000426};
427
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000428template <class ..._Tp>
429_LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000430void __swallow(_Tp&&...) _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000431
Howard Hinnanta5e01212011-05-27 19:08:18 +0000432template <bool ...> struct __all;
433
434template <>
435struct __all<>
436{
437 static const bool value = true;
438};
439
Howard Hinnant99968442011-11-29 18:15:50 +0000440template <bool _B0, bool ... _Bp>
441struct __all<_B0, _Bp...>
Howard Hinnanta5e01212011-05-27 19:08:18 +0000442{
Howard Hinnant99968442011-11-29 18:15:50 +0000443 static const bool value = _B0 && __all<_Bp...>::value;
Howard Hinnanta5e01212011-05-27 19:08:18 +0000444};
445
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000446// __tuple_impl
447
448template<class _Indx, class ..._Tp> struct __tuple_impl;
449
450template<size_t ..._Indx, class ..._Tp>
451struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
452 : public __tuple_leaf<_Indx, _Tp>...
453{
Howard Hinnant5394c1e2012-07-06 20:39:45 +0000454 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant4eebfc32012-07-06 20:50:27 +0000455 _LIBCPP_CONSTEXPR __tuple_impl()
456 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
Howard Hinnant5394c1e2012-07-06 20:39:45 +0000457
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000458 template <size_t ..._Uf, class ..._Tf,
459 size_t ..._Ul, class ..._Tl, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000460 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000461 explicit
462 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
463 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
Howard Hinnant74f26f22012-07-06 21:53:48 +0000464 _Up&&... __u)
465 _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
466 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
Howard Hinnant0949eed2011-06-30 21:18:19 +0000467 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000468 __tuple_leaf<_Ul, _Tl>()...
469 {}
470
471 template <class _Alloc, size_t ..._Uf, class ..._Tf,
472 size_t ..._Ul, class ..._Tl, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000473 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000474 explicit
475 __tuple_impl(allocator_arg_t, const _Alloc& __a,
476 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
477 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
478 _Up&&... __u) :
479 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
Howard Hinnant0949eed2011-06-30 21:18:19 +0000480 _VSTD::forward<_Up>(__u))...,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000481 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
482 {}
483
484 template <class _Tuple,
485 class = typename enable_if
486 <
Howard Hinnant99324892013-04-14 00:01:13 +0000487 __tuple_constructible<_Tuple, tuple<_Tp...> >::value
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000488 >::type
489 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000490 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000491 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
492 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
Howard Hinnant0949eed2011-06-30 21:18:19 +0000493 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
494 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000495 {}
496
497 template <class _Alloc, class _Tuple,
498 class = typename enable_if
499 <
Howard Hinnantf83417b2011-01-24 16:07:25 +0000500 __tuple_convertible<_Tuple, tuple<_Tp...> >::value
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000501 >::type
502 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000503 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000504 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
505 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
Howard Hinnant324bb032010-08-22 00:02:43 +0000506 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
Howard Hinnant0949eed2011-06-30 21:18:19 +0000507 _VSTD::forward<typename tuple_element<_Indx,
508 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000509 {}
510
511 template <class _Tuple>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000512 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000513 typename enable_if
514 <
Howard Hinnantf83417b2011-01-24 16:07:25 +0000515 __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000516 __tuple_impl&
517 >::type
Howard Hinnant74f26f22012-07-06 21:53:48 +0000518 operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
519 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000520 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000521 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
522 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000523 return *this;
524 }
525
Howard Hinnant28484442012-02-15 20:13:52 +0000526 _LIBCPP_INLINE_VISIBILITY
527 __tuple_impl&
Howard Hinnant74f26f22012-07-06 21:53:48 +0000528 operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
Howard Hinnant28484442012-02-15 20:13:52 +0000529 {
530 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
531 return *this;
532 }
533
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000534 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000535 void swap(__tuple_impl& __t)
Howard Hinnanta5e01212011-05-27 19:08:18 +0000536 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000537 {
538 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
539 }
540};
541
542template <class ..._Tp>
Howard Hinnant83eade62013-03-06 23:30:19 +0000543class _LIBCPP_TYPE_VIS tuple
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000544{
545 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
546
547 base base_;
548
549 template <size_t _Jp, class ..._Up> friend
Howard Hinnantec3773c2011-12-01 20:21:04 +0000550 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000551 template <size_t _Jp, class ..._Up> friend
Howard Hinnantec3773c2011-12-01 20:21:04 +0000552 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000553 template <size_t _Jp, class ..._Up> friend
Howard Hinnantec3773c2011-12-01 20:21:04 +0000554 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000555public:
556
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000557 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant4eebfc32012-07-06 20:50:27 +0000558 _LIBCPP_CONSTEXPR tuple()
559 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
Howard Hinnant5394c1e2012-07-06 20:39:45 +0000560
561 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000562 explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000563 : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
564 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
565 typename __make_tuple_indices<0>::type(),
566 typename __make_tuple_types<tuple, 0>::type(),
567 __t...
568 ) {}
569
570 template <class _Alloc>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000571 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000572 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
573 : base_(allocator_arg_t(), __a,
574 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
575 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
576 typename __make_tuple_indices<0>::type(),
577 typename __make_tuple_types<tuple, 0>::type(),
578 __t...
579 ) {}
580
581 template <class ..._Up,
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000582 typename enable_if
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000583 <
584 sizeof...(_Up) <= sizeof...(_Tp) &&
585 __tuple_convertible
586 <
587 tuple<_Up...>,
588 typename __make_tuple_types<tuple,
589 sizeof...(_Up) < sizeof...(_Tp) ?
590 sizeof...(_Up) :
591 sizeof...(_Tp)>::type
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000592 >::value,
593 bool
594 >::type = false
595 >
596 _LIBCPP_INLINE_VISIBILITY
597 tuple(_Up&&... __u)
Howard Hinnant74f26f22012-07-06 21:53:48 +0000598 _NOEXCEPT_((
599 is_nothrow_constructible<
600 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 _Up...
605 >::value
606 ))
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000607 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
608 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
609 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
610 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
611 _VSTD::forward<_Up>(__u)...) {}
612
613 template <class ..._Up,
614 typename enable_if
615 <
616 sizeof...(_Up) <= sizeof...(_Tp) &&
617 __tuple_constructible
618 <
619 tuple<_Up...>,
620 typename __make_tuple_types<tuple,
621 sizeof...(_Up) < sizeof...(_Tp) ?
622 sizeof...(_Up) :
623 sizeof...(_Tp)>::type
624 >::value &&
625 !__tuple_convertible
626 <
627 tuple<_Up...>,
628 typename __make_tuple_types<tuple,
629 sizeof...(_Up) < sizeof...(_Tp) ?
630 sizeof...(_Up) :
631 sizeof...(_Tp)>::type
632 >::value,
633 bool
634 >::type =false
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000635 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000636 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000637 explicit
638 tuple(_Up&&... __u)
Howard Hinnant74f26f22012-07-06 21:53:48 +0000639 _NOEXCEPT_((
640 is_nothrow_constructible<
641 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 _Up...
646 >::value
647 ))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000648 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
649 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
650 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
651 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
Howard Hinnant0949eed2011-06-30 21:18:19 +0000652 _VSTD::forward<_Up>(__u)...) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000653
654 template <class _Alloc, class ..._Up,
655 class = typename enable_if
656 <
657 sizeof...(_Up) <= sizeof...(_Tp) &&
658 __tuple_convertible
659 <
660 tuple<_Up...>,
661 typename __make_tuple_types<tuple,
662 sizeof...(_Up) < sizeof...(_Tp) ?
663 sizeof...(_Up) :
664 sizeof...(_Tp)>::type
665 >::value
666 >::type
667 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000668 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000669 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
670 : base_(allocator_arg_t(), __a,
671 typename __make_tuple_indices<sizeof...(_Up)>::type(),
672 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
673 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
674 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
Howard Hinnant0949eed2011-06-30 21:18:19 +0000675 _VSTD::forward<_Up>(__u)...) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000676
677 template <class _Tuple,
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000678 typename enable_if
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000679 <
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000680 __tuple_convertible<_Tuple, tuple>::value,
681 bool
682 >::type = false
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000683 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000684 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000685 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
Howard Hinnant0949eed2011-06-30 21:18:19 +0000686 : base_(_VSTD::forward<_Tuple>(__t)) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000687
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000688 template <class _Tuple,
689 typename enable_if
690 <
691 __tuple_constructible<_Tuple, tuple>::value &&
692 !__tuple_convertible<_Tuple, tuple>::value,
693 bool
694 >::type = false
695 >
696 _LIBCPP_INLINE_VISIBILITY
697 explicit
Howard Hinnant74f26f22012-07-06 21:53:48 +0000698 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
Howard Hinnantdc1345f2012-04-01 23:10:42 +0000699 : base_(_VSTD::forward<_Tuple>(__t)) {}
700
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000701 template <class _Alloc, class _Tuple,
702 class = typename enable_if
703 <
704 __tuple_convertible<_Tuple, tuple>::value
705 >::type
706 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000707 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000708 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000709 : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000710
711 template <class _Tuple,
712 class = typename enable_if
713 <
714 __tuple_assignable<_Tuple, tuple>::value
715 >::type
716 >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000717 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000718 tuple&
Howard Hinnant74f26f22012-07-06 21:53:48 +0000719 operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000720 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000721 base_.operator=(_VSTD::forward<_Tuple>(__t));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000722 return *this;
723 }
724
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000725 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta5e01212011-05-27 19:08:18 +0000726 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
727 {base_.swap(__t.base_);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000728};
729
730template <>
Howard Hinnant83eade62013-03-06 23:30:19 +0000731class _LIBCPP_TYPE_VIS tuple<>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000732{
733public:
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000734 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant4eebfc32012-07-06 20:50:27 +0000735 _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000736 template <class _Alloc>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000737 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000738 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000739 template <class _Alloc>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000740 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000741 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
Howard Hinnant99968442011-11-29 18:15:50 +0000742 template <class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000743 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000744 tuple(array<_Up, 0>) _NOEXCEPT {}
Howard Hinnant99968442011-11-29 18:15:50 +0000745 template <class _Alloc, class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000746 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant74f26f22012-07-06 21:53:48 +0000747 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000748 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta5e01212011-05-27 19:08:18 +0000749 void swap(tuple&) _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000750};
751
752template <class ..._Tp>
753inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaabf2872011-06-01 19:59:32 +0000754typename enable_if
755<
756 __all<__is_swappable<_Tp>::value...>::value,
757 void
758>::type
Howard Hinnanta5e01212011-05-27 19:08:18 +0000759swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
760 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
761 {__t.swap(__u);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000762
763// get
764
765template <size_t _Ip, class ..._Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000766inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantf83417b2011-01-24 16:07:25 +0000767typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnantec3773c2011-12-01 20:21:04 +0000768get(tuple<_Tp...>& __t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000769{
Howard Hinnantf83417b2011-01-24 16:07:25 +0000770 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000771 return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
772}
773
774template <size_t _Ip, class ..._Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000775inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantf83417b2011-01-24 16:07:25 +0000776const typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnantec3773c2011-12-01 20:21:04 +0000777get(const tuple<_Tp...>& __t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000778{
Howard Hinnantf83417b2011-01-24 16:07:25 +0000779 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000780 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
781}
782
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000783template <size_t _Ip, class ..._Tp>
784inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantf83417b2011-01-24 16:07:25 +0000785typename tuple_element<_Ip, tuple<_Tp...> >::type&&
Howard Hinnantec3773c2011-12-01 20:21:04 +0000786get(tuple<_Tp...>&& __t) _NOEXCEPT
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000787{
Howard Hinnantf83417b2011-01-24 16:07:25 +0000788 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Howard Hinnant56a85ca2011-01-25 16:31:30 +0000789 return static_cast<type&&>(
Douglas Gregor6c669942011-01-25 16:14:21 +0000790 static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000791}
792
Marshall Clowe8029e52013-07-13 02:54:05 +0000793#if _LIBCPP_STD_VER > 11
794// get by type
795template <typename _T1, size_t _Idx, typename... _Args>
796struct __find_exactly_one_t_helper;
797
798// -- find exactly one
799template <typename _T1, size_t _Idx, typename... _Args>
800struct __find_exactly_one_t_checker {
801 static constexpr size_t value = _Idx;
802// Check the rest of the list to make sure there's only one
803 static_assert ( __find_exactly_one_t_helper<_T1, 0, _Args...>::value == -1, "type can only occur once in type list" );
804 };
805
806
807template <typename _T1, size_t _Idx>
808struct __find_exactly_one_t_helper <_T1, _Idx> {
809 static constexpr size_t value = -1;
810 };
811
812template <typename _T1, size_t _Idx, typename _Head, typename... _Args>
813struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> {
814 static constexpr size_t value =
815 std::conditional<
816 std::is_same<_T1, _Head>::value,
817 __find_exactly_one_t_checker<_T1, _Idx,   _Args...>,
818 __find_exactly_one_t_helper <_T1, _Idx+1, _Args...>
819 >::type::value;
820 };
821
822template <typename _T1, typename... _Args>
823struct __find_exactly_one_t {
824 static constexpr size_t value = __find_exactly_one_t_helper<_T1, 0, _Args...>::value;
825 static_assert ( value != -1, "type not found in type list" );
826 };
827
828template <class _T1, class... _Args>
829inline _LIBCPP_INLINE_VISIBILITY
830constexpr _T1& get(tuple<_Args...>& __tup) noexcept
831{
832 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
833}
834
835template <class _T1, class... _Args>
836inline _LIBCPP_INLINE_VISIBILITY
837constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
838{
839 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
840}
841
842template <class _T1, class... _Args>
843inline _LIBCPP_INLINE_VISIBILITY
844constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
845{
846 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move<tuple<_Args...>>(__tup));
847}
848
849#endif
850
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000851// tie
852
853template <class ..._Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000854inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000855tuple<_Tp&...>
Howard Hinnant74f26f22012-07-06 21:53:48 +0000856tie(_Tp&... __t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000857{
858 return tuple<_Tp&...>(__t...);
859}
860
861template <class _Up>
862struct __ignore_t
863{
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000864 template <class _Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000865 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000866 const __ignore_t& operator=(_Tp&&) const {return *this;}
867};
868
869namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
870
Howard Hinnant83eade62013-03-06 23:30:19 +0000871template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000872
873template <class _Tp>
874struct ___make_tuple_return
875{
876 typedef _Tp type;
877};
878
879template <class _Tp>
Howard Hinnantf83417b2011-01-24 16:07:25 +0000880struct ___make_tuple_return<reference_wrapper<_Tp> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000881{
882 typedef _Tp& type;
883};
884
885template <class _Tp>
886struct __make_tuple_return
887{
888 typedef typename ___make_tuple_return<typename decay<_Tp>::type>::type type;
889};
890
891template <class... _Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000892inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000893tuple<typename __make_tuple_return<_Tp>::type...>
894make_tuple(_Tp&&... __t)
895{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000896 return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000897}
898
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000899template <class... _Tp>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000900inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000901tuple<_Tp&&...>
Howard Hinnant74f26f22012-07-06 21:53:48 +0000902forward_as_tuple(_Tp&&... __t) _NOEXCEPT
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000903{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000904 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
Howard Hinnant3c1ffba2010-08-19 18:59:38 +0000905}
906
Howard Hinnant99968442011-11-29 18:15:50 +0000907template <size_t _Ip>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000908struct __tuple_equal
909{
910 template <class _Tp, class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000911 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000912 bool operator()(const _Tp& __x, const _Up& __y)
913 {
Howard Hinnant99968442011-11-29 18:15:50 +0000914 return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000915 }
916};
917
918template <>
919struct __tuple_equal<0>
920{
921 template <class _Tp, class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000922 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000923 bool operator()(const _Tp&, const _Up&)
924 {
925 return true;
926 }
927};
928
929template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000930inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000931bool
932operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
933{
934 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
935}
936
937template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000938inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000939bool
940operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
941{
942 return !(__x == __y);
943}
944
Howard Hinnant99968442011-11-29 18:15:50 +0000945template <size_t _Ip>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000946struct __tuple_less
947{
948 template <class _Tp, class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000949 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000950 bool operator()(const _Tp& __x, const _Up& __y)
951 {
Howard Hinnant99968442011-11-29 18:15:50 +0000952 return __tuple_less<_Ip-1>()(__x, __y) ||
953 (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000954 }
955};
956
957template <>
958struct __tuple_less<0>
959{
960 template <class _Tp, class _Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000961 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000962 bool operator()(const _Tp&, const _Up&)
963 {
964 return false;
965 }
966};
967
968template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000969inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000970bool
971operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
972{
973 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
974}
975
976template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000977inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000978bool
979operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
980{
981 return __y < __x;
982}
983
984template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000985inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000986bool
987operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
988{
989 return !(__x < __y);
990}
991
992template <class ..._Tp, class ..._Up>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000993inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000994bool
995operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
996{
997 return !(__y < __x);
998}
999
1000// tuple_cat
1001
Howard Hinnant0e1493e2010-12-11 20:47:50 +00001002template <class _Tp, class _Up> struct __tuple_cat_type;
1003
1004template <class ..._Ttypes, class ..._Utypes>
Howard Hinnantf83417b2011-01-24 16:07:25 +00001005struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001006{
Howard Hinnant0e1493e2010-12-11 20:47:50 +00001007 typedef tuple<_Ttypes..., _Utypes...> type;
1008};
1009
1010template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
1011struct __tuple_cat_return_1
1012{
1013};
1014
1015template <class ..._Types, class _Tuple0>
1016struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
1017{
1018 typedef typename __tuple_cat_type<tuple<_Types...>,
1019 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
1020 type;
1021};
1022
1023template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
1024struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1025 : public __tuple_cat_return_1<
1026 typename __tuple_cat_type<
1027 tuple<_Types...>,
1028 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
1029 >::type,
1030 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
1031 _Tuple1, _Tuples...>
1032{
1033};
1034
1035template <class ..._Tuples> struct __tuple_cat_return;
1036
1037template <class _Tuple0, class ..._Tuples>
1038struct __tuple_cat_return<_Tuple0, _Tuples...>
1039 : public __tuple_cat_return_1<tuple<>,
1040 __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
1041 _Tuples...>
1042{
1043};
1044
1045template <>
1046struct __tuple_cat_return<>
1047{
1048 typedef tuple<> type;
1049};
1050
1051inline _LIBCPP_INLINE_VISIBILITY
1052tuple<>
1053tuple_cat()
1054{
1055 return tuple<>();
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001056}
1057
Howard Hinnant99968442011-11-29 18:15:50 +00001058template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
Howard Hinnante48e3662010-12-12 23:04:37 +00001059struct __tuple_cat_return_ref_imp;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001060
Howard Hinnante48e3662010-12-12 23:04:37 +00001061template <class ..._Types, size_t ..._I0, class _Tuple0>
1062struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001063{
Howard Hinnant0e1493e2010-12-11 20:47:50 +00001064 typedef typename remove_reference<_Tuple0>::type _T0;
Howard Hinnante48e3662010-12-12 23:04:37 +00001065 typedef tuple<_Types..., typename __apply_cv<_Tuple0,
1066 typename tuple_element<_I0, _T0>::type>::type&&...> type;
1067};
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001068
Howard Hinnante48e3662010-12-12 23:04:37 +00001069template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
1070struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
1071 _Tuple0, _Tuple1, _Tuples...>
1072 : public __tuple_cat_return_ref_imp<
1073 tuple<_Types..., typename __apply_cv<_Tuple0,
1074 typename tuple_element<_I0,
1075 typename remove_reference<_Tuple0>::type>::type>::type&&...>,
1076 typename __make_tuple_indices<tuple_size<typename
1077 remove_reference<_Tuple1>::type>::value>::type,
1078 _Tuple1, _Tuples...>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001079{
Howard Hinnante48e3662010-12-12 23:04:37 +00001080};
1081
1082template <class _Tuple0, class ..._Tuples>
1083struct __tuple_cat_return_ref
1084 : public __tuple_cat_return_ref_imp<tuple<>,
1085 typename __make_tuple_indices<
1086 tuple_size<typename remove_reference<_Tuple0>::type>::value
1087 >::type, _Tuple0, _Tuples...>
1088{
1089};
1090
1091template <class _Types, class _I0, class _J0>
1092struct __tuple_cat;
1093
1094template <class ..._Types, size_t ..._I0, size_t ..._J0>
Howard Hinnantf83417b2011-01-24 16:07:25 +00001095struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
Howard Hinnante48e3662010-12-12 23:04:37 +00001096{
1097 template <class _Tuple0>
1098 _LIBCPP_INLINE_VISIBILITY
1099 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1100 operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1101 {
Howard Hinnant0949eed2011-06-30 21:18:19 +00001102 return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
1103 get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
Howard Hinnante48e3662010-12-12 23:04:37 +00001104 }
1105
1106 template <class _Tuple0, class _Tuple1, class ..._Tuples>
1107 _LIBCPP_INLINE_VISIBILITY
1108 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1109 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1110 {
1111 typedef typename remove_reference<_Tuple0>::type _T0;
1112 typedef typename remove_reference<_Tuple1>::type _T1;
1113 return __tuple_cat<
1114 tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1115 typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1116 typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
Howard Hinnant0949eed2011-06-30 21:18:19 +00001117 (_VSTD::forward_as_tuple(
1118 _VSTD::forward<_Types>(get<_I0>(__t))...,
1119 get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
Howard Hinnante48e3662010-12-12 23:04:37 +00001120 ),
Howard Hinnant0949eed2011-06-30 21:18:19 +00001121 _VSTD::forward<_Tuple1>(__t1),
1122 _VSTD::forward<_Tuples>(__tpls)...);
Howard Hinnante48e3662010-12-12 23:04:37 +00001123 }
1124};
1125
1126template <class _Tuple0, class... _Tuples>
1127inline _LIBCPP_INLINE_VISIBILITY
1128typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1129tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1130{
1131 typedef typename remove_reference<_Tuple0>::type _T0;
1132 return __tuple_cat<tuple<>, __tuple_indices<>,
1133 typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
Howard Hinnant0949eed2011-06-30 21:18:19 +00001134 (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1135 _VSTD::forward<_Tuples>(__tpls)...);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001136}
1137
1138template <class ..._Tp, class _Alloc>
Howard Hinnant83eade62013-03-06 23:30:19 +00001139struct _LIBCPP_TYPE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001140 : true_type {};
1141
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001142template <class _T1, class _T2>
1143template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
1144inline _LIBCPP_INLINE_VISIBILITY
1145pair<_T1, _T2>::pair(piecewise_construct_t,
1146 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1147 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
Howard Hinnant0949eed2011-06-30 21:18:19 +00001148 : first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
1149 second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001150{
1151}
1152
Howard Hinnant324bb032010-08-22 00:02:43 +00001153#endif // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001154
1155_LIBCPP_END_NAMESPACE_STD
1156
1157#endif // _LIBCPP_TUPLE