tuple revision 1.1.1.16
1 // <tuple> -*- C++ -*- 2 3 // Copyright (C) 2007-2022 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/tuple 26 * This is a Standard C++ Library header. 27 */ 28 29 #ifndef _GLIBCXX_TUPLE 30 #define _GLIBCXX_TUPLE 1 31 32 #pragma GCC system_header 33 34 #if __cplusplus < 201103L 35 # include <bits/c++0x_warning.h> 36 #else 37 38 #include <bits/stl_pair.h> // for std::pair 39 #include <bits/uses_allocator.h> // for std::allocator_arg_t 40 #include <bits/utility.h> // for std::get, std::tuple_size etc. 41 #include <bits/invoke.h> // for std::__invoke 42 #if __cplusplus > 201703L 43 # include <compare> 44 # define __cpp_lib_constexpr_tuple 201811L 45 #endif 46 47 namespace std _GLIBCXX_VISIBILITY(default) 48 { 49 _GLIBCXX_BEGIN_NAMESPACE_VERSION 50 51 /** 52 * @addtogroup utilities 53 * @{ 54 */ 55 56 template<typename... _Elements> 57 class tuple; 58 59 template<typename _Tp> 60 struct __is_empty_non_tuple : is_empty<_Tp> { }; 61 62 // Using EBO for elements that are tuples causes ambiguous base errors. 63 template<typename _El0, typename... _El> 64 struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { }; 65 66 // Use the Empty Base-class Optimization for empty, non-final types. 67 template<typename _Tp> 68 using __empty_not_final 69 = __conditional_t<__is_final(_Tp), false_type, 70 __is_empty_non_tuple<_Tp>>; 71 72 template<size_t _Idx, typename _Head, 73 bool = __empty_not_final<_Head>::value> 74 struct _Head_base; 75 76 #if __has_cpp_attribute(__no_unique_address__) 77 template<size_t _Idx, typename _Head> 78 struct _Head_base<_Idx, _Head, true> 79 { 80 constexpr _Head_base() 81 : _M_head_impl() { } 82 83 constexpr _Head_base(const _Head& __h) 84 : _M_head_impl(__h) { } 85 86 constexpr _Head_base(const _Head_base&) = default; 87 constexpr _Head_base(_Head_base&&) = default; 88 89 template<typename _UHead> 90 constexpr _Head_base(_UHead&& __h) 91 : _M_head_impl(std::forward<_UHead>(__h)) { } 92 93 _GLIBCXX20_CONSTEXPR 94 _Head_base(allocator_arg_t, __uses_alloc0) 95 : _M_head_impl() { } 96 97 template<typename _Alloc> 98 _GLIBCXX20_CONSTEXPR 99 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) 100 : _M_head_impl(allocator_arg, *__a._M_a) { } 101 102 template<typename _Alloc> 103 _GLIBCXX20_CONSTEXPR 104 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) 105 : _M_head_impl(*__a._M_a) { } 106 107 template<typename _UHead> 108 _GLIBCXX20_CONSTEXPR 109 _Head_base(__uses_alloc0, _UHead&& __uhead) 110 : _M_head_impl(std::forward<_UHead>(__uhead)) { } 111 112 template<typename _Alloc, typename _UHead> 113 _GLIBCXX20_CONSTEXPR 114 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 115 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) 116 { } 117 118 template<typename _Alloc, typename _UHead> 119 _GLIBCXX20_CONSTEXPR 120 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 121 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } 122 123 static constexpr _Head& 124 _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } 125 126 static constexpr const _Head& 127 _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } 128 129 [[__no_unique_address__]] _Head _M_head_impl; 130 }; 131 #else 132 template<size_t _Idx, typename _Head> 133 struct _Head_base<_Idx, _Head, true> 134 : public _Head 135 { 136 constexpr _Head_base() 137 : _Head() { } 138 139 constexpr _Head_base(const _Head& __h) 140 : _Head(__h) { } 141 142 constexpr _Head_base(const _Head_base&) = default; 143 constexpr _Head_base(_Head_base&&) = default; 144 145 template<typename _UHead> 146 constexpr _Head_base(_UHead&& __h) 147 : _Head(std::forward<_UHead>(__h)) { } 148 149 _GLIBCXX20_CONSTEXPR 150 _Head_base(allocator_arg_t, __uses_alloc0) 151 : _Head() { } 152 153 template<typename _Alloc> 154 _GLIBCXX20_CONSTEXPR 155 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) 156 : _Head(allocator_arg, *__a._M_a) { } 157 158 template<typename _Alloc> 159 _GLIBCXX20_CONSTEXPR 160 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) 161 : _Head(*__a._M_a) { } 162 163 template<typename _UHead> 164 _GLIBCXX20_CONSTEXPR 165 _Head_base(__uses_alloc0, _UHead&& __uhead) 166 : _Head(std::forward<_UHead>(__uhead)) { } 167 168 template<typename _Alloc, typename _UHead> 169 _GLIBCXX20_CONSTEXPR 170 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 171 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } 172 173 template<typename _Alloc, typename _UHead> 174 _GLIBCXX20_CONSTEXPR 175 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 176 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } 177 178 static constexpr _Head& 179 _M_head(_Head_base& __b) noexcept { return __b; } 180 181 static constexpr const _Head& 182 _M_head(const _Head_base& __b) noexcept { return __b; } 183 }; 184 #endif 185 186 template<size_t _Idx, typename _Head> 187 struct _Head_base<_Idx, _Head, false> 188 { 189 constexpr _Head_base() 190 : _M_head_impl() { } 191 192 constexpr _Head_base(const _Head& __h) 193 : _M_head_impl(__h) { } 194 195 constexpr _Head_base(const _Head_base&) = default; 196 constexpr _Head_base(_Head_base&&) = default; 197 198 template<typename _UHead> 199 constexpr _Head_base(_UHead&& __h) 200 : _M_head_impl(std::forward<_UHead>(__h)) { } 201 202 _GLIBCXX20_CONSTEXPR 203 _Head_base(allocator_arg_t, __uses_alloc0) 204 : _M_head_impl() { } 205 206 template<typename _Alloc> 207 _GLIBCXX20_CONSTEXPR 208 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) 209 : _M_head_impl(allocator_arg, *__a._M_a) { } 210 211 template<typename _Alloc> 212 _GLIBCXX20_CONSTEXPR 213 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) 214 : _M_head_impl(*__a._M_a) { } 215 216 template<typename _UHead> 217 _GLIBCXX20_CONSTEXPR 218 _Head_base(__uses_alloc0, _UHead&& __uhead) 219 : _M_head_impl(std::forward<_UHead>(__uhead)) { } 220 221 template<typename _Alloc, typename _UHead> 222 _GLIBCXX20_CONSTEXPR 223 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 224 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) 225 { } 226 227 template<typename _Alloc, typename _UHead> 228 _GLIBCXX20_CONSTEXPR 229 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 230 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } 231 232 static constexpr _Head& 233 _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } 234 235 static constexpr const _Head& 236 _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } 237 238 _Head _M_head_impl; 239 }; 240 241 /** 242 * Contains the actual implementation of the @c tuple template, stored 243 * as a recursive inheritance hierarchy from the first element (most 244 * derived class) to the last (least derived class). The @c Idx 245 * parameter gives the 0-based index of the element stored at this 246 * point in the hierarchy; we use it to implement a constant-time 247 * get() operation. 248 */ 249 template<size_t _Idx, typename... _Elements> 250 struct _Tuple_impl; 251 252 /** 253 * Recursive tuple implementation. Here we store the @c Head element 254 * and derive from a @c Tuple_impl containing the remaining elements 255 * (which contains the @c Tail). 256 */ 257 template<size_t _Idx, typename _Head, typename... _Tail> 258 struct _Tuple_impl<_Idx, _Head, _Tail...> 259 : public _Tuple_impl<_Idx + 1, _Tail...>, 260 private _Head_base<_Idx, _Head> 261 { 262 template<size_t, typename...> friend struct _Tuple_impl; 263 264 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; 265 typedef _Head_base<_Idx, _Head> _Base; 266 267 static constexpr _Head& 268 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 269 270 static constexpr const _Head& 271 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 272 273 static constexpr _Inherited& 274 _M_tail(_Tuple_impl& __t) noexcept { return __t; } 275 276 static constexpr const _Inherited& 277 _M_tail(const _Tuple_impl& __t) noexcept { return __t; } 278 279 constexpr _Tuple_impl() 280 : _Inherited(), _Base() { } 281 282 explicit constexpr 283 _Tuple_impl(const _Head& __head, const _Tail&... __tail) 284 : _Inherited(__tail...), _Base(__head) 285 { } 286 287 template<typename _UHead, typename... _UTail, 288 typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>> 289 explicit constexpr 290 _Tuple_impl(_UHead&& __head, _UTail&&... __tail) 291 : _Inherited(std::forward<_UTail>(__tail)...), 292 _Base(std::forward<_UHead>(__head)) 293 { } 294 295 constexpr _Tuple_impl(const _Tuple_impl&) = default; 296 297 // _GLIBCXX_RESOLVE_LIB_DEFECTS 298 // 2729. Missing SFINAE on std::pair::operator= 299 _Tuple_impl& operator=(const _Tuple_impl&) = delete; 300 301 _Tuple_impl(_Tuple_impl&&) = default; 302 303 template<typename... _UElements> 304 constexpr 305 _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) 306 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), 307 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) 308 { } 309 310 template<typename _UHead, typename... _UTails> 311 constexpr 312 _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 313 : _Inherited(std::move 314 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 315 _Base(std::forward<_UHead> 316 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) 317 { } 318 319 template<typename _Alloc> 320 _GLIBCXX20_CONSTEXPR 321 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) 322 : _Inherited(__tag, __a), 323 _Base(__tag, __use_alloc<_Head>(__a)) 324 { } 325 326 template<typename _Alloc> 327 _GLIBCXX20_CONSTEXPR 328 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 329 const _Head& __head, const _Tail&... __tail) 330 : _Inherited(__tag, __a, __tail...), 331 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) 332 { } 333 334 template<typename _Alloc, typename _UHead, typename... _UTail, 335 typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>> 336 _GLIBCXX20_CONSTEXPR 337 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 338 _UHead&& __head, _UTail&&... __tail) 339 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), 340 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 341 std::forward<_UHead>(__head)) 342 { } 343 344 template<typename _Alloc> 345 _GLIBCXX20_CONSTEXPR 346 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 347 const _Tuple_impl& __in) 348 : _Inherited(__tag, __a, _M_tail(__in)), 349 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) 350 { } 351 352 template<typename _Alloc> 353 _GLIBCXX20_CONSTEXPR 354 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 355 _Tuple_impl&& __in) 356 : _Inherited(__tag, __a, std::move(_M_tail(__in))), 357 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 358 std::forward<_Head>(_M_head(__in))) 359 { } 360 361 template<typename _Alloc, typename _UHead, typename... _UTails> 362 _GLIBCXX20_CONSTEXPR 363 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 364 const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) 365 : _Inherited(__tag, __a, 366 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), 367 _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), 368 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) 369 { } 370 371 template<typename _Alloc, typename _UHead, typename... _UTails> 372 _GLIBCXX20_CONSTEXPR 373 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 374 _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 375 : _Inherited(__tag, __a, std::move 376 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 377 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 378 std::forward<_UHead> 379 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) 380 { } 381 382 template<typename... _UElements> 383 _GLIBCXX20_CONSTEXPR 384 void 385 _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) 386 { 387 _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); 388 _M_tail(*this)._M_assign( 389 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); 390 } 391 392 template<typename _UHead, typename... _UTails> 393 _GLIBCXX20_CONSTEXPR 394 void 395 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 396 { 397 _M_head(*this) = std::forward<_UHead> 398 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); 399 _M_tail(*this)._M_assign( 400 std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); 401 } 402 403 protected: 404 _GLIBCXX20_CONSTEXPR 405 void 406 _M_swap(_Tuple_impl& __in) 407 { 408 using std::swap; 409 swap(_M_head(*this), _M_head(__in)); 410 _Inherited::_M_swap(_M_tail(__in)); 411 } 412 }; 413 414 // Basis case of inheritance recursion. 415 template<size_t _Idx, typename _Head> 416 struct _Tuple_impl<_Idx, _Head> 417 : private _Head_base<_Idx, _Head> 418 { 419 template<size_t, typename...> friend struct _Tuple_impl; 420 421 typedef _Head_base<_Idx, _Head> _Base; 422 423 static constexpr _Head& 424 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 425 426 static constexpr const _Head& 427 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 428 429 constexpr 430 _Tuple_impl() 431 : _Base() { } 432 433 explicit constexpr 434 _Tuple_impl(const _Head& __head) 435 : _Base(__head) 436 { } 437 438 template<typename _UHead> 439 explicit constexpr 440 _Tuple_impl(_UHead&& __head) 441 : _Base(std::forward<_UHead>(__head)) 442 { } 443 444 constexpr _Tuple_impl(const _Tuple_impl&) = default; 445 446 // _GLIBCXX_RESOLVE_LIB_DEFECTS 447 // 2729. Missing SFINAE on std::pair::operator= 448 _Tuple_impl& operator=(const _Tuple_impl&) = delete; 449 450 #if _GLIBCXX_INLINE_VERSION 451 _Tuple_impl(_Tuple_impl&&) = default; 452 #else 453 constexpr 454 _Tuple_impl(_Tuple_impl&& __in) 455 noexcept(is_nothrow_move_constructible<_Head>::value) 456 : _Base(static_cast<_Base&&>(__in)) 457 { } 458 #endif 459 460 template<typename _UHead> 461 constexpr 462 _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) 463 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) 464 { } 465 466 template<typename _UHead> 467 constexpr 468 _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) 469 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) 470 { } 471 472 template<typename _Alloc> 473 _GLIBCXX20_CONSTEXPR 474 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) 475 : _Base(__tag, __use_alloc<_Head>(__a)) 476 { } 477 478 template<typename _Alloc> 479 _GLIBCXX20_CONSTEXPR 480 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 481 const _Head& __head) 482 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) 483 { } 484 485 template<typename _Alloc, typename _UHead> 486 _GLIBCXX20_CONSTEXPR 487 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 488 _UHead&& __head) 489 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 490 std::forward<_UHead>(__head)) 491 { } 492 493 template<typename _Alloc> 494 _GLIBCXX20_CONSTEXPR 495 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 496 const _Tuple_impl& __in) 497 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) 498 { } 499 500 template<typename _Alloc> 501 _GLIBCXX20_CONSTEXPR 502 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 503 _Tuple_impl&& __in) 504 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 505 std::forward<_Head>(_M_head(__in))) 506 { } 507 508 template<typename _Alloc, typename _UHead> 509 _GLIBCXX20_CONSTEXPR 510 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 511 const _Tuple_impl<_Idx, _UHead>& __in) 512 : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), 513 _Tuple_impl<_Idx, _UHead>::_M_head(__in)) 514 { } 515 516 template<typename _Alloc, typename _UHead> 517 _GLIBCXX20_CONSTEXPR 518 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 519 _Tuple_impl<_Idx, _UHead>&& __in) 520 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 521 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) 522 { } 523 524 template<typename _UHead> 525 _GLIBCXX20_CONSTEXPR 526 void 527 _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) 528 { 529 _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); 530 } 531 532 template<typename _UHead> 533 _GLIBCXX20_CONSTEXPR 534 void 535 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) 536 { 537 _M_head(*this) 538 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); 539 } 540 541 protected: 542 _GLIBCXX20_CONSTEXPR 543 void 544 _M_swap(_Tuple_impl& __in) 545 { 546 using std::swap; 547 swap(_M_head(*this), _M_head(__in)); 548 } 549 }; 550 551 // Concept utility functions, reused in conditionally-explicit 552 // constructors. 553 template<bool, typename... _Types> 554 struct _TupleConstraints 555 { 556 // Constraint for a non-explicit constructor. 557 // True iff each Ti in _Types... can be constructed from Ui in _UTypes... 558 // and every Ui is implicitly convertible to Ti. 559 template<typename... _UTypes> 560 static constexpr bool __is_implicitly_constructible() 561 { 562 return __and_<is_constructible<_Types, _UTypes>..., 563 is_convertible<_UTypes, _Types>... 564 >::value; 565 } 566 567 // Constraint for a non-explicit constructor. 568 // True iff each Ti in _Types... can be constructed from Ui in _UTypes... 569 // but not every Ui is implicitly convertible to Ti. 570 template<typename... _UTypes> 571 static constexpr bool __is_explicitly_constructible() 572 { 573 return __and_<is_constructible<_Types, _UTypes>..., 574 __not_<__and_<is_convertible<_UTypes, _Types>...>> 575 >::value; 576 } 577 578 static constexpr bool __is_implicitly_default_constructible() 579 { 580 return __and_<std::__is_implicitly_default_constructible<_Types>... 581 >::value; 582 } 583 584 static constexpr bool __is_explicitly_default_constructible() 585 { 586 return __and_<is_default_constructible<_Types>..., 587 __not_<__and_< 588 std::__is_implicitly_default_constructible<_Types>...> 589 >>::value; 590 } 591 }; 592 593 // Partial specialization used when a required precondition isn't met, 594 // e.g. when sizeof...(_Types) != sizeof...(_UTypes). 595 template<typename... _Types> 596 struct _TupleConstraints<false, _Types...> 597 { 598 template<typename... _UTypes> 599 static constexpr bool __is_implicitly_constructible() 600 { return false; } 601 602 template<typename... _UTypes> 603 static constexpr bool __is_explicitly_constructible() 604 { return false; } 605 }; 606 607 /// Primary class template, tuple 608 template<typename... _Elements> 609 class tuple : public _Tuple_impl<0, _Elements...> 610 { 611 typedef _Tuple_impl<0, _Elements...> _Inherited; 612 613 template<bool _Cond> 614 using _TCC = _TupleConstraints<_Cond, _Elements...>; 615 616 // Constraint for non-explicit default constructor 617 template<bool _Dummy> 618 using _ImplicitDefaultCtor = __enable_if_t< 619 _TCC<_Dummy>::__is_implicitly_default_constructible(), 620 bool>; 621 622 // Constraint for explicit default constructor 623 template<bool _Dummy> 624 using _ExplicitDefaultCtor = __enable_if_t< 625 _TCC<_Dummy>::__is_explicitly_default_constructible(), 626 bool>; 627 628 // Constraint for non-explicit constructors 629 template<bool _Cond, typename... _Args> 630 using _ImplicitCtor = __enable_if_t< 631 _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), 632 bool>; 633 634 // Constraint for non-explicit constructors 635 template<bool _Cond, typename... _Args> 636 using _ExplicitCtor = __enable_if_t< 637 _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), 638 bool>; 639 640 template<typename... _UElements> 641 static constexpr 642 __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool> 643 __assignable() 644 { return __and_<is_assignable<_Elements&, _UElements>...>::value; } 645 646 // Condition for noexcept-specifier of an assignment operator. 647 template<typename... _UElements> 648 static constexpr bool __nothrow_assignable() 649 { 650 return 651 __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value; 652 } 653 654 // Condition for noexcept-specifier of a constructor. 655 template<typename... _UElements> 656 static constexpr bool __nothrow_constructible() 657 { 658 return 659 __and_<is_nothrow_constructible<_Elements, _UElements>...>::value; 660 } 661 662 // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) == 1. 663 template<typename _Up> 664 static constexpr bool __valid_args() 665 { 666 return sizeof...(_Elements) == 1 667 && !is_same<tuple, __remove_cvref_t<_Up>>::value; 668 } 669 670 // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) > 1. 671 template<typename, typename, typename... _Tail> 672 static constexpr bool __valid_args() 673 { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } 674 675 /* Constraint for constructors with a tuple<UTypes...> parameter ensures 676 * that the constructor is only viable when it would not interfere with 677 * tuple(UTypes&&...) or tuple(const tuple&) or tuple(tuple&&). 678 * Such constructors are only viable if: 679 * either sizeof...(Types) != 1, 680 * or (when Types... expands to T and UTypes... expands to U) 681 * is_convertible_v<TUPLE, T>, is_constructible_v<T, TUPLE>, 682 * and is_same_v<T, U> are all false. 683 */ 684 template<typename _Tuple, typename = tuple, 685 typename = __remove_cvref_t<_Tuple>> 686 struct _UseOtherCtor 687 : false_type 688 { }; 689 // If TUPLE is convertible to the single element in *this, 690 // then TUPLE should match tuple(UTypes&&...) instead. 691 template<typename _Tuple, typename _Tp, typename _Up> 692 struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> 693 : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>> 694 { }; 695 // If TUPLE and *this each have a single element of the same type, 696 // then TUPLE should match a copy/move constructor instead. 697 template<typename _Tuple, typename _Tp> 698 struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> 699 : true_type 700 { }; 701 702 // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1 703 // and the single element in Types can be initialized from TUPLE, 704 // or is the same type as tuple_element_t<0, TUPLE>. 705 template<typename _Tuple> 706 static constexpr bool __use_other_ctor() 707 { return _UseOtherCtor<_Tuple>::value; } 708 709 public: 710 template<typename _Dummy = void, 711 _ImplicitDefaultCtor<is_void<_Dummy>::value> = true> 712 constexpr 713 tuple() 714 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value) 715 : _Inherited() { } 716 717 template<typename _Dummy = void, 718 _ExplicitDefaultCtor<is_void<_Dummy>::value> = false> 719 explicit constexpr 720 tuple() 721 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value) 722 : _Inherited() { } 723 724 template<bool _NotEmpty = (sizeof...(_Elements) >= 1), 725 _ImplicitCtor<_NotEmpty, const _Elements&...> = true> 726 constexpr 727 tuple(const _Elements&... __elements) 728 noexcept(__nothrow_constructible<const _Elements&...>()) 729 : _Inherited(__elements...) { } 730 731 template<bool _NotEmpty = (sizeof...(_Elements) >= 1), 732 _ExplicitCtor<_NotEmpty, const _Elements&...> = false> 733 explicit constexpr 734 tuple(const _Elements&... __elements) 735 noexcept(__nothrow_constructible<const _Elements&...>()) 736 : _Inherited(__elements...) { } 737 738 template<typename... _UElements, 739 bool _Valid = __valid_args<_UElements...>(), 740 _ImplicitCtor<_Valid, _UElements...> = true> 741 constexpr 742 tuple(_UElements&&... __elements) 743 noexcept(__nothrow_constructible<_UElements...>()) 744 : _Inherited(std::forward<_UElements>(__elements)...) { } 745 746 template<typename... _UElements, 747 bool _Valid = __valid_args<_UElements...>(), 748 _ExplicitCtor<_Valid, _UElements...> = false> 749 explicit constexpr 750 tuple(_UElements&&... __elements) 751 noexcept(__nothrow_constructible<_UElements...>()) 752 : _Inherited(std::forward<_UElements>(__elements)...) { } 753 754 constexpr tuple(const tuple&) = default; 755 756 constexpr tuple(tuple&&) = default; 757 758 template<typename... _UElements, 759 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 760 && !__use_other_ctor<const tuple<_UElements...>&>(), 761 _ImplicitCtor<_Valid, const _UElements&...> = true> 762 constexpr 763 tuple(const tuple<_UElements...>& __in) 764 noexcept(__nothrow_constructible<const _UElements&...>()) 765 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 766 { } 767 768 template<typename... _UElements, 769 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 770 && !__use_other_ctor<const tuple<_UElements...>&>(), 771 _ExplicitCtor<_Valid, const _UElements&...> = false> 772 explicit constexpr 773 tuple(const tuple<_UElements...>& __in) 774 noexcept(__nothrow_constructible<const _UElements&...>()) 775 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 776 { } 777 778 template<typename... _UElements, 779 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 780 && !__use_other_ctor<tuple<_UElements...>&&>(), 781 _ImplicitCtor<_Valid, _UElements...> = true> 782 constexpr 783 tuple(tuple<_UElements...>&& __in) 784 noexcept(__nothrow_constructible<_UElements...>()) 785 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } 786 787 template<typename... _UElements, 788 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 789 && !__use_other_ctor<tuple<_UElements...>&&>(), 790 _ExplicitCtor<_Valid, _UElements...> = false> 791 explicit constexpr 792 tuple(tuple<_UElements...>&& __in) 793 noexcept(__nothrow_constructible<_UElements...>()) 794 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } 795 796 // Allocator-extended constructors. 797 798 template<typename _Alloc, 799 _ImplicitDefaultCtor<is_object<_Alloc>::value> = true> 800 _GLIBCXX20_CONSTEXPR 801 tuple(allocator_arg_t __tag, const _Alloc& __a) 802 : _Inherited(__tag, __a) { } 803 804 template<typename _Alloc, 805 _ExplicitDefaultCtor<is_object<_Alloc>::value> = false> 806 _GLIBCXX20_CONSTEXPR 807 explicit 808 tuple(allocator_arg_t __tag, const _Alloc& __a) 809 : _Inherited(__tag, __a) { } 810 811 template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1), 812 _ImplicitCtor<_NotEmpty, const _Elements&...> = true> 813 _GLIBCXX20_CONSTEXPR 814 tuple(allocator_arg_t __tag, const _Alloc& __a, 815 const _Elements&... __elements) 816 : _Inherited(__tag, __a, __elements...) { } 817 818 template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1), 819 _ExplicitCtor<_NotEmpty, const _Elements&...> = false> 820 _GLIBCXX20_CONSTEXPR 821 explicit 822 tuple(allocator_arg_t __tag, const _Alloc& __a, 823 const _Elements&... __elements) 824 : _Inherited(__tag, __a, __elements...) { } 825 826 template<typename _Alloc, typename... _UElements, 827 bool _Valid = __valid_args<_UElements...>(), 828 _ImplicitCtor<_Valid, _UElements...> = true> 829 _GLIBCXX20_CONSTEXPR 830 tuple(allocator_arg_t __tag, const _Alloc& __a, 831 _UElements&&... __elements) 832 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) 833 { } 834 835 template<typename _Alloc, typename... _UElements, 836 bool _Valid = __valid_args<_UElements...>(), 837 _ExplicitCtor<_Valid, _UElements...> = false> 838 _GLIBCXX20_CONSTEXPR 839 explicit 840 tuple(allocator_arg_t __tag, const _Alloc& __a, 841 _UElements&&... __elements) 842 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) 843 { } 844 845 template<typename _Alloc> 846 _GLIBCXX20_CONSTEXPR 847 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 848 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 849 850 template<typename _Alloc> 851 _GLIBCXX20_CONSTEXPR 852 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 853 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 854 855 template<typename _Alloc, typename... _UElements, 856 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 857 && !__use_other_ctor<const tuple<_UElements...>&>(), 858 _ImplicitCtor<_Valid, const _UElements&...> = true> 859 _GLIBCXX20_CONSTEXPR 860 tuple(allocator_arg_t __tag, const _Alloc& __a, 861 const tuple<_UElements...>& __in) 862 : _Inherited(__tag, __a, 863 static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 864 { } 865 866 template<typename _Alloc, typename... _UElements, 867 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 868 && !__use_other_ctor<const tuple<_UElements...>&>(), 869 _ExplicitCtor<_Valid, const _UElements&...> = false> 870 _GLIBCXX20_CONSTEXPR 871 explicit 872 tuple(allocator_arg_t __tag, const _Alloc& __a, 873 const tuple<_UElements...>& __in) 874 : _Inherited(__tag, __a, 875 static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 876 { } 877 878 template<typename _Alloc, typename... _UElements, 879 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 880 && !__use_other_ctor<tuple<_UElements...>&&>(), 881 _ImplicitCtor<_Valid, _UElements...> = true> 882 _GLIBCXX20_CONSTEXPR 883 tuple(allocator_arg_t __tag, const _Alloc& __a, 884 tuple<_UElements...>&& __in) 885 : _Inherited(__tag, __a, 886 static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) 887 { } 888 889 template<typename _Alloc, typename... _UElements, 890 bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) 891 && !__use_other_ctor<tuple<_UElements...>&&>(), 892 _ExplicitCtor<_Valid, _UElements...> = false> 893 _GLIBCXX20_CONSTEXPR 894 explicit 895 tuple(allocator_arg_t __tag, const _Alloc& __a, 896 tuple<_UElements...>&& __in) 897 : _Inherited(__tag, __a, 898 static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) 899 { } 900 901 // tuple assignment 902 903 _GLIBCXX20_CONSTEXPR 904 tuple& 905 operator=(__conditional_t<__assignable<const _Elements&...>(), 906 const tuple&, 907 const __nonesuch&> __in) 908 noexcept(__nothrow_assignable<const _Elements&...>()) 909 { 910 this->_M_assign(__in); 911 return *this; 912 } 913 914 _GLIBCXX20_CONSTEXPR 915 tuple& 916 operator=(__conditional_t<__assignable<_Elements...>(), 917 tuple&&, 918 __nonesuch&&> __in) 919 noexcept(__nothrow_assignable<_Elements...>()) 920 { 921 this->_M_assign(std::move(__in)); 922 return *this; 923 } 924 925 template<typename... _UElements> 926 _GLIBCXX20_CONSTEXPR 927 __enable_if_t<__assignable<const _UElements&...>(), tuple&> 928 operator=(const tuple<_UElements...>& __in) 929 noexcept(__nothrow_assignable<const _UElements&...>()) 930 { 931 this->_M_assign(__in); 932 return *this; 933 } 934 935 template<typename... _UElements> 936 _GLIBCXX20_CONSTEXPR 937 __enable_if_t<__assignable<_UElements...>(), tuple&> 938 operator=(tuple<_UElements...>&& __in) 939 noexcept(__nothrow_assignable<_UElements...>()) 940 { 941 this->_M_assign(std::move(__in)); 942 return *this; 943 } 944 945 // tuple swap 946 _GLIBCXX20_CONSTEXPR 947 void 948 swap(tuple& __in) 949 noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) 950 { _Inherited::_M_swap(__in); } 951 }; 952 953 #if __cpp_deduction_guides >= 201606 954 template<typename... _UTypes> 955 tuple(_UTypes...) -> tuple<_UTypes...>; 956 template<typename _T1, typename _T2> 957 tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; 958 template<typename _Alloc, typename... _UTypes> 959 tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; 960 template<typename _Alloc, typename _T1, typename _T2> 961 tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; 962 template<typename _Alloc, typename... _UTypes> 963 tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; 964 #endif 965 966 // Explicit specialization, zero-element tuple. 967 template<> 968 class tuple<> 969 { 970 public: 971 _GLIBCXX20_CONSTEXPR 972 void swap(tuple&) noexcept { /* no-op */ } 973 // We need the default since we're going to define no-op 974 // allocator constructors. 975 tuple() = default; 976 // No-op allocator constructors. 977 template<typename _Alloc> 978 _GLIBCXX20_CONSTEXPR 979 tuple(allocator_arg_t, const _Alloc&) noexcept { } 980 template<typename _Alloc> 981 _GLIBCXX20_CONSTEXPR 982 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } 983 }; 984 985 /// Partial specialization, 2-element tuple. 986 /// Includes construction and assignment from a pair. 987 template<typename _T1, typename _T2> 988 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> 989 { 990 typedef _Tuple_impl<0, _T1, _T2> _Inherited; 991 992 // Constraint for non-explicit default constructor 993 template<bool _Dummy, typename _U1, typename _U2> 994 using _ImplicitDefaultCtor = __enable_if_t< 995 _TupleConstraints<_Dummy, _U1, _U2>:: 996 __is_implicitly_default_constructible(), 997 bool>; 998 999 // Constraint for explicit default constructor 1000 template<bool _Dummy, typename _U1, typename _U2> 1001 using _ExplicitDefaultCtor = __enable_if_t< 1002 _TupleConstraints<_Dummy, _U1, _U2>:: 1003 __is_explicitly_default_constructible(), 1004 bool>; 1005 1006 template<bool _Dummy> 1007 using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; 1008 1009 // Constraint for non-explicit constructors 1010 template<bool _Cond, typename _U1, typename _U2> 1011 using _ImplicitCtor = __enable_if_t< 1012 _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), 1013 bool>; 1014 1015 // Constraint for non-explicit constructors 1016 template<bool _Cond, typename _U1, typename _U2> 1017 using _ExplicitCtor = __enable_if_t< 1018 _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), 1019 bool>; 1020 1021 template<typename _U1, typename _U2> 1022 static constexpr bool __assignable() 1023 { 1024 return __and_<is_assignable<_T1&, _U1>, 1025 is_assignable<_T2&, _U2>>::value; 1026 } 1027 1028 template<typename _U1, typename _U2> 1029 static constexpr bool __nothrow_assignable() 1030 { 1031 return __and_<is_nothrow_assignable<_T1&, _U1>, 1032 is_nothrow_assignable<_T2&, _U2>>::value; 1033 } 1034 1035 template<typename _U1, typename _U2> 1036 static constexpr bool __nothrow_constructible() 1037 { 1038 return __and_<is_nothrow_constructible<_T1, _U1>, 1039 is_nothrow_constructible<_T2, _U2>>::value; 1040 } 1041 1042 static constexpr bool __nothrow_default_constructible() 1043 { 1044 return __and_<is_nothrow_default_constructible<_T1>, 1045 is_nothrow_default_constructible<_T2>>::value; 1046 } 1047 1048 template<typename _U1> 1049 static constexpr bool __is_alloc_arg() 1050 { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } 1051 1052 public: 1053 template<bool _Dummy = true, 1054 _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true> 1055 constexpr 1056 tuple() 1057 noexcept(__nothrow_default_constructible()) 1058 : _Inherited() { } 1059 1060 template<bool _Dummy = true, 1061 _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false> 1062 explicit constexpr 1063 tuple() 1064 noexcept(__nothrow_default_constructible()) 1065 : _Inherited() { } 1066 1067 template<bool _Dummy = true, 1068 _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true> 1069 constexpr 1070 tuple(const _T1& __a1, const _T2& __a2) 1071 noexcept(__nothrow_constructible<const _T1&, const _T2&>()) 1072 : _Inherited(__a1, __a2) { } 1073 1074 template<bool _Dummy = true, 1075 _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false> 1076 explicit constexpr 1077 tuple(const _T1& __a1, const _T2& __a2) 1078 noexcept(__nothrow_constructible<const _T1&, const _T2&>()) 1079 : _Inherited(__a1, __a2) { } 1080 1081 template<typename _U1, typename _U2, 1082 _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true> 1083 constexpr 1084 tuple(_U1&& __a1, _U2&& __a2) 1085 noexcept(__nothrow_constructible<_U1, _U2>()) 1086 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } 1087 1088 template<typename _U1, typename _U2, 1089 _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false> 1090 explicit constexpr 1091 tuple(_U1&& __a1, _U2&& __a2) 1092 noexcept(__nothrow_constructible<_U1, _U2>()) 1093 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } 1094 1095 constexpr tuple(const tuple&) = default; 1096 1097 constexpr tuple(tuple&&) = default; 1098 1099 template<typename _U1, typename _U2, 1100 _ImplicitCtor<true, const _U1&, const _U2&> = true> 1101 constexpr 1102 tuple(const tuple<_U1, _U2>& __in) 1103 noexcept(__nothrow_constructible<const _U1&, const _U2&>()) 1104 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } 1105 1106 template<typename _U1, typename _U2, 1107 _ExplicitCtor<true, const _U1&, const _U2&> = false> 1108 explicit constexpr 1109 tuple(const tuple<_U1, _U2>& __in) 1110 noexcept(__nothrow_constructible<const _U1&, const _U2&>()) 1111 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } 1112 1113 template<typename _U1, typename _U2, 1114 _ImplicitCtor<true, _U1, _U2> = true> 1115 constexpr 1116 tuple(tuple<_U1, _U2>&& __in) 1117 noexcept(__nothrow_constructible<_U1, _U2>()) 1118 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } 1119 1120 template<typename _U1, typename _U2, 1121 _ExplicitCtor<true, _U1, _U2> = false> 1122 explicit constexpr 1123 tuple(tuple<_U1, _U2>&& __in) 1124 noexcept(__nothrow_constructible<_U1, _U2>()) 1125 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } 1126 1127 template<typename _U1, typename _U2, 1128 _ImplicitCtor<true, const _U1&, const _U2&> = true> 1129 constexpr 1130 tuple(const pair<_U1, _U2>& __in) 1131 noexcept(__nothrow_constructible<const _U1&, const _U2&>()) 1132 : _Inherited(__in.first, __in.second) { } 1133 1134 template<typename _U1, typename _U2, 1135 _ExplicitCtor<true, const _U1&, const _U2&> = false> 1136 explicit constexpr 1137 tuple(const pair<_U1, _U2>& __in) 1138 noexcept(__nothrow_constructible<const _U1&, const _U2&>()) 1139 : _Inherited(__in.first, __in.second) { } 1140 1141 template<typename _U1, typename _U2, 1142 _ImplicitCtor<true, _U1, _U2> = true> 1143 constexpr 1144 tuple(pair<_U1, _U2>&& __in) 1145 noexcept(__nothrow_constructible<_U1, _U2>()) 1146 : _Inherited(std::forward<_U1>(__in.first), 1147 std::forward<_U2>(__in.second)) { } 1148 1149 template<typename _U1, typename _U2, 1150 _ExplicitCtor<true, _U1, _U2> = false> 1151 explicit constexpr 1152 tuple(pair<_U1, _U2>&& __in) 1153 noexcept(__nothrow_constructible<_U1, _U2>()) 1154 : _Inherited(std::forward<_U1>(__in.first), 1155 std::forward<_U2>(__in.second)) { } 1156 1157 // Allocator-extended constructors. 1158 1159 template<typename _Alloc, 1160 _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true> 1161 _GLIBCXX20_CONSTEXPR 1162 tuple(allocator_arg_t __tag, const _Alloc& __a) 1163 : _Inherited(__tag, __a) { } 1164 1165 template<typename _Alloc, 1166 _ExplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = false> 1167 _GLIBCXX20_CONSTEXPR 1168 explicit 1169 tuple(allocator_arg_t __tag, const _Alloc& __a) 1170 : _Inherited(__tag, __a) { } 1171 1172 template<typename _Alloc, bool _Dummy = true, 1173 _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true> 1174 _GLIBCXX20_CONSTEXPR 1175 tuple(allocator_arg_t __tag, const _Alloc& __a, 1176 const _T1& __a1, const _T2& __a2) 1177 : _Inherited(__tag, __a, __a1, __a2) { } 1178 1179 template<typename _Alloc, bool _Dummy = true, 1180 _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false> 1181 explicit 1182 _GLIBCXX20_CONSTEXPR 1183 tuple(allocator_arg_t __tag, const _Alloc& __a, 1184 const _T1& __a1, const _T2& __a2) 1185 : _Inherited(__tag, __a, __a1, __a2) { } 1186 1187 template<typename _Alloc, typename _U1, typename _U2, 1188 _ImplicitCtor<true, _U1, _U2> = true> 1189 _GLIBCXX20_CONSTEXPR 1190 tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) 1191 : _Inherited(__tag, __a, std::forward<_U1>(__a1), 1192 std::forward<_U2>(__a2)) { } 1193 1194 template<typename _Alloc, typename _U1, typename _U2, 1195 _ExplicitCtor<true, _U1, _U2> = false> 1196 explicit 1197 _GLIBCXX20_CONSTEXPR 1198 tuple(allocator_arg_t __tag, const _Alloc& __a, 1199 _U1&& __a1, _U2&& __a2) 1200 : _Inherited(__tag, __a, std::forward<_U1>(__a1), 1201 std::forward<_U2>(__a2)) { } 1202 1203 template<typename _Alloc> 1204 _GLIBCXX20_CONSTEXPR 1205 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 1206 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 1207 1208 template<typename _Alloc> 1209 _GLIBCXX20_CONSTEXPR 1210 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 1211 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 1212 1213 template<typename _Alloc, typename _U1, typename _U2, 1214 _ImplicitCtor<true, const _U1&, const _U2&> = true> 1215 _GLIBCXX20_CONSTEXPR 1216 tuple(allocator_arg_t __tag, const _Alloc& __a, 1217 const tuple<_U1, _U2>& __in) 1218 : _Inherited(__tag, __a, 1219 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) 1220 { } 1221 1222 template<typename _Alloc, typename _U1, typename _U2, 1223 _ExplicitCtor<true, const _U1&, const _U2&> = false> 1224 explicit 1225 _GLIBCXX20_CONSTEXPR 1226 tuple(allocator_arg_t __tag, const _Alloc& __a, 1227 const tuple<_U1, _U2>& __in) 1228 : _Inherited(__tag, __a, 1229 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) 1230 { } 1231 1232 template<typename _Alloc, typename _U1, typename _U2, 1233 _ImplicitCtor<true, _U1, _U2> = true> 1234 _GLIBCXX20_CONSTEXPR 1235 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) 1236 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) 1237 { } 1238 1239 template<typename _Alloc, typename _U1, typename _U2, 1240 _ExplicitCtor<true, _U1, _U2> = false> 1241 explicit 1242 _GLIBCXX20_CONSTEXPR 1243 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) 1244 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) 1245 { } 1246 1247 template<typename _Alloc, typename _U1, typename _U2, 1248 _ImplicitCtor<true, const _U1&, const _U2&> = true> 1249 _GLIBCXX20_CONSTEXPR 1250 tuple(allocator_arg_t __tag, const _Alloc& __a, 1251 const pair<_U1, _U2>& __in) 1252 : _Inherited(__tag, __a, __in.first, __in.second) { } 1253 1254 template<typename _Alloc, typename _U1, typename _U2, 1255 _ExplicitCtor<true, const _U1&, const _U2&> = false> 1256 explicit 1257 _GLIBCXX20_CONSTEXPR 1258 tuple(allocator_arg_t __tag, const _Alloc& __a, 1259 const pair<_U1, _U2>& __in) 1260 : _Inherited(__tag, __a, __in.first, __in.second) { } 1261 1262 template<typename _Alloc, typename _U1, typename _U2, 1263 _ImplicitCtor<true, _U1, _U2> = true> 1264 _GLIBCXX20_CONSTEXPR 1265 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) 1266 : _Inherited(__tag, __a, std::forward<_U1>(__in.first), 1267 std::forward<_U2>(__in.second)) { } 1268 1269 template<typename _Alloc, typename _U1, typename _U2, 1270 _ExplicitCtor<true, _U1, _U2> = false> 1271 explicit 1272 _GLIBCXX20_CONSTEXPR 1273 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) 1274 : _Inherited(__tag, __a, std::forward<_U1>(__in.first), 1275 std::forward<_U2>(__in.second)) { } 1276 1277 // Tuple assignment. 1278 1279 _GLIBCXX20_CONSTEXPR 1280 tuple& 1281 operator=(__conditional_t<__assignable<const _T1&, const _T2&>(), 1282 const tuple&, 1283 const __nonesuch&> __in) 1284 noexcept(__nothrow_assignable<const _T1&, const _T2&>()) 1285 { 1286 this->_M_assign(__in); 1287 return *this; 1288 } 1289 1290 _GLIBCXX20_CONSTEXPR 1291 tuple& 1292 operator=(__conditional_t<__assignable<_T1, _T2>(), 1293 tuple&&, 1294 __nonesuch&&> __in) 1295 noexcept(__nothrow_assignable<_T1, _T2>()) 1296 { 1297 this->_M_assign(std::move(__in)); 1298 return *this; 1299 } 1300 1301 template<typename _U1, typename _U2> 1302 _GLIBCXX20_CONSTEXPR 1303 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&> 1304 operator=(const tuple<_U1, _U2>& __in) 1305 noexcept(__nothrow_assignable<const _U1&, const _U2&>()) 1306 { 1307 this->_M_assign(__in); 1308 return *this; 1309 } 1310 1311 template<typename _U1, typename _U2> 1312 _GLIBCXX20_CONSTEXPR 1313 __enable_if_t<__assignable<_U1, _U2>(), tuple&> 1314 operator=(tuple<_U1, _U2>&& __in) 1315 noexcept(__nothrow_assignable<_U1, _U2>()) 1316 { 1317 this->_M_assign(std::move(__in)); 1318 return *this; 1319 } 1320 1321 template<typename _U1, typename _U2> 1322 _GLIBCXX20_CONSTEXPR 1323 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&> 1324 operator=(const pair<_U1, _U2>& __in) 1325 noexcept(__nothrow_assignable<const _U1&, const _U2&>()) 1326 { 1327 this->_M_head(*this) = __in.first; 1328 this->_M_tail(*this)._M_head(*this) = __in.second; 1329 return *this; 1330 } 1331 1332 template<typename _U1, typename _U2> 1333 _GLIBCXX20_CONSTEXPR 1334 __enable_if_t<__assignable<_U1, _U2>(), tuple&> 1335 operator=(pair<_U1, _U2>&& __in) 1336 noexcept(__nothrow_assignable<_U1, _U2>()) 1337 { 1338 this->_M_head(*this) = std::forward<_U1>(__in.first); 1339 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); 1340 return *this; 1341 } 1342 1343 _GLIBCXX20_CONSTEXPR 1344 void 1345 swap(tuple& __in) 1346 noexcept(__and_<__is_nothrow_swappable<_T1>, 1347 __is_nothrow_swappable<_T2>>::value) 1348 { _Inherited::_M_swap(__in); } 1349 }; 1350 1351 1352 /// class tuple_size 1353 template<typename... _Elements> 1354 struct tuple_size<tuple<_Elements...>> 1355 : public integral_constant<size_t, sizeof...(_Elements)> { }; 1356 1357 #if __cplusplus >= 201703L 1358 template<typename... _Types> 1359 inline constexpr size_t tuple_size_v<tuple<_Types...>> 1360 = sizeof...(_Types); 1361 1362 template<typename... _Types> 1363 inline constexpr size_t tuple_size_v<const tuple<_Types...>> 1364 = sizeof...(_Types); 1365 #endif 1366 1367 /// Trait to get the Ith element type from a tuple. 1368 template<size_t __i, typename... _Types> 1369 struct tuple_element<__i, tuple<_Types...>> 1370 { 1371 static_assert(__i < sizeof...(_Types), "tuple index must be in range"); 1372 1373 using type = typename _Nth_type<__i, _Types...>::type; 1374 }; 1375 1376 template<size_t __i, typename _Head, typename... _Tail> 1377 constexpr _Head& 1378 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1379 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1380 1381 template<size_t __i, typename _Head, typename... _Tail> 1382 constexpr const _Head& 1383 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1384 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1385 1386 // Deleted overload to improve diagnostics for invalid indices 1387 template<size_t __i, typename... _Types> 1388 __enable_if_t<(__i >= sizeof...(_Types))> 1389 __get_helper(const tuple<_Types...>&) = delete; 1390 1391 /// Return a reference to the ith element of a tuple. 1392 template<size_t __i, typename... _Elements> 1393 constexpr __tuple_element_t<__i, tuple<_Elements...>>& 1394 get(tuple<_Elements...>& __t) noexcept 1395 { return std::__get_helper<__i>(__t); } 1396 1397 /// Return a const reference to the ith element of a const tuple. 1398 template<size_t __i, typename... _Elements> 1399 constexpr const __tuple_element_t<__i, tuple<_Elements...>>& 1400 get(const tuple<_Elements...>& __t) noexcept 1401 { return std::__get_helper<__i>(__t); } 1402 1403 /// Return an rvalue reference to the ith element of a tuple rvalue. 1404 template<size_t __i, typename... _Elements> 1405 constexpr __tuple_element_t<__i, tuple<_Elements...>>&& 1406 get(tuple<_Elements...>&& __t) noexcept 1407 { 1408 typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; 1409 return std::forward<__element_type>(std::__get_helper<__i>(__t)); 1410 } 1411 1412 /// Return a const rvalue reference to the ith element of a const tuple rvalue. 1413 template<size_t __i, typename... _Elements> 1414 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& 1415 get(const tuple<_Elements...>&& __t) noexcept 1416 { 1417 typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; 1418 return std::forward<const __element_type>(std::__get_helper<__i>(__t)); 1419 } 1420 1421 /// @cond undocumented 1422 // Deleted overload chosen for invalid indices. 1423 template<size_t __i, typename... _Elements> 1424 constexpr __enable_if_t<(__i >= sizeof...(_Elements))> 1425 get(const tuple<_Elements...>&) = delete; 1426 /// @endcond 1427 1428 #if __cplusplus >= 201402L 1429 1430 #define __cpp_lib_tuples_by_type 201304L 1431 1432 /// Return a reference to the unique element of type _Tp of a tuple. 1433 template <typename _Tp, typename... _Types> 1434 constexpr _Tp& 1435 get(tuple<_Types...>& __t) noexcept 1436 { 1437 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); 1438 static_assert(__idx < sizeof...(_Types), 1439 "the type T in std::get<T> must occur exactly once in the tuple"); 1440 return std::__get_helper<__idx>(__t); 1441 } 1442 1443 /// Return a reference to the unique element of type _Tp of a tuple rvalue. 1444 template <typename _Tp, typename... _Types> 1445 constexpr _Tp&& 1446 get(tuple<_Types...>&& __t) noexcept 1447 { 1448 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); 1449 static_assert(__idx < sizeof...(_Types), 1450 "the type T in std::get<T> must occur exactly once in the tuple"); 1451 return std::forward<_Tp>(std::__get_helper<__idx>(__t)); 1452 } 1453 1454 /// Return a const reference to the unique element of type _Tp of a tuple. 1455 template <typename _Tp, typename... _Types> 1456 constexpr const _Tp& 1457 get(const tuple<_Types...>& __t) noexcept 1458 { 1459 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); 1460 static_assert(__idx < sizeof...(_Types), 1461 "the type T in std::get<T> must occur exactly once in the tuple"); 1462 return std::__get_helper<__idx>(__t); 1463 } 1464 1465 /// Return a const reference to the unique element of type _Tp of 1466 /// a const tuple rvalue. 1467 template <typename _Tp, typename... _Types> 1468 constexpr const _Tp&& 1469 get(const tuple<_Types...>&& __t) noexcept 1470 { 1471 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); 1472 static_assert(__idx < sizeof...(_Types), 1473 "the type T in std::get<T> must occur exactly once in the tuple"); 1474 return std::forward<const _Tp>(std::__get_helper<__idx>(__t)); 1475 } 1476 #endif 1477 1478 // This class performs the comparison operations on tuples 1479 template<typename _Tp, typename _Up, size_t __i, size_t __size> 1480 struct __tuple_compare 1481 { 1482 static constexpr bool 1483 __eq(const _Tp& __t, const _Up& __u) 1484 { 1485 return bool(std::get<__i>(__t) == std::get<__i>(__u)) 1486 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); 1487 } 1488 1489 static constexpr bool 1490 __less(const _Tp& __t, const _Up& __u) 1491 { 1492 return bool(std::get<__i>(__t) < std::get<__i>(__u)) 1493 || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) 1494 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); 1495 } 1496 }; 1497 1498 template<typename _Tp, typename _Up, size_t __size> 1499 struct __tuple_compare<_Tp, _Up, __size, __size> 1500 { 1501 static constexpr bool 1502 __eq(const _Tp&, const _Up&) { return true; } 1503 1504 static constexpr bool 1505 __less(const _Tp&, const _Up&) { return false; } 1506 }; 1507 1508 template<typename... _TElements, typename... _UElements> 1509 constexpr bool 1510 operator==(const tuple<_TElements...>& __t, 1511 const tuple<_UElements...>& __u) 1512 { 1513 static_assert(sizeof...(_TElements) == sizeof...(_UElements), 1514 "tuple objects can only be compared if they have equal sizes."); 1515 using __compare = __tuple_compare<tuple<_TElements...>, 1516 tuple<_UElements...>, 1517 0, sizeof...(_TElements)>; 1518 return __compare::__eq(__t, __u); 1519 } 1520 1521 #if __cpp_lib_three_way_comparison 1522 template<typename _Cat, typename _Tp, typename _Up> 1523 constexpr _Cat 1524 __tuple_cmp(const _Tp&, const _Up&, index_sequence<>) 1525 { return _Cat::equivalent; } 1526 1527 template<typename _Cat, typename _Tp, typename _Up, 1528 size_t _Idx0, size_t... _Idxs> 1529 constexpr _Cat 1530 __tuple_cmp(const _Tp& __t, const _Up& __u, 1531 index_sequence<_Idx0, _Idxs...>) 1532 { 1533 auto __c 1534 = __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u)); 1535 if (__c != 0) 1536 return __c; 1537 return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>()); 1538 } 1539 1540 template<typename... _Tps, typename... _Ups> 1541 constexpr 1542 common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...> 1543 operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u) 1544 { 1545 using _Cat 1546 = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>; 1547 return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>()); 1548 } 1549 #else 1550 template<typename... _TElements, typename... _UElements> 1551 constexpr bool 1552 operator<(const tuple<_TElements...>& __t, 1553 const tuple<_UElements...>& __u) 1554 { 1555 static_assert(sizeof...(_TElements) == sizeof...(_UElements), 1556 "tuple objects can only be compared if they have equal sizes."); 1557 using __compare = __tuple_compare<tuple<_TElements...>, 1558 tuple<_UElements...>, 1559 0, sizeof...(_TElements)>; 1560 return __compare::__less(__t, __u); 1561 } 1562 1563 template<typename... _TElements, typename... _UElements> 1564 constexpr bool 1565 operator!=(const tuple<_TElements...>& __t, 1566 const tuple<_UElements...>& __u) 1567 { return !(__t == __u); } 1568 1569 template<typename... _TElements, typename... _UElements> 1570 constexpr bool 1571 operator>(const tuple<_TElements...>& __t, 1572 const tuple<_UElements...>& __u) 1573 { return __u < __t; } 1574 1575 template<typename... _TElements, typename... _UElements> 1576 constexpr bool 1577 operator<=(const tuple<_TElements...>& __t, 1578 const tuple<_UElements...>& __u) 1579 { return !(__u < __t); } 1580 1581 template<typename... _TElements, typename... _UElements> 1582 constexpr bool 1583 operator>=(const tuple<_TElements...>& __t, 1584 const tuple<_UElements...>& __u) 1585 { return !(__t < __u); } 1586 #endif // three_way_comparison 1587 1588 // NB: DR 705. 1589 /// Create a tuple containing copies of the arguments 1590 template<typename... _Elements> 1591 constexpr tuple<typename __decay_and_strip<_Elements>::__type...> 1592 make_tuple(_Elements&&... __args) 1593 { 1594 typedef tuple<typename __decay_and_strip<_Elements>::__type...> 1595 __result_type; 1596 return __result_type(std::forward<_Elements>(__args)...); 1597 } 1598 1599 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1600 // 2275. Why is forward_as_tuple not constexpr? 1601 /// Create a tuple of lvalue or rvalue references to the arguments 1602 template<typename... _Elements> 1603 constexpr tuple<_Elements&&...> 1604 forward_as_tuple(_Elements&&... __args) noexcept 1605 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } 1606 1607 // Declarations of std::array and its std::get overloads, so that 1608 // std::tuple_cat can use them if <tuple> is included before <array>. 1609 1610 template<typename _Tp, size_t _Nm> struct array; 1611 1612 template<size_t _Int, typename _Tp, size_t _Nm> 1613 constexpr _Tp& 1614 get(array<_Tp, _Nm>&) noexcept; 1615 1616 template<size_t _Int, typename _Tp, size_t _Nm> 1617 constexpr _Tp&& 1618 get(array<_Tp, _Nm>&&) noexcept; 1619 1620 template<size_t _Int, typename _Tp, size_t _Nm> 1621 constexpr const _Tp& 1622 get(const array<_Tp, _Nm>&) noexcept; 1623 1624 template<size_t _Int, typename _Tp, size_t _Nm> 1625 constexpr const _Tp&& 1626 get(const array<_Tp, _Nm>&&) noexcept; 1627 1628 /// @cond undocumented 1629 template<size_t, typename, typename, size_t> 1630 struct __make_tuple_impl; 1631 1632 template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm> 1633 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> 1634 : __make_tuple_impl<_Idx + 1, 1635 tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, 1636 _Tuple, _Nm> 1637 { }; 1638 1639 template<size_t _Nm, typename _Tuple, typename... _Tp> 1640 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> 1641 { 1642 typedef tuple<_Tp...> __type; 1643 }; 1644 1645 template<typename _Tuple> 1646 struct __do_make_tuple 1647 : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> 1648 { }; 1649 1650 // Returns the std::tuple equivalent of a tuple-like type. 1651 template<typename _Tuple> 1652 struct __make_tuple 1653 : public __do_make_tuple<__remove_cvref_t<_Tuple>> 1654 { }; 1655 1656 // Combines several std::tuple's into a single one. 1657 template<typename...> 1658 struct __combine_tuples; 1659 1660 template<> 1661 struct __combine_tuples<> 1662 { 1663 typedef tuple<> __type; 1664 }; 1665 1666 template<typename... _Ts> 1667 struct __combine_tuples<tuple<_Ts...>> 1668 { 1669 typedef tuple<_Ts...> __type; 1670 }; 1671 1672 template<typename... _T1s, typename... _T2s, typename... _Rem> 1673 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> 1674 { 1675 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, 1676 _Rem...>::__type __type; 1677 }; 1678 1679 // Computes the result type of tuple_cat given a set of tuple-like types. 1680 template<typename... _Tpls> 1681 struct __tuple_cat_result 1682 { 1683 typedef typename __combine_tuples 1684 <typename __make_tuple<_Tpls>::__type...>::__type __type; 1685 }; 1686 1687 // Helper to determine the index set for the first tuple-like 1688 // type of a given set. 1689 template<typename...> 1690 struct __make_1st_indices; 1691 1692 template<> 1693 struct __make_1st_indices<> 1694 { 1695 typedef _Index_tuple<> __type; 1696 }; 1697 1698 template<typename _Tp, typename... _Tpls> 1699 struct __make_1st_indices<_Tp, _Tpls...> 1700 { 1701 typedef typename _Build_index_tuple<tuple_size< 1702 typename remove_reference<_Tp>::type>::value>::__type __type; 1703 }; 1704 1705 // Performs the actual concatenation by step-wise expanding tuple-like 1706 // objects into the elements, which are finally forwarded into the 1707 // result tuple. 1708 template<typename _Ret, typename _Indices, typename... _Tpls> 1709 struct __tuple_concater; 1710 1711 template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls> 1712 struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> 1713 { 1714 template<typename... _Us> 1715 static constexpr _Ret 1716 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) 1717 { 1718 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1719 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; 1720 return __next::_S_do(std::forward<_Tpls>(__tps)..., 1721 std::forward<_Us>(__us)..., 1722 std::get<_Is>(std::forward<_Tp>(__tp))...); 1723 } 1724 }; 1725 1726 template<typename _Ret> 1727 struct __tuple_concater<_Ret, _Index_tuple<>> 1728 { 1729 template<typename... _Us> 1730 static constexpr _Ret 1731 _S_do(_Us&&... __us) 1732 { 1733 return _Ret(std::forward<_Us>(__us)...); 1734 } 1735 }; 1736 1737 template<typename... _Tps> 1738 struct __is_tuple_like_impl<tuple<_Tps...>> : true_type 1739 { }; 1740 /// @endcond 1741 1742 /// Create a `tuple` containing all elements from multiple tuple-like objects 1743 template<typename... _Tpls, typename = typename 1744 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type> 1745 constexpr auto 1746 tuple_cat(_Tpls&&... __tpls) 1747 -> typename __tuple_cat_result<_Tpls...>::__type 1748 { 1749 typedef typename __tuple_cat_result<_Tpls...>::__type __ret; 1750 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1751 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; 1752 return __concater::_S_do(std::forward<_Tpls>(__tpls)...); 1753 } 1754 1755 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1756 // 2301. Why is tie not constexpr? 1757 /// Return a tuple of lvalue references bound to the arguments 1758 template<typename... _Elements> 1759 constexpr tuple<_Elements&...> 1760 tie(_Elements&... __args) noexcept 1761 { return tuple<_Elements&...>(__args...); } 1762 1763 /// Exchange the values of two tuples 1764 template<typename... _Elements> 1765 _GLIBCXX20_CONSTEXPR 1766 inline 1767 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 1768 // Constrained free swap overload, see p0185r1 1769 typename enable_if<__and_<__is_swappable<_Elements>...>::value 1770 >::type 1771 #else 1772 void 1773 #endif 1774 swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) 1775 noexcept(noexcept(__x.swap(__y))) 1776 { __x.swap(__y); } 1777 1778 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 1779 /// Exchange the values of two const tuples (if const elements can be swapped) 1780 template<typename... _Elements> 1781 _GLIBCXX20_CONSTEXPR 1782 typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type 1783 swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; 1784 #endif 1785 1786 // A class (and instance) which can be used in 'tie' when an element 1787 // of a tuple is not required. 1788 // _GLIBCXX14_CONSTEXPR 1789 // 2933. PR for LWG 2773 could be clearer 1790 struct _Swallow_assign 1791 { 1792 template<class _Tp> 1793 _GLIBCXX14_CONSTEXPR const _Swallow_assign& 1794 operator=(const _Tp&) const 1795 { return *this; } 1796 }; 1797 1798 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1799 // 2773. Making std::ignore constexpr 1800 /** Used with `std::tie` to ignore an element of a tuple 1801 * 1802 * When using `std::tie` to assign the elements of a tuple to variables, 1803 * unwanted elements can be ignored by using `std::ignore`. For example: 1804 * 1805 * ``` 1806 * int x, y; 1807 * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3); 1808 * ``` 1809 * 1810 * This assignment will perform `x=1; std::ignore=2; y=3;` which results 1811 * in the second element being ignored. 1812 * 1813 * @since C++11 1814 */ 1815 _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{}; 1816 1817 /// Partial specialization for tuples 1818 template<typename... _Types, typename _Alloc> 1819 struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { }; 1820 1821 // See stl_pair.h... 1822 /** "piecewise construction" using a tuple of arguments for each member. 1823 * 1824 * @param __first Arguments for the first member of the pair. 1825 * @param __second Arguments for the second member of the pair. 1826 * 1827 * The elements of each tuple will be used as the constructor arguments 1828 * for the data members of the pair. 1829 */ 1830 template<class _T1, class _T2> 1831 template<typename... _Args1, typename... _Args2> 1832 _GLIBCXX20_CONSTEXPR 1833 inline 1834 pair<_T1, _T2>:: 1835 pair(piecewise_construct_t, 1836 tuple<_Args1...> __first, tuple<_Args2...> __second) 1837 : pair(__first, __second, 1838 typename _Build_index_tuple<sizeof...(_Args1)>::__type(), 1839 typename _Build_index_tuple<sizeof...(_Args2)>::__type()) 1840 { } 1841 1842 template<class _T1, class _T2> 1843 template<typename... _Args1, size_t... _Indexes1, 1844 typename... _Args2, size_t... _Indexes2> 1845 _GLIBCXX20_CONSTEXPR inline 1846 pair<_T1, _T2>:: 1847 pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, 1848 _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) 1849 : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), 1850 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) 1851 { } 1852 1853 #if __cplusplus >= 201703L 1854 1855 // Unpack a std::tuple into a type trait and use its value. 1856 // For cv std::tuple<_Up> the result is _Trait<_Tp, cv _Up...>::value. 1857 // For cv std::tuple<_Up>& the result is _Trait<_Tp, cv _Up&...>::value. 1858 // Otherwise the result is false (because we don't know if std::get throws). 1859 template<template<typename...> class _Trait, typename _Tp, typename _Tuple> 1860 inline constexpr bool __unpack_std_tuple = false; 1861 1862 template<template<typename...> class _Trait, typename _Tp, typename... _Up> 1863 inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> 1864 = _Trait<_Tp, _Up...>::value; 1865 1866 template<template<typename...> class _Trait, typename _Tp, typename... _Up> 1867 inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> 1868 = _Trait<_Tp, _Up&...>::value; 1869 1870 template<template<typename...> class _Trait, typename _Tp, typename... _Up> 1871 inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> 1872 = _Trait<_Tp, const _Up...>::value; 1873 1874 template<template<typename...> class _Trait, typename _Tp, typename... _Up> 1875 inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> 1876 = _Trait<_Tp, const _Up&...>::value; 1877 1878 # define __cpp_lib_apply 201603L 1879 1880 template <typename _Fn, typename _Tuple, size_t... _Idx> 1881 constexpr decltype(auto) 1882 __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) 1883 { 1884 return std::__invoke(std::forward<_Fn>(__f), 1885 std::get<_Idx>(std::forward<_Tuple>(__t))...); 1886 } 1887 1888 template <typename _Fn, typename _Tuple> 1889 constexpr decltype(auto) 1890 apply(_Fn&& __f, _Tuple&& __t) 1891 noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>) 1892 { 1893 using _Indices 1894 = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>; 1895 return std::__apply_impl(std::forward<_Fn>(__f), 1896 std::forward<_Tuple>(__t), 1897 _Indices{}); 1898 } 1899 1900 #define __cpp_lib_make_from_tuple 201606L 1901 1902 template <typename _Tp, typename _Tuple, size_t... _Idx> 1903 constexpr _Tp 1904 __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) 1905 { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } 1906 1907 template <typename _Tp, typename _Tuple> 1908 constexpr _Tp 1909 make_from_tuple(_Tuple&& __t) 1910 noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>) 1911 { 1912 return __make_from_tuple_impl<_Tp>( 1913 std::forward<_Tuple>(__t), 1914 make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}); 1915 } 1916 #endif // C++17 1917 1918 /// @} 1919 1920 _GLIBCXX_END_NAMESPACE_VERSION 1921 } // namespace std 1922 1923 #endif // C++11 1924 1925 #endif // _GLIBCXX_TUPLE 1926
Indexes created Fri Apr 24 00:22:58 UTC 2026