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