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