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