1 // -*- C++ -*- 2 //===--------------------------- tuple ------------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 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 17 namespace std 18 { 19 20 template <class... T> 21 class tuple { 22 public: 23 constexpr tuple(); 24 explicit tuple(const T&...); // constexpr in C++14 25 template <class... U> 26 explicit tuple(U&&...); // constexpr in C++14 27 tuple(const tuple&) = default; 28 tuple(tuple&&) = default; 29 template <class... U> 30 tuple(const tuple<U...>&); // constexpr in C++14 31 template <class... U> 32 tuple(tuple<U...>&&); // constexpr in C++14 33 template <class U1, class U2> 34 tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14 35 template <class U1, class U2> 36 tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14 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&); 59 tuple& 60 operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...)); 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 70 void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); 71 }; 72 73 const unspecified ignore; 74 75 template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14 76 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14 77 template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14 78 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14 79 80 // 20.4.1.4, tuple helper classes: 81 template <class T> class tuple_size; // undefined 82 template <class... T> class tuple_size<tuple<T...>>; 83 template <intsize_t I, class T> class tuple_element; // undefined 84 template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>; 85 template <size_t _Ip, class ..._Tp> 86 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type; // C++14 87 88 // 20.4.1.5, element access: 89 template <intsize_t I, class... T> 90 typename tuple_element<I, tuple<T...>>::type& 91 get(tuple<T...>&) noexcept; // constexpr in C++14 92 template <intsize_t I, class... T> 93 typename const tuple_element<I, tuple<T...>>::type & 94 get(const tuple<T...>&) noexcept; // constexpr in C++14 95 template <intsize_t I, class... T> 96 typename tuple_element<I, tuple<T...>>::type&& 97 get(tuple<T...>&&) noexcept; // constexpr in C++14 98 99 template <class T1, class... T> 100 constexpr T1& get(tuple<T...>&) noexcept; // C++14 101 template <class T1, class... T> 102 constexpr T1 const& get(const tuple<T...>&) noexcept; // C++14 103 template <class T1, class... T> 104 constexpr T1&& get(tuple<T...>&&) noexcept; // C++14 105 106 // 20.4.1.6, relational operators: 107 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 108 template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 109 template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 110 template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 111 template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 112 template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14 113 114 template <class... Types, class Alloc> 115 struct uses_allocator<tuple<Types...>, Alloc>; 116 117 template <class... Types> 118 void 119 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y))); 120 121 } // std 122 123 */ 124 125 #include <__config> 126 #include <__tuple> 127 #include <cstddef> 128 #include <type_traits> 129 #include <__functional_base> 130 #include <utility> 131 132 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 133 #pragma GCC system_header 134 #endif 135 136 _LIBCPP_BEGIN_NAMESPACE_STD 137 138 #ifndef _LIBCPP_HAS_NO_VARIADICS 139 140 // tuple_size 141 142 template <class ..._Tp> 143 class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> > 144 : public integral_constant<size_t, sizeof...(_Tp)> 145 { 146 }; 147 148 // tuple_element 149 150 template <size_t _Ip, class ..._Tp> 151 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> > 152 { 153 public: 154 typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; 155 }; 156 157 #if _LIBCPP_STD_VER > 11 158 template <size_t _Ip, class ..._Tp> 159 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type; 160 #endif 161 162 // __tuple_leaf 163 164 template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value 165 #if __has_feature(is_final) 166 && !__is_final(_Hp) 167 #endif 168 > 169 class __tuple_leaf; 170 171 template <size_t _Ip, class _Hp, bool _Ep> 172 inline _LIBCPP_INLINE_VISIBILITY 173 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y) 174 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value) 175 { 176 swap(__x.get(), __y.get()); 177 } 178 179 template <size_t _Ip, class _Hp, bool> 180 class __tuple_leaf 181 { 182 _Hp value; 183 184 __tuple_leaf& operator=(const __tuple_leaf&); 185 public: 186 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf() 187 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value() 188 {static_assert(!is_reference<_Hp>::value, 189 "Attempted to default construct a reference element in a tuple");} 190 191 template <class _Alloc> 192 _LIBCPP_INLINE_VISIBILITY 193 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) 194 : value() 195 {static_assert(!is_reference<_Hp>::value, 196 "Attempted to default construct a reference element in a tuple");} 197 198 template <class _Alloc> 199 _LIBCPP_INLINE_VISIBILITY 200 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a) 201 : value(allocator_arg_t(), __a) 202 {static_assert(!is_reference<_Hp>::value, 203 "Attempted to default construct a reference element in a tuple");} 204 205 template <class _Alloc> 206 _LIBCPP_INLINE_VISIBILITY 207 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a) 208 : value(__a) 209 {static_assert(!is_reference<_Hp>::value, 210 "Attempted to default construct a reference element in a tuple");} 211 212 template <class _Tp, 213 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type> 214 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 215 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) 216 : value(_VSTD::forward<_Tp>(__t)) 217 {static_assert(!is_reference<_Hp>::value || 218 (is_lvalue_reference<_Hp>::value && 219 (is_lvalue_reference<_Tp>::value || 220 is_same<typename remove_reference<_Tp>::type, 221 reference_wrapper< 222 typename remove_reference<_Hp>::type 223 > 224 >::value)) || 225 (is_rvalue_reference<_Hp>::value && 226 !is_lvalue_reference<_Tp>::value), 227 "Attempted to construct a reference element in a tuple with an rvalue");} 228 229 template <class _Tp, class _Alloc> 230 _LIBCPP_INLINE_VISIBILITY 231 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t) 232 : value(_VSTD::forward<_Tp>(__t)) 233 {static_assert(!is_lvalue_reference<_Hp>::value || 234 (is_lvalue_reference<_Hp>::value && 235 (is_lvalue_reference<_Tp>::value || 236 is_same<typename remove_reference<_Tp>::type, 237 reference_wrapper< 238 typename remove_reference<_Hp>::type 239 > 240 >::value)), 241 "Attempted to construct a reference element in a tuple with an rvalue");} 242 243 template <class _Tp, class _Alloc> 244 _LIBCPP_INLINE_VISIBILITY 245 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t) 246 : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) 247 {static_assert(!is_lvalue_reference<_Hp>::value || 248 (is_lvalue_reference<_Hp>::value && 249 (is_lvalue_reference<_Tp>::value || 250 is_same<typename remove_reference<_Tp>::type, 251 reference_wrapper< 252 typename remove_reference<_Hp>::type 253 > 254 >::value)), 255 "Attempted to construct a reference element in a tuple with an rvalue");} 256 257 template <class _Tp, class _Alloc> 258 _LIBCPP_INLINE_VISIBILITY 259 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t) 260 : value(_VSTD::forward<_Tp>(__t), __a) 261 {static_assert(!is_lvalue_reference<_Hp>::value || 262 (is_lvalue_reference<_Hp>::value && 263 (is_lvalue_reference<_Tp>::value || 264 is_same<typename remove_reference<_Tp>::type, 265 reference_wrapper< 266 typename remove_reference<_Hp>::type 267 > 268 >::value)), 269 "Attempted to construct a reference element in a tuple with an rvalue");} 270 271 _LIBCPP_INLINE_VISIBILITY 272 _LIBCPP_CONSTEXPR_AFTER_CXX11 273 __tuple_leaf(const __tuple_leaf& __t) _NOEXCEPT_(is_nothrow_copy_constructible<_Hp>::value) 274 : value(__t.get()) 275 {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");} 276 277 _LIBCPP_INLINE_VISIBILITY 278 _LIBCPP_CONSTEXPR_AFTER_CXX11 279 __tuple_leaf(__tuple_leaf&& __t) _NOEXCEPT_(is_nothrow_move_constructible<_Hp>::value) 280 : value(_VSTD::forward<_Hp>(__t.get())) 281 {} 282 283 template <class _Tp> 284 _LIBCPP_INLINE_VISIBILITY 285 __tuple_leaf& 286 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value)) 287 { 288 value = _VSTD::forward<_Tp>(__t); 289 return *this; 290 } 291 292 _LIBCPP_INLINE_VISIBILITY 293 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) 294 { 295 _VSTD::swap(*this, __t); 296 return 0; 297 } 298 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;} 301 }; 302 303 template <size_t _Ip, class _Hp> 304 class __tuple_leaf<_Ip, _Hp, true> 305 : private _Hp 306 { 307 308 __tuple_leaf& operator=(const __tuple_leaf&); 309 public: 310 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf() 311 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {} 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 327 template <class _Tp, 328 class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type> 329 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 330 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) 331 : _Hp(_VSTD::forward<_Tp>(__t)) {} 332 333 template <class _Tp, class _Alloc> 334 _LIBCPP_INLINE_VISIBILITY 335 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t) 336 : _Hp(_VSTD::forward<_Tp>(__t)) {} 337 338 template <class _Tp, class _Alloc> 339 _LIBCPP_INLINE_VISIBILITY 340 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t) 341 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {} 342 343 template <class _Tp, class _Alloc> 344 _LIBCPP_INLINE_VISIBILITY 345 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t) 346 : _Hp(_VSTD::forward<_Tp>(__t), __a) {} 347 348 template <class _Tp> 349 _LIBCPP_INLINE_VISIBILITY 350 __tuple_leaf& 351 operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value)) 352 { 353 _Hp::operator=(_VSTD::forward<_Tp>(__t)); 354 return *this; 355 } 356 357 _LIBCPP_INLINE_VISIBILITY 358 int 359 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) 360 { 361 _VSTD::swap(*this, __t); 362 return 0; 363 } 364 365 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);} 366 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);} 367 }; 368 369 template <class ..._Tp> 370 _LIBCPP_INLINE_VISIBILITY 371 void __swallow(_Tp&&...) _NOEXCEPT {} 372 373 template <bool ...> struct __all; 374 375 template <> 376 struct __all<> 377 { 378 static const bool value = true; 379 }; 380 381 template <bool _B0, bool ... _Bp> 382 struct __all<_B0, _Bp...> 383 { 384 static const bool value = _B0 && __all<_Bp...>::value; 385 }; 386 387 // __tuple_impl 388 389 template<class _Indx, class ..._Tp> struct __tuple_impl; 390 391 template<size_t ..._Indx, class ..._Tp> 392 struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...> 393 : public __tuple_leaf<_Indx, _Tp>... 394 { 395 _LIBCPP_INLINE_VISIBILITY 396 _LIBCPP_CONSTEXPR __tuple_impl() 397 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {} 398 399 template <size_t ..._Uf, class ..._Tf, 400 size_t ..._Ul, class ..._Tl, class ..._Up> 401 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 402 explicit 403 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>, 404 __tuple_indices<_Ul...>, __tuple_types<_Tl...>, 405 _Up&&... __u) 406 _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value && 407 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) : 408 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))..., 409 __tuple_leaf<_Ul, _Tl>()... 410 {} 411 412 template <class _Alloc, size_t ..._Uf, class ..._Tf, 413 size_t ..._Ul, class ..._Tl, class ..._Up> 414 _LIBCPP_INLINE_VISIBILITY 415 explicit 416 __tuple_impl(allocator_arg_t, const _Alloc& __a, 417 __tuple_indices<_Uf...>, __tuple_types<_Tf...>, 418 __tuple_indices<_Ul...>, __tuple_types<_Tl...>, 419 _Up&&... __u) : 420 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, 421 _VSTD::forward<_Up>(__u))..., 422 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... 423 {} 424 425 template <class _Tuple, 426 class = typename enable_if 427 < 428 __tuple_constructible<_Tuple, tuple<_Tp...> >::value 429 >::type 430 > 431 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 432 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx, 433 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value)) 434 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx, 435 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))... 436 {} 437 438 template <class _Alloc, class _Tuple, 439 class = typename enable_if 440 < 441 __tuple_convertible<_Tuple, tuple<_Tp...> >::value 442 >::type 443 > 444 _LIBCPP_INLINE_VISIBILITY 445 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) 446 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx, 447 typename __make_tuple_types<_Tuple>::type>::type>(), __a, 448 _VSTD::forward<typename tuple_element<_Indx, 449 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))... 450 {} 451 452 template <class _Tuple> 453 _LIBCPP_INLINE_VISIBILITY 454 typename enable_if 455 < 456 __tuple_assignable<_Tuple, tuple<_Tp...> >::value, 457 __tuple_impl& 458 >::type 459 operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx, 460 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value)) 461 { 462 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx, 463 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...); 464 return *this; 465 } 466 467 __tuple_impl(const __tuple_impl&) = default; 468 __tuple_impl(__tuple_impl&&) = default; 469 470 _LIBCPP_INLINE_VISIBILITY 471 __tuple_impl& 472 operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value)) 473 { 474 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...); 475 return *this; 476 } 477 478 _LIBCPP_INLINE_VISIBILITY 479 __tuple_impl& 480 operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value)) 481 { 482 __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...); 483 return *this; 484 } 485 486 _LIBCPP_INLINE_VISIBILITY 487 void swap(__tuple_impl& __t) 488 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) 489 { 490 __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...); 491 } 492 }; 493 494 template <class ..._Tp> 495 class _LIBCPP_TYPE_VIS_ONLY tuple 496 { 497 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base; 498 499 base base_; 500 501 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 502 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT; 503 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 504 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT; 505 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11 506 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT; 507 public: 508 509 _LIBCPP_INLINE_VISIBILITY 510 _LIBCPP_CONSTEXPR tuple() 511 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {} 512 513 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 514 explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value)) 515 : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(), 516 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(), 517 typename __make_tuple_indices<0>::type(), 518 typename __make_tuple_types<tuple, 0>::type(), 519 __t... 520 ) {} 521 522 template <class _Alloc> 523 _LIBCPP_INLINE_VISIBILITY 524 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t) 525 : base_(allocator_arg_t(), __a, 526 typename __make_tuple_indices<sizeof...(_Tp)>::type(), 527 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(), 528 typename __make_tuple_indices<0>::type(), 529 typename __make_tuple_types<tuple, 0>::type(), 530 __t... 531 ) {} 532 533 template <class ..._Up, 534 typename enable_if 535 < 536 sizeof...(_Up) <= sizeof...(_Tp) && 537 __tuple_convertible 538 < 539 tuple<_Up...>, 540 typename __make_tuple_types<tuple, 541 sizeof...(_Up) < sizeof...(_Tp) ? 542 sizeof...(_Up) : 543 sizeof...(_Tp)>::type 544 >::value, 545 bool 546 >::type = false 547 > 548 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 549 tuple(_Up&&... __u) 550 _NOEXCEPT_(( 551 is_nothrow_constructible< 552 typename __make_tuple_indices<sizeof...(_Up)>::type, 553 typename __make_tuple_types<tuple, sizeof...(_Up)>::type, 554 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type, 555 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type, 556 _Up... 557 >::value 558 )) 559 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), 560 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), 561 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), 562 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), 563 _VSTD::forward<_Up>(__u)...) {} 564 565 template <class ..._Up, 566 typename enable_if 567 < 568 sizeof...(_Up) <= sizeof...(_Tp) && 569 __tuple_constructible 570 < 571 tuple<_Up...>, 572 typename __make_tuple_types<tuple, 573 sizeof...(_Up) < sizeof...(_Tp) ? 574 sizeof...(_Up) : 575 sizeof...(_Tp)>::type 576 >::value && 577 !__tuple_convertible 578 < 579 tuple<_Up...>, 580 typename __make_tuple_types<tuple, 581 sizeof...(_Up) < sizeof...(_Tp) ? 582 sizeof...(_Up) : 583 sizeof...(_Tp)>::type 584 >::value, 585 bool 586 >::type =false 587 > 588 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 589 explicit 590 tuple(_Up&&... __u) 591 _NOEXCEPT_(( 592 is_nothrow_constructible< 593 typename __make_tuple_indices<sizeof...(_Up)>::type, 594 typename __make_tuple_types<tuple, sizeof...(_Up)>::type, 595 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type, 596 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type, 597 _Up... 598 >::value 599 )) 600 : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), 601 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), 602 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), 603 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), 604 _VSTD::forward<_Up>(__u)...) {} 605 606 template <class _Alloc, class ..._Up, 607 class = typename enable_if 608 < 609 sizeof...(_Up) <= sizeof...(_Tp) && 610 __tuple_convertible 611 < 612 tuple<_Up...>, 613 typename __make_tuple_types<tuple, 614 sizeof...(_Up) < sizeof...(_Tp) ? 615 sizeof...(_Up) : 616 sizeof...(_Tp)>::type 617 >::value 618 >::type 619 > 620 _LIBCPP_INLINE_VISIBILITY 621 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) 622 : base_(allocator_arg_t(), __a, 623 typename __make_tuple_indices<sizeof...(_Up)>::type(), 624 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), 625 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), 626 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), 627 _VSTD::forward<_Up>(__u)...) {} 628 629 template <class _Tuple, 630 typename enable_if 631 < 632 __tuple_convertible<_Tuple, tuple>::value, 633 bool 634 >::type = false 635 > 636 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 637 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value)) 638 : base_(_VSTD::forward<_Tuple>(__t)) {} 639 640 template <class _Tuple, 641 typename enable_if 642 < 643 __tuple_constructible<_Tuple, tuple>::value && 644 !__tuple_convertible<_Tuple, tuple>::value, 645 bool 646 >::type = false 647 > 648 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 649 explicit 650 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value)) 651 : base_(_VSTD::forward<_Tuple>(__t)) {} 652 653 template <class _Alloc, class _Tuple, 654 class = typename enable_if 655 < 656 __tuple_convertible<_Tuple, tuple>::value 657 >::type 658 > 659 _LIBCPP_INLINE_VISIBILITY 660 tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) 661 : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {} 662 663 template <class _Tuple, 664 class = typename enable_if 665 < 666 __tuple_assignable<_Tuple, tuple>::value 667 >::type 668 > 669 _LIBCPP_INLINE_VISIBILITY 670 tuple& 671 operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value)) 672 { 673 base_.operator=(_VSTD::forward<_Tuple>(__t)); 674 return *this; 675 } 676 677 _LIBCPP_INLINE_VISIBILITY 678 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) 679 {base_.swap(__t.base_);} 680 }; 681 682 template <> 683 class _LIBCPP_TYPE_VIS_ONLY tuple<> 684 { 685 public: 686 _LIBCPP_INLINE_VISIBILITY 687 _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {} 688 template <class _Alloc> 689 _LIBCPP_INLINE_VISIBILITY 690 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {} 691 template <class _Alloc> 692 _LIBCPP_INLINE_VISIBILITY 693 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {} 694 template <class _Up> 695 _LIBCPP_INLINE_VISIBILITY 696 tuple(array<_Up, 0>) _NOEXCEPT {} 697 template <class _Alloc, class _Up> 698 _LIBCPP_INLINE_VISIBILITY 699 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {} 700 _LIBCPP_INLINE_VISIBILITY 701 void swap(tuple&) _NOEXCEPT {} 702 }; 703 704 template <class ..._Tp> 705 inline _LIBCPP_INLINE_VISIBILITY 706 typename enable_if 707 < 708 __all<__is_swappable<_Tp>::value...>::value, 709 void 710 >::type 711 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) 712 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) 713 {__t.swap(__u);} 714 715 // get 716 717 template <size_t _Ip, class ..._Tp> 718 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 719 typename tuple_element<_Ip, tuple<_Tp...> >::type& 720 get(tuple<_Tp...>& __t) _NOEXCEPT 721 { 722 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; 723 return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get(); 724 } 725 726 template <size_t _Ip, class ..._Tp> 727 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 728 const typename tuple_element<_Ip, tuple<_Tp...> >::type& 729 get(const tuple<_Tp...>& __t) _NOEXCEPT 730 { 731 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; 732 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get(); 733 } 734 735 template <size_t _Ip, class ..._Tp> 736 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 737 typename tuple_element<_Ip, tuple<_Tp...> >::type&& 738 get(tuple<_Tp...>&& __t) _NOEXCEPT 739 { 740 typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; 741 return static_cast<type&&>( 742 static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get()); 743 } 744 745 #if _LIBCPP_STD_VER > 11 746 // get by type 747 template <typename _T1, size_t _Idx, typename... _Args> 748 struct __find_exactly_one_t_helper; 749 750 // -- find exactly one 751 template <typename _T1, size_t _Idx, typename... _Args> 752 struct __find_exactly_one_t_checker { 753 static constexpr size_t value = _Idx; 754 // Check the rest of the list to make sure there's only one 755 static_assert ( __find_exactly_one_t_helper<_T1, 0, _Args...>::value == -1, "type can only occur once in type list" ); 756 }; 757 758 759 template <typename _T1, size_t _Idx> 760 struct __find_exactly_one_t_helper <_T1, _Idx> { 761 static constexpr size_t value = -1; 762 }; 763 764 template <typename _T1, size_t _Idx, typename _Head, typename... _Args> 765 struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> { 766 static constexpr size_t value = 767 std::conditional< 768 std::is_same<_T1, _Head>::value, 769 __find_exactly_one_t_checker<_T1, _Idx, _Args...>, 770 __find_exactly_one_t_helper <_T1, _Idx+1, _Args...> 771 >::type::value; 772 }; 773 774 template <typename _T1, typename... _Args> 775 struct __find_exactly_one_t { 776 static constexpr size_t value = __find_exactly_one_t_helper<_T1, 0, _Args...>::value; 777 static_assert ( value != -1, "type not found in type list" ); 778 }; 779 780 template <class _T1, class... _Args> 781 inline _LIBCPP_INLINE_VISIBILITY 782 constexpr _T1& get(tuple<_Args...>& __tup) noexcept 783 { 784 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); 785 } 786 787 template <class _T1, class... _Args> 788 inline _LIBCPP_INLINE_VISIBILITY 789 constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept 790 { 791 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); 792 } 793 794 template <class _T1, class... _Args> 795 inline _LIBCPP_INLINE_VISIBILITY 796 constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept 797 { 798 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup)); 799 } 800 801 #endif 802 803 // tie 804 805 template <class ..._Tp> 806 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 807 tuple<_Tp&...> 808 tie(_Tp&... __t) _NOEXCEPT 809 { 810 return tuple<_Tp&...>(__t...); 811 } 812 813 template <class _Up> 814 struct __ignore_t 815 { 816 template <class _Tp> 817 _LIBCPP_INLINE_VISIBILITY 818 const __ignore_t& operator=(_Tp&&) const {return *this;} 819 }; 820 821 namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); } 822 823 template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper; 824 825 template <class _Tp> 826 struct __make_tuple_return_impl 827 { 828 typedef _Tp type; 829 }; 830 831 template <class _Tp> 832 struct __make_tuple_return_impl<reference_wrapper<_Tp> > 833 { 834 typedef _Tp& type; 835 }; 836 837 template <class _Tp> 838 struct __make_tuple_return 839 { 840 typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type; 841 }; 842 843 template <class... _Tp> 844 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 845 tuple<typename __make_tuple_return<_Tp>::type...> 846 make_tuple(_Tp&&... __t) 847 { 848 return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...); 849 } 850 851 template <class... _Tp> 852 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 853 tuple<_Tp&&...> 854 forward_as_tuple(_Tp&&... __t) _NOEXCEPT 855 { 856 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...); 857 } 858 859 template <size_t _Ip> 860 struct __tuple_equal 861 { 862 template <class _Tp, class _Up> 863 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 864 bool operator()(const _Tp& __x, const _Up& __y) 865 { 866 return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y); 867 } 868 }; 869 870 template <> 871 struct __tuple_equal<0> 872 { 873 template <class _Tp, class _Up> 874 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 875 bool operator()(const _Tp&, const _Up&) 876 { 877 return true; 878 } 879 }; 880 881 template <class ..._Tp, class ..._Up> 882 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 883 bool 884 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 885 { 886 return __tuple_equal<sizeof...(_Tp)>()(__x, __y); 887 } 888 889 template <class ..._Tp, class ..._Up> 890 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 891 bool 892 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 893 { 894 return !(__x == __y); 895 } 896 897 template <size_t _Ip> 898 struct __tuple_less 899 { 900 template <class _Tp, class _Up> 901 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 902 bool operator()(const _Tp& __x, const _Up& __y) 903 { 904 return __tuple_less<_Ip-1>()(__x, __y) || 905 (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y)); 906 } 907 }; 908 909 template <> 910 struct __tuple_less<0> 911 { 912 template <class _Tp, class _Up> 913 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 914 bool operator()(const _Tp&, const _Up&) 915 { 916 return false; 917 } 918 }; 919 920 template <class ..._Tp, class ..._Up> 921 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 922 bool 923 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 924 { 925 return __tuple_less<sizeof...(_Tp)>()(__x, __y); 926 } 927 928 template <class ..._Tp, class ..._Up> 929 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 930 bool 931 operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 932 { 933 return __y < __x; 934 } 935 936 template <class ..._Tp, class ..._Up> 937 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 938 bool 939 operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 940 { 941 return !(__x < __y); 942 } 943 944 template <class ..._Tp, class ..._Up> 945 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 946 bool 947 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) 948 { 949 return !(__y < __x); 950 } 951 952 // tuple_cat 953 954 template <class _Tp, class _Up> struct __tuple_cat_type; 955 956 template <class ..._Ttypes, class ..._Utypes> 957 struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> > 958 { 959 typedef tuple<_Ttypes..., _Utypes...> type; 960 }; 961 962 template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples> 963 struct __tuple_cat_return_1 964 { 965 }; 966 967 template <class ..._Types, class _Tuple0> 968 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0> 969 { 970 typedef typename __tuple_cat_type<tuple<_Types...>, 971 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type 972 type; 973 }; 974 975 template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples> 976 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...> 977 : public __tuple_cat_return_1< 978 typename __tuple_cat_type< 979 tuple<_Types...>, 980 typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type 981 >::type, 982 __tuple_like<typename remove_reference<_Tuple1>::type>::value, 983 _Tuple1, _Tuples...> 984 { 985 }; 986 987 template <class ..._Tuples> struct __tuple_cat_return; 988 989 template <class _Tuple0, class ..._Tuples> 990 struct __tuple_cat_return<_Tuple0, _Tuples...> 991 : public __tuple_cat_return_1<tuple<>, 992 __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0, 993 _Tuples...> 994 { 995 }; 996 997 template <> 998 struct __tuple_cat_return<> 999 { 1000 typedef tuple<> type; 1001 }; 1002 1003 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1004 tuple<> 1005 tuple_cat() 1006 { 1007 return tuple<>(); 1008 } 1009 1010 template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples> 1011 struct __tuple_cat_return_ref_imp; 1012 1013 template <class ..._Types, size_t ..._I0, class _Tuple0> 1014 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0> 1015 { 1016 typedef typename remove_reference<_Tuple0>::type _T0; 1017 typedef tuple<_Types..., typename __apply_cv<_Tuple0, 1018 typename tuple_element<_I0, _T0>::type>::type&&...> type; 1019 }; 1020 1021 template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples> 1022 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, 1023 _Tuple0, _Tuple1, _Tuples...> 1024 : public __tuple_cat_return_ref_imp< 1025 tuple<_Types..., typename __apply_cv<_Tuple0, 1026 typename tuple_element<_I0, 1027 typename remove_reference<_Tuple0>::type>::type>::type&&...>, 1028 typename __make_tuple_indices<tuple_size<typename 1029 remove_reference<_Tuple1>::type>::value>::type, 1030 _Tuple1, _Tuples...> 1031 { 1032 }; 1033 1034 template <class _Tuple0, class ..._Tuples> 1035 struct __tuple_cat_return_ref 1036 : public __tuple_cat_return_ref_imp<tuple<>, 1037 typename __make_tuple_indices< 1038 tuple_size<typename remove_reference<_Tuple0>::type>::value 1039 >::type, _Tuple0, _Tuples...> 1040 { 1041 }; 1042 1043 template <class _Types, class _I0, class _J0> 1044 struct __tuple_cat; 1045 1046 template <class ..._Types, size_t ..._I0, size_t ..._J0> 1047 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> > 1048 { 1049 template <class _Tuple0> 1050 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1051 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type 1052 operator()(tuple<_Types...> __t, _Tuple0&& __t0) 1053 { 1054 return forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))..., 1055 get<_J0>(_VSTD::forward<_Tuple0>(__t0))...); 1056 } 1057 1058 template <class _Tuple0, class _Tuple1, class ..._Tuples> 1059 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1060 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type 1061 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls) 1062 { 1063 typedef typename remove_reference<_Tuple0>::type _T0; 1064 typedef typename remove_reference<_Tuple1>::type _T1; 1065 return __tuple_cat< 1066 tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>, 1067 typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type, 1068 typename __make_tuple_indices<tuple_size<_T1>::value>::type>() 1069 (forward_as_tuple( 1070 _VSTD::forward<_Types>(get<_I0>(__t))..., 1071 get<_J0>(_VSTD::forward<_Tuple0>(__t0))... 1072 ), 1073 _VSTD::forward<_Tuple1>(__t1), 1074 _VSTD::forward<_Tuples>(__tpls)...); 1075 } 1076 }; 1077 1078 template <class _Tuple0, class... _Tuples> 1079 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1080 typename __tuple_cat_return<_Tuple0, _Tuples...>::type 1081 tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) 1082 { 1083 typedef typename remove_reference<_Tuple0>::type _T0; 1084 return __tuple_cat<tuple<>, __tuple_indices<>, 1085 typename __make_tuple_indices<tuple_size<_T0>::value>::type>() 1086 (tuple<>(), _VSTD::forward<_Tuple0>(__t0), 1087 _VSTD::forward<_Tuples>(__tpls)...); 1088 } 1089 1090 template <class ..._Tp, class _Alloc> 1091 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<tuple<_Tp...>, _Alloc> 1092 : true_type {}; 1093 1094 template <class _T1, class _T2> 1095 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2> 1096 inline _LIBCPP_INLINE_VISIBILITY 1097 pair<_T1, _T2>::pair(piecewise_construct_t, 1098 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, 1099 __tuple_indices<_I1...>, __tuple_indices<_I2...>) 1100 : first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...), 1101 second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) 1102 { 1103 } 1104 1105 #endif // _LIBCPP_HAS_NO_VARIADICS 1106 1107 _LIBCPP_END_NAMESPACE_STD 1108 1109 #endif // _LIBCPP_TUPLE 1110
