blob: 4cafc6b5640d2ac513d17b6f1d6e55de13638ef2 [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
Howard Hinnantc566dc32010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantc51e1022010-05-11 19:42:16 +00005//
Howard Hinnantee11c312010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantc51e1022010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP___TUPLE
12#define _LIBCPP___TUPLE
13
14#include <__config>
15#include <cstddef>
16#include <type_traits>
17
Howard Hinnantaaaa52b2011-10-17 20:05:10 +000018#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +000019#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +000020#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +000021
Howard Hinnantc51e1022010-05-11 19:42:16 +000022
23_LIBCPP_BEGIN_NAMESPACE_STD
24
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000025template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000026
27template <class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000028class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000029 : public tuple_size<_Tp> {};
30
31template <class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000032class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000033 : public tuple_size<_Tp> {};
34
35template <class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000036class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000037 : public tuple_size<_Tp> {};
38
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000039template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
Howard Hinnantc51e1022010-05-11 19:42:16 +000040
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000041template <size_t _Ip, class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000042class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000043{
44public:
45 typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
46};
47
48template <size_t _Ip, class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000049class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000050{
51public:
52 typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
53};
54
55template <size_t _Ip, class _Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +000056class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
Howard Hinnant15ab6eb2010-11-17 19:22:43 +000057{
58public:
59 typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
60};
61
Howard Hinnantc51e1022010-05-11 19:42:16 +000062template <class _Tp> struct __tuple_like : false_type {};
63
Howard Hinnant6256ee72010-12-11 20:47:50 +000064template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
65template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
66template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
67
Eric Fiseliere80441d2015-03-17 15:08:03 +000068// tuple specializations
69
70#if !defined(_LIBCPP_HAS_NO_VARIADICS)
Eric Fiselier2079cc72016-06-30 22:34:43 +000071
72template <size_t...> struct __tuple_indices {};
73
74template <class _IdxType, _IdxType... _Values>
75struct __integer_sequence {
76 template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>
77 using __convert = _ToIndexSeq<_ToIndexType, _Values...>;
78
79 template <size_t _Sp>
80 using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
81};
82
83#if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
84namespace __detail {
85
86template<typename _Tp, size_t ..._Extra> struct __repeat;
87template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
88 typedef __integer_sequence<_Tp,
89 _Np...,
90 sizeof...(_Np) + _Np...,
91 2 * sizeof...(_Np) + _Np...,
92 3 * sizeof...(_Np) + _Np...,
93 4 * sizeof...(_Np) + _Np...,
94 5 * sizeof...(_Np) + _Np...,
95 6 * sizeof...(_Np) + _Np...,
96 7 * sizeof...(_Np) + _Np...,
97 _Extra...> type;
98};
99
100template<size_t _Np> struct __parity;
101template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
102
103template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
104template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
105template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
106template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
107template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
108template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
109template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
110template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
111
112template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
113template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
114template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
115template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
116template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
117template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
118template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
119template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
120
121} // namespace detail
122
123#endif // !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
124
125#if __has_builtin(__make_integer_seq)
126template <size_t _Ep, size_t _Sp>
127using __make_indices_imp =
128 typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
129 __to_tuple_indices<_Sp>;
130#else
131template <size_t _Ep, size_t _Sp>
132using __make_indices_imp =
133 typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
134
135#endif
136
137template <size_t _Ep, size_t _Sp = 0>
138struct __make_tuple_indices
139{
140 static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
141 typedef __make_indices_imp<_Ep, _Sp> type;
142};
143
144
Eric Fiseliere80441d2015-03-17 15:08:03 +0000145template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
146
Howard Hinnant3a47c3d2011-01-24 16:07:25 +0000147template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000148
Howard Hinnantc51e1022010-05-11 19:42:16 +0000149template <size_t _Ip, class ..._Tp>
Marshall Clow0abb1042013-07-17 18:25:36 +0000150_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant3a47c3d2011-01-24 16:07:25 +0000151typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000152get(tuple<_Tp...>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000153
154template <size_t _Ip, class ..._Tp>
Marshall Clow0abb1042013-07-17 18:25:36 +0000155_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant3a47c3d2011-01-24 16:07:25 +0000156const typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000157get(const tuple<_Tp...>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000158
Howard Hinnant22e97242010-11-17 19:52:17 +0000159template <size_t _Ip, class ..._Tp>
Marshall Clow0abb1042013-07-17 18:25:36 +0000160_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant3a47c3d2011-01-24 16:07:25 +0000161typename tuple_element<_Ip, tuple<_Tp...> >::type&&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000162get(tuple<_Tp...>&&) _NOEXCEPT;
Eric Fiselier6dea8092015-12-18 00:36:55 +0000163
164template <size_t _Ip, class ..._Tp>
165_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
166const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
167get(const tuple<_Tp...>&&) _NOEXCEPT;
Eric Fiseliere80441d2015-03-17 15:08:03 +0000168#endif
169
170// pair specializations
171
Eric Fiseliere80441d2015-03-17 15:08:03 +0000172template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
Howard Hinnant22e97242010-11-17 19:52:17 +0000173
Howard Hinnantc51e1022010-05-11 19:42:16 +0000174template <size_t _Ip, class _T1, class _T2>
Marshall Clow0abb1042013-07-17 18:25:36 +0000175_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +0000176typename tuple_element<_Ip, pair<_T1, _T2> >::type&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000177get(pair<_T1, _T2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000178
179template <size_t _Ip, class _T1, class _T2>
Marshall Clow0abb1042013-07-17 18:25:36 +0000180_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +0000181const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000182get(const pair<_T1, _T2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000183
Eric Fiseliere80441d2015-03-17 15:08:03 +0000184#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
Howard Hinnant22e97242010-11-17 19:52:17 +0000185template <size_t _Ip, class _T1, class _T2>
Marshall Clow0abb1042013-07-17 18:25:36 +0000186_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant22e97242010-11-17 19:52:17 +0000187typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
Howard Hinnant89ef1212011-05-27 19:08:18 +0000188get(pair<_T1, _T2>&&) _NOEXCEPT;
Eric Fiselier6dea8092015-12-18 00:36:55 +0000189
190template <size_t _Ip, class _T1, class _T2>
191_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
192const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
193get(const pair<_T1, _T2>&&) _NOEXCEPT;
Eric Fiseliere80441d2015-03-17 15:08:03 +0000194#endif
195
196// array specializations
197
198template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
199
200template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
Howard Hinnant22e97242010-11-17 19:52:17 +0000201
Howard Hinnantc51e1022010-05-11 19:42:16 +0000202template <size_t _Ip, class _Tp, size_t _Size>
Marshall Clow0abb1042013-07-17 18:25:36 +0000203_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +0000204_Tp&
Howard Hinnant32477e82011-05-31 21:06:33 +0000205get(array<_Tp, _Size>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000206
207template <size_t _Ip, class _Tp, size_t _Size>
Marshall Clow0abb1042013-07-17 18:25:36 +0000208_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +0000209const _Tp&
Howard Hinnant32477e82011-05-31 21:06:33 +0000210get(const array<_Tp, _Size>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000211
Eric Fiseliere80441d2015-03-17 15:08:03 +0000212#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
Howard Hinnant22e97242010-11-17 19:52:17 +0000213template <size_t _Ip, class _Tp, size_t _Size>
Marshall Clow0abb1042013-07-17 18:25:36 +0000214_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant22e97242010-11-17 19:52:17 +0000215_Tp&&
Howard Hinnant32477e82011-05-31 21:06:33 +0000216get(array<_Tp, _Size>&&) _NOEXCEPT;
Eric Fiselier6dea8092015-12-18 00:36:55 +0000217
218template <size_t _Ip, class _Tp, size_t _Size>
219_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
220const _Tp&&
221get(const array<_Tp, _Size>&&) _NOEXCEPT;
Eric Fiseliere80441d2015-03-17 15:08:03 +0000222#endif
223
224#if !defined(_LIBCPP_HAS_NO_VARIADICS)
225
Howard Hinnantc51e1022010-05-11 19:42:16 +0000226
227// __tuple_types
228
229template <class ..._Tp> struct __tuple_types {};
230
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000231#if !__has_builtin(__type_pack_element)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000232
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000233namespace __indexer_detail {
Howard Hinnantc51e1022010-05-11 19:42:16 +0000234
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000235template <size_t _Idx, class _Tp>
236struct __indexed { using type = _Tp; };
237
238template <class _Types, class _Indexes> struct __indexer;
239
240template <class ..._Types, size_t ..._Idx>
241struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
242 : __indexed<_Idx, _Types>...
243{};
244
245template <size_t _Idx, class _Tp>
246__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
247
248} // namespace __indexer_detail
249
250template <size_t _Idx, class ..._Types>
251using __type_pack_element = typename decltype(
252 __indexer_detail::__at_index<_Idx>(
253 __indexer_detail::__indexer<
254 __tuple_types<_Types...>,
255 typename __make_tuple_indices<sizeof...(_Types)>::type
256 >{})
257 )::type;
258
259#endif
260
261template <size_t _Ip, class ..._Types>
262class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Types...>>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000263{
264public:
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000265 static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
266 typedef __type_pack_element<_Ip, _Types...> type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000267};
268
269template <class ..._Tp>
Howard Hinnanta37d3cf2013-08-12 18:38:34 +0000270class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
Howard Hinnantc51e1022010-05-11 19:42:16 +0000271 : public integral_constant<size_t, sizeof...(_Tp)>
272{
273};
274
Howard Hinnant3a47c3d2011-01-24 16:07:25 +0000275template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000276
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000277template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
278struct __apply_cv_mf;
279template <>
280struct __apply_cv_mf<false, false, false> {
281 template <class _Tp> using __apply = _Tp;
282};
283template <>
284struct __apply_cv_mf<false, true, false> {
285 template <class _Tp> using __apply = const _Tp;
286};
287template <>
288struct __apply_cv_mf<false, false, true> {
289 template <class _Tp> using __apply = volatile _Tp;
290};
291template <>
292struct __apply_cv_mf<false, true, true> {
293 template <class _Tp> using __apply = const volatile _Tp;
294};
295template <>
296struct __apply_cv_mf<true, false, false> {
297 template <class _Tp> using __apply = _Tp&;
298};
299template <>
300struct __apply_cv_mf<true, true, false> {
301 template <class _Tp> using __apply = const _Tp&;
302};
303template <>
304struct __apply_cv_mf<true, false, true> {
305 template <class _Tp> using __apply = volatile _Tp&;
306};
307template <>
308struct __apply_cv_mf<true, true, true> {
309 template <class _Tp> using __apply = const volatile _Tp&;
310};
311template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
312using __apply_cv_t = __apply_cv_mf<
313 is_lvalue_reference<_Tp>::value,
314 is_const<_RawTp>::value,
315 is_volatile<_RawTp>::value>;
316
Howard Hinnantc51e1022010-05-11 19:42:16 +0000317// __make_tuple_types
318
Howard Hinnant693fc212010-09-27 17:54:17 +0000319// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
320// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
321// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>. If _Tuple is a
322// lvalue_reference type, then __tuple_types<_Types&...> is the result.
323
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000324template <class _TupleTypes, class _TupleIndices>
325struct __make_tuple_types_flat;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000326
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000327template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
328struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
329 // Specialization for pair, tuple, and __tuple_types
330 template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
331 using __apply_quals = __tuple_types<
332 typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>...
333 >;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000334};
335
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000336template <class _Vt, size_t _Np, size_t ..._Idx>
337struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
338 using _Array = array<_Vt, _Np>;
339
340 template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
341 using __apply_quals = __tuple_types<
342 typename _ApplyFn::template __apply<typename tuple_element<_Idx, _Array>::type>...
343 >;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000344};
345
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000346template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value,
347 size_t _Sp = 0,
348 bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000349struct __make_tuple_types
350{
351 static_assert(_Sp <= _Ep, "__make_tuple_types input error");
Eric Fiseliera1ef3b22016-07-01 03:54:54 +0000352 using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type;
353 using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
354 using type = typename _Maker::template __apply_quals<_Tp>;
355};
356
357template <class ..._Types, size_t _Ep>
358struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
359 typedef __tuple_types<_Types...> type;
360};
361
362template <class ..._Types, size_t _Ep>
363struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
364 typedef __tuple_types<_Types...> type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000365};
366
Howard Hinnantc51e1022010-05-11 19:42:16 +0000367// __tuple_convertible
368
Eric Fiselier99337852014-10-28 06:31:22 +0000369template <class, class>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000370struct __tuple_convertible_imp : public false_type {};
371
372template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
Eric Fiselier99337852014-10-28 06:31:22 +0000373struct __tuple_convertible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
Howard Hinnantc51e1022010-05-11 19:42:16 +0000374 : public integral_constant<bool,
Howard Hinnant65704d02012-04-01 23:10:42 +0000375 is_convertible<_Tp0, _Up0>::value &&
Eric Fiselier99337852014-10-28 06:31:22 +0000376 __tuple_convertible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000377
378template <>
Eric Fiselier99337852014-10-28 06:31:22 +0000379struct __tuple_convertible_imp<__tuple_types<>, __tuple_types<> >
Howard Hinnantc51e1022010-05-11 19:42:16 +0000380 : public true_type {};
381
Eric Fiselier99337852014-10-28 06:31:22 +0000382template <bool, class, class>
383struct __tuple_convertible_apply : public false_type {};
384
385template <class _Tp, class _Up>
386struct __tuple_convertible_apply<true, _Tp, _Up>
387 : public __tuple_convertible_imp<
388 typename __make_tuple_types<_Tp>::type
389 , typename __make_tuple_types<_Up>::type
390 >
391{};
392
Howard Hinnantc51e1022010-05-11 19:42:16 +0000393template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
394 bool = __tuple_like<_Up>::value>
395struct __tuple_convertible
396 : public false_type {};
397
398template <class _Tp, class _Up>
399struct __tuple_convertible<_Tp, _Up, true, true>
Eric Fiselier99337852014-10-28 06:31:22 +0000400 : public __tuple_convertible_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
401 tuple_size<_Up>::value, _Tp, _Up>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000402{};
403
Howard Hinnant65704d02012-04-01 23:10:42 +0000404// __tuple_constructible
405
Eric Fiselier99337852014-10-28 06:31:22 +0000406template <class, class>
Howard Hinnant65704d02012-04-01 23:10:42 +0000407struct __tuple_constructible_imp : public false_type {};
408
409template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
Eric Fiselier99337852014-10-28 06:31:22 +0000410struct __tuple_constructible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
Howard Hinnant65704d02012-04-01 23:10:42 +0000411 : public integral_constant<bool,
412 is_constructible<_Up0, _Tp0>::value &&
Eric Fiselier99337852014-10-28 06:31:22 +0000413 __tuple_constructible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
Howard Hinnant65704d02012-04-01 23:10:42 +0000414
415template <>
Eric Fiselier99337852014-10-28 06:31:22 +0000416struct __tuple_constructible_imp<__tuple_types<>, __tuple_types<> >
Howard Hinnant65704d02012-04-01 23:10:42 +0000417 : public true_type {};
418
Eric Fiselier99337852014-10-28 06:31:22 +0000419template <bool _SameSize, class, class>
420struct __tuple_constructible_apply : public false_type {};
421
422template <class _Tp, class _Up>
423struct __tuple_constructible_apply<true, _Tp, _Up>
424 : public __tuple_constructible_imp<
425 typename __make_tuple_types<_Tp>::type
426 , typename __make_tuple_types<_Up>::type
427 >
428{};
429
Howard Hinnant65704d02012-04-01 23:10:42 +0000430template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
431 bool = __tuple_like<_Up>::value>
432struct __tuple_constructible
433 : public false_type {};
434
435template <class _Tp, class _Up>
436struct __tuple_constructible<_Tp, _Up, true, true>
Eric Fiselier99337852014-10-28 06:31:22 +0000437 : public __tuple_constructible_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
438 tuple_size<_Up>::value, _Tp, _Up>
Howard Hinnant65704d02012-04-01 23:10:42 +0000439{};
440
Howard Hinnantc51e1022010-05-11 19:42:16 +0000441// __tuple_assignable
442
Eric Fiselier99337852014-10-28 06:31:22 +0000443template <class, class>
Howard Hinnant693fc212010-09-27 17:54:17 +0000444struct __tuple_assignable_imp : public false_type {};
445
446template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
Eric Fiselier99337852014-10-28 06:31:22 +0000447struct __tuple_assignable_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
Howard Hinnant693fc212010-09-27 17:54:17 +0000448 : public integral_constant<bool,
Howard Hinnant35255ad2010-11-20 18:25:22 +0000449 is_assignable<_Up0&, _Tp0>::value &&
Eric Fiselier99337852014-10-28 06:31:22 +0000450 __tuple_assignable_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
Howard Hinnant693fc212010-09-27 17:54:17 +0000451
452template <>
Eric Fiselier99337852014-10-28 06:31:22 +0000453struct __tuple_assignable_imp<__tuple_types<>, __tuple_types<> >
Howard Hinnant693fc212010-09-27 17:54:17 +0000454 : public true_type {};
455
Eric Fiselier99337852014-10-28 06:31:22 +0000456template <bool, class, class>
457struct __tuple_assignable_apply : public false_type {};
458
459template <class _Tp, class _Up>
460struct __tuple_assignable_apply<true, _Tp, _Up>
461 : __tuple_assignable_imp<
462 typename __make_tuple_types<_Tp>::type
463 , typename __make_tuple_types<_Up>::type
464 >
465{};
466
Howard Hinnantc51e1022010-05-11 19:42:16 +0000467template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
468 bool = __tuple_like<_Up>::value>
469struct __tuple_assignable
470 : public false_type {};
471
472template <class _Tp, class _Up>
473struct __tuple_assignable<_Tp, _Up, true, true>
Eric Fiselier99337852014-10-28 06:31:22 +0000474 : public __tuple_assignable_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
475 tuple_size<_Up>::value, _Tp, _Up>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000476{};
477
Howard Hinnantc51e1022010-05-11 19:42:16 +0000478#endif // _LIBCPP_HAS_NO_VARIADICS
479
Eric Fiseliere80441d2015-03-17 15:08:03 +0000480_LIBCPP_END_NAMESPACE_STD
481
Howard Hinnantc51e1022010-05-11 19:42:16 +0000482#endif // _LIBCPP___TUPLE