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