1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP___TUPLE 12 #define _LIBCPP___TUPLE 13 14 #include <__config> 15 #include <cstddef> 16 #include <type_traits> 17 18 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 19 #pragma GCC system_header 20 #endif 21 22 #ifdef _LIBCPP_HAS_NO_VARIADICS 23 24 #include <__tuple_03> 25 26 #else // _LIBCPP_HAS_NO_VARIADICS 27 28 _LIBCPP_BEGIN_NAMESPACE_STD 29 30 // __lazy_and 31 32 template <bool _Last, class ..._Preds> 33 struct __lazy_and_impl; 34 35 template <class ..._Preds> 36 struct __lazy_and_impl<false, _Preds...> : false_type {}; 37 38 template <> 39 struct __lazy_and_impl<true> : true_type {}; 40 41 template <class _Pred> 42 struct __lazy_and_impl<true, _Pred> : integral_constant<bool, _Pred::type::value> {}; 43 44 template <class _Hp, class ..._Tp> 45 struct __lazy_and_impl<true, _Hp, _Tp...> : __lazy_and_impl<_Hp::type::value, _Tp...> {}; 46 47 template <class _P1, class ..._Pr> 48 struct __lazy_and : __lazy_and_impl<_P1::type::value, _Pr...> {}; 49 50 // __lazy_not 51 52 template <class _Pred> 53 struct __lazy_not : integral_constant<bool, !_Pred::type::value> {}; 54 55 56 template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size; 57 58 template <class _Tp> 59 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp> 60 : public tuple_size<_Tp> {}; 61 62 template <class _Tp> 63 class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp> 64 : public tuple_size<_Tp> {}; 65 66 template <class _Tp> 67 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp> 68 : public tuple_size<_Tp> {}; 69 70 template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element; 71 72 template <size_t _Ip, class _Tp> 73 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp> 74 { 75 public: 76 typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type; 77 }; 78 79 template <size_t _Ip, class _Tp> 80 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp> 81 { 82 public: 83 typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type; 84 }; 85 86 template <size_t _Ip, class _Tp> 87 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp> 88 { 89 public: 90 typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; 91 }; 92 93 template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple; 94 template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair; 95 template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array; 96 97 template <class _Tp> struct __tuple_like : false_type {}; 98 99 template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {}; 100 template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {}; 101 template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {}; 102 103 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {}; 104 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {}; 105 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {}; 106 107 template <size_t _Ip, class ..._Tp> 108 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 109 typename tuple_element<_Ip, tuple<_Tp...> >::type& 110 get(tuple<_Tp...>&) _NOEXCEPT; 111 112 template <size_t _Ip, class ..._Tp> 113 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 114 const typename tuple_element<_Ip, tuple<_Tp...> >::type& 115 get(const tuple<_Tp...>&) _NOEXCEPT; 116 117 template <size_t _Ip, class ..._Tp> 118 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 119 typename tuple_element<_Ip, tuple<_Tp...> >::type&& 120 get(tuple<_Tp...>&&) _NOEXCEPT; 121 122 template <size_t _Ip, class _T1, class _T2> 123 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 124 typename tuple_element<_Ip, pair<_T1, _T2> >::type& 125 get(pair<_T1, _T2>&) _NOEXCEPT; 126 127 template <size_t _Ip, class _T1, class _T2> 128 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 129 const typename tuple_element<_Ip, pair<_T1, _T2> >::type& 130 get(const pair<_T1, _T2>&) _NOEXCEPT; 131 132 template <size_t _Ip, class _T1, class _T2> 133 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 134 typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 135 get(pair<_T1, _T2>&&) _NOEXCEPT; 136 137 template <size_t _Ip, class _Tp, size_t _Size> 138 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 139 _Tp& 140 get(array<_Tp, _Size>&) _NOEXCEPT; 141 142 template <size_t _Ip, class _Tp, size_t _Size> 143 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 144 const _Tp& 145 get(const array<_Tp, _Size>&) _NOEXCEPT; 146 147 template <size_t _Ip, class _Tp, size_t _Size> 148 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 149 _Tp&& 150 get(array<_Tp, _Size>&&) _NOEXCEPT; 151 152 // __make_tuple_indices 153 154 template <size_t...> struct __tuple_indices {}; 155 156 template <size_t _Sp, class _IntTuple, size_t _Ep> 157 struct __make_indices_imp; 158 159 template <size_t _Sp, size_t ..._Indices, size_t _Ep> 160 struct __make_indices_imp<_Sp, __tuple_indices<_Indices...>, _Ep> 161 { 162 typedef typename __make_indices_imp<_Sp+1, __tuple_indices<_Indices..., _Sp>, _Ep>::type type; 163 }; 164 165 template <size_t _Ep, size_t ..._Indices> 166 struct __make_indices_imp<_Ep, __tuple_indices<_Indices...>, _Ep> 167 { 168 typedef __tuple_indices<_Indices...> type; 169 }; 170 171 template <size_t _Ep, size_t _Sp = 0> 172 struct __make_tuple_indices 173 { 174 static_assert(_Sp <= _Ep, "__make_tuple_indices input error"); 175 typedef typename __make_indices_imp<_Sp, __tuple_indices<>, _Ep>::type type; 176 }; 177 178 // __tuple_types 179 180 template <class ..._Tp> struct __tuple_types {}; 181 182 template <size_t _Ip> 183 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<> > 184 { 185 public: 186 static_assert(_Ip == 0, "tuple_element index out of range"); 187 static_assert(_Ip != 0, "tuple_element index out of range"); 188 }; 189 190 template <class _Hp, class ..._Tp> 191 class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, __tuple_types<_Hp, _Tp...> > 192 { 193 public: 194 typedef _Hp type; 195 }; 196 197 template <size_t _Ip, class _Hp, class ..._Tp> 198 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Hp, _Tp...> > 199 { 200 public: 201 typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type; 202 }; 203 204 template <class ..._Tp> 205 class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> > 206 : public integral_constant<size_t, sizeof...(_Tp)> 207 { 208 }; 209 210 template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {}; 211 212 // __make_tuple_types 213 214 // __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a 215 // __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep). 216 // _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>. If _Tuple is a 217 // lvalue_reference type, then __tuple_types<_Types&...> is the result. 218 219 template <class _TupleTypes, class _Tp, size_t _Sp, size_t _Ep> 220 struct __make_tuple_types_imp; 221 222 template <class ..._Types, class _Tp, size_t _Sp, size_t _Ep> 223 struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep> 224 { 225 typedef typename remove_reference<_Tp>::type _Tpr; 226 typedef typename __make_tuple_types_imp<__tuple_types<_Types..., 227 typename conditional<is_lvalue_reference<_Tp>::value, 228 typename tuple_element<_Sp, _Tpr>::type&, 229 typename tuple_element<_Sp, _Tpr>::type>::type>, 230 _Tp, _Sp+1, _Ep>::type type; 231 }; 232 233 template <class ..._Types, class _Tp, size_t _Ep> 234 struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Ep, _Ep> 235 { 236 typedef __tuple_types<_Types...> type; 237 }; 238 239 template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0> 240 struct __make_tuple_types 241 { 242 static_assert(_Sp <= _Ep, "__make_tuple_types input error"); 243 typedef typename __make_tuple_types_imp<__tuple_types<>, _Tp, _Sp, _Ep>::type type; 244 }; 245 246 // __tuple_convertible 247 248 template <class, class> 249 struct __tuple_convertible_imp : public false_type {}; 250 251 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up> 252 struct __tuple_convertible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> > 253 : public integral_constant<bool, 254 is_convertible<_Tp0, _Up0>::value && 255 __tuple_convertible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {}; 256 257 template <> 258 struct __tuple_convertible_imp<__tuple_types<>, __tuple_types<> > 259 : public true_type {}; 260 261 template <bool, class, class> 262 struct __tuple_convertible_apply : public false_type {}; 263 264 template <class _Tp, class _Up> 265 struct __tuple_convertible_apply<true, _Tp, _Up> 266 : public __tuple_convertible_imp< 267 typename __make_tuple_types<_Tp>::type 268 , typename __make_tuple_types<_Up>::type 269 > 270 {}; 271 272 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 273 bool = __tuple_like<_Up>::value> 274 struct __tuple_convertible 275 : public false_type {}; 276 277 template <class _Tp, class _Up> 278 struct __tuple_convertible<_Tp, _Up, true, true> 279 : public __tuple_convertible_apply<tuple_size<typename remove_reference<_Tp>::type>::value == 280 tuple_size<_Up>::value, _Tp, _Up> 281 {}; 282 283 // __tuple_constructible 284 285 template <class, class> 286 struct __tuple_constructible_imp : public false_type {}; 287 288 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up> 289 struct __tuple_constructible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> > 290 : public integral_constant<bool, 291 is_constructible<_Up0, _Tp0>::value && 292 __tuple_constructible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {}; 293 294 template <> 295 struct __tuple_constructible_imp<__tuple_types<>, __tuple_types<> > 296 : public true_type {}; 297 298 template <bool _SameSize, class, class> 299 struct __tuple_constructible_apply : public false_type {}; 300 301 template <class _Tp, class _Up> 302 struct __tuple_constructible_apply<true, _Tp, _Up> 303 : public __tuple_constructible_imp< 304 typename __make_tuple_types<_Tp>::type 305 , typename __make_tuple_types<_Up>::type 306 > 307 {}; 308 309 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 310 bool = __tuple_like<_Up>::value> 311 struct __tuple_constructible 312 : public false_type {}; 313 314 template <class _Tp, class _Up> 315 struct __tuple_constructible<_Tp, _Up, true, true> 316 : public __tuple_constructible_apply<tuple_size<typename remove_reference<_Tp>::type>::value == 317 tuple_size<_Up>::value, _Tp, _Up> 318 {}; 319 320 // __tuple_assignable 321 322 template <class, class> 323 struct __tuple_assignable_imp : public false_type {}; 324 325 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up> 326 struct __tuple_assignable_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> > 327 : public integral_constant<bool, 328 is_assignable<_Up0&, _Tp0>::value && 329 __tuple_assignable_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {}; 330 331 template <> 332 struct __tuple_assignable_imp<__tuple_types<>, __tuple_types<> > 333 : public true_type {}; 334 335 template <bool, class, class> 336 struct __tuple_assignable_apply : public false_type {}; 337 338 template <class _Tp, class _Up> 339 struct __tuple_assignable_apply<true, _Tp, _Up> 340 : __tuple_assignable_imp< 341 typename __make_tuple_types<_Tp>::type 342 , typename __make_tuple_types<_Up>::type 343 > 344 {}; 345 346 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 347 bool = __tuple_like<_Up>::value> 348 struct __tuple_assignable 349 : public false_type {}; 350 351 template <class _Tp, class _Up> 352 struct __tuple_assignable<_Tp, _Up, true, true> 353 : public __tuple_assignable_apply<tuple_size<typename remove_reference<_Tp>::type>::value == 354 tuple_size<_Up>::value, _Tp, _Up> 355 {}; 356 357 _LIBCPP_END_NAMESPACE_STD 358 359 #endif // _LIBCPP_HAS_NO_VARIADICS 360 361 #endif // _LIBCPP___TUPLE 362
