include/__tuple

   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
  25 template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
  26
  27 template <class _Tp>
  28 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
  29     : public tuple_size<_Tp> {};
  30
  31 template <class _Tp>
  32 class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
  33     : public tuple_size<_Tp> {};
  34
  35 template <class _Tp>
  36 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
  37     : public tuple_size<_Tp> {};
  38
  39 template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
  40
  41 template <size_t _Ip, class _Tp>
  42 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp>
  43 {
  44 public:
  45     typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
  46 };
  47
  48 template <size_t _Ip, class _Tp>
  49 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp>
  50 {
  51 public:
  52     typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
  53 };
  54
  55 template <size_t _Ip, class _Tp>
  56 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
  57 {
  58 public:
  59     typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
  60 };
  61
  62 template <class _Tp> struct __tuple_like : false_type {};
  63
  64 template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
  65 template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
  66 template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
  67
  68 // tuple specializations
  69
  70 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
  71
  72 template <size_t...> struct __tuple_indices {};
  73
  74 template <class _IdxType, _IdxType... _Values>
  75 struct __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)
  84 namespace __detail {
  85
  86 template<typename _Tp, size_t ..._Extra> struct __repeat;
  87 template<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
 100 template<size_t _Np> struct __parity;
 101 template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
 102
 103 template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
 104 template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
 105 template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
 106 template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
 107 template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
 108 template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
 109 template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
 110 template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
 111
 112 template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
 113 template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
 114 template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
 115 template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
 116 template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
 117 template<> 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> {}; };
 118 template<> 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> {}; };
 119 template<> 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)
 126 template <size_t _Ep, size_t _Sp>
 127 using __make_indices_imp =
 128     typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
 129     __to_tuple_indices<_Sp>;
 130 #else
 131 template <size_t _Ep, size_t _Sp>
 132 using __make_indices_imp =
 133     typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
 134
 135 #endif
 136
 137 template <size_t _Ep, size_t _Sp = 0>
 138 struct __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
 145 template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
 146
 147 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
 148
 149 template <size_t _Ip, class ..._Tp>
 150 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 151 typename tuple_element<_Ip, tuple<_Tp...> >::type&
 152 get(tuple<_Tp...>&) _NOEXCEPT;
 153
 154 template <size_t _Ip, class ..._Tp>
 155 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 156 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 157 get(const tuple<_Tp...>&) _NOEXCEPT;
 158
 159 template <size_t _Ip, class ..._Tp>
 160 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 161 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 162 get(tuple<_Tp...>&&) _NOEXCEPT;
 163
 164 template <size_t _Ip, class ..._Tp>
 165 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 166 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 167 get(const tuple<_Tp...>&&) _NOEXCEPT;
 168 #endif
 169
 170 // pair specializations
 171
 172 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 173
 174 template <size_t _Ip, class _T1, class _T2>
 175 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 176 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 177 get(pair<_T1, _T2>&) _NOEXCEPT;
 178
 179 template <size_t _Ip, class _T1, class _T2>
 180 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 181 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 182 get(const pair<_T1, _T2>&) _NOEXCEPT;
 183
 184 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 185 template <size_t _Ip, class _T1, class _T2>
 186 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 187 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 188 get(pair<_T1, _T2>&&) _NOEXCEPT;
 189
 190 template <size_t _Ip, class _T1, class _T2>
 191 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 192 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 193 get(const pair<_T1, _T2>&&) _NOEXCEPT;
 194 #endif
 195
 196 // array specializations
 197
 198 template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
 199
 200 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
 201
 202 template <size_t _Ip, class _Tp, size_t _Size>
 203 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 204 _Tp&
 205 get(array<_Tp, _Size>&) _NOEXCEPT;
 206
 207 template <size_t _Ip, class _Tp, size_t _Size>
 208 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 209 const _Tp&
 210 get(const array<_Tp, _Size>&) _NOEXCEPT;
 211
 212 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 213 template <size_t _Ip, class _Tp, size_t _Size>
 214 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 215 _Tp&&
 216 get(array<_Tp, _Size>&&) _NOEXCEPT;
 217
 218 template <size_t _Ip, class _Tp, size_t _Size>
 219 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 220 const _Tp&&
 221 get(const array<_Tp, _Size>&&) _NOEXCEPT;
 222 #endif
 223
 224 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
 225
 226
 227 // __tuple_types
 228
 229 template <class ..._Tp> struct __tuple_types {};
 230
 231 #if !__has_builtin(__type_pack_element)
 232
 233 namespace __indexer_detail {
 234
 235 template <size_t _Idx, class _Tp>
 236 struct __indexed { using type = _Tp; };
 237
 238 template <class _Types, class _Indexes> struct __indexer;
 239
 240 template <class ..._Types, size_t ..._Idx>
 241 struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
 242     : __indexed<_Idx, _Types>...
 243 {};
 244
 245 template <size_t _Idx, class _Tp>
 246 __indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
 247
 248 } // namespace __indexer_detail
 249
 250 template <size_t _Idx, class ..._Types>
 251 using __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 #endif
 259
 260 template <size_t _Ip, class ..._Types>
 261 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Types...>>
 262 {
 263 public:
 264     static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
 265     typedef __type_pack_element<_Ip, _Types...> type;
 266 };
 267
 268
 269 template <class ..._Tp>
 270 class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
 271     : public integral_constant<size_t, sizeof...(_Tp)>
 272 {
 273 };
 274
 275 template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
 276
 277 template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
 278 struct __apply_cv_mf;
 279 template <>
 280 struct __apply_cv_mf<false, false, false> {
 281   template <class _Tp> using __apply = _Tp;
 282 };
 283 template <>
 284 struct __apply_cv_mf<false, true, false> {
 285   template <class _Tp> using __apply = const _Tp;
 286 };
 287 template <>
 288 struct __apply_cv_mf<false, false, true> {
 289   template <class _Tp> using __apply = volatile _Tp;
 290 };
 291 template <>
 292 struct __apply_cv_mf<false, true, true> {
 293   template <class _Tp> using __apply = const volatile _Tp;
 294 };
 295 template <>
 296 struct __apply_cv_mf<true, false, false> {
 297   template <class _Tp> using __apply = _Tp&;
 298 };
 299 template <>
 300 struct __apply_cv_mf<true, true, false> {
 301   template <class _Tp> using __apply = const _Tp&;
 302 };
 303 template <>
 304 struct __apply_cv_mf<true, false, true> {
 305   template <class _Tp> using __apply = volatile _Tp&;
 306 };
 307 template <>
 308 struct __apply_cv_mf<true, true, true> {
 309   template <class _Tp> using __apply = const volatile _Tp&;
 310 };
 311 template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
 312 using __apply_cv_t = __apply_cv_mf<
 313     is_lvalue_reference<_Tp>::value,
 314     is_const<_RawTp>::value,
 315     is_volatile<_RawTp>::value>;
 316
 317 // __make_tuple_types
 318
 319 // __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
 324 template <class _TupleTypes, class _TupleIndices>
 325 struct __make_tuple_types_flat;
 326
 327 template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
 328 struct __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     >;
 334 };
 335
 336 template <class _Vt, size_t _Np, size_t ..._Idx>
 337 struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
 338   template <size_t>
 339   using __value_type = _Vt;
 340   template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
 341   using __apply_quals = __tuple_types<
 342       typename _ApplyFn::template __apply<__value_type<_Idx>>...
 343     >;
 344 };
 345
 346 template <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)>
 349 struct __make_tuple_types
 350 {
 351     static_assert(_Sp <= _Ep, "__make_tuple_types input error");
 352     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
 357 template <class ..._Types, size_t _Ep>
 358 struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
 359   typedef __tuple_types<_Types...> type;
 360 };
 361
 362 template <class ..._Types, size_t _Ep>
 363 struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
 364   typedef __tuple_types<_Types...> type;
 365 };
 366
 367 template <bool ..._Preds>
 368 struct __all_dummy;
 369
 370 template <bool ..._Pred>
 371 using __all = is_same<__all_dummy<_Pred...>, __all_dummy<(_Pred, true)...>>;
 372
 373 struct __tuple_sfinae_base {
 374   template <template <class, class...> class _Trait,
 375             class ..._LArgs, class ..._RArgs>
 376   static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
 377     -> __all<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{true}...>;
 378   template <template <class...> class>
 379   static auto __do_test(...) -> false_type;
 380
 381   template <class _FromArgs, class _ToArgs>
 382   using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
 383   template <class _FromArgs, class _ToArgs>
 384   using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
 385   template <class _FromArgs, class _ToArgs>
 386   using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
 387 };
 388
 389 // __tuple_convertible
 390
 391 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 392                                 bool = __tuple_like<_Up>::value>
 393 struct __tuple_convertible
 394     : public false_type {};
 395
 396 template <class _Tp, class _Up>
 397 struct __tuple_convertible<_Tp, _Up, true, true>
 398     : public __tuple_sfinae_base::__convertible<
 399       typename __make_tuple_types<_Tp>::type
 400     , typename __make_tuple_types<_Up>::type
 401     >
 402 {};
 403
 404 // __tuple_constructible
 405
 406 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 407                                 bool = __tuple_like<_Up>::value>
 408 struct __tuple_constructible
 409     : public false_type {};
 410
 411 template <class _Tp, class _Up>
 412 struct __tuple_constructible<_Tp, _Up, true, true>
 413     : public __tuple_sfinae_base::__constructible<
 414       typename __make_tuple_types<_Tp>::type
 415     , typename __make_tuple_types<_Up>::type
 416     >
 417 {};
 418
 419 // __tuple_assignable
 420
 421 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 422                                 bool = __tuple_like<_Up>::value>
 423 struct __tuple_assignable
 424     : public false_type {};
 425
 426 template <class _Tp, class _Up>
 427 struct __tuple_assignable<_Tp, _Up, true, true>
 428     : public __tuple_sfinae_base::__assignable<
 429       typename __make_tuple_types<_Tp>::type
 430     , typename __make_tuple_types<_Up&>::type
 431     >
 432 {};
 433
 434 #endif  // _LIBCPP_HAS_NO_VARIADICS
 435
 436 _LIBCPP_END_NAMESPACE_STD
 437
 438 #endif  // _LIBCPP___TUPLE