1// <tuple> -*- C++ -*- 2 3// Copyright (C) 2007-2017 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 <utility> 39#include <array> 40#include <bits/uses_allocator.h> 41#include <bits/invoke.h> 42 43namespace std _GLIBCXX_VISIBILITY(default) 44{ 45_GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 /** 48 * @addtogroup utilities 49 * @{ 50 */ 51 52 template<typename... _Elements> 53 class tuple; 54 55 template<typename _Tp> 56 struct __is_empty_non_tuple : is_empty<_Tp> { }; 57 58 // Using EBO for elements that are tuples causes ambiguous base errors. 59 template<typename _El0, typename... _El> 60 struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { }; 61 62 // Use the Empty Base-class Optimization for empty, non-final types. 63 template<typename _Tp> 64 using __empty_not_final 65 = typename conditional<__is_final(_Tp), false_type, 66 __is_empty_non_tuple<_Tp>>::type; 67 68 template<std::size_t _Idx, typename _Head, 69 bool = __empty_not_final<_Head>::value> 70 struct _Head_base; 71 72 template<std::size_t _Idx, typename _Head> 73 struct _Head_base<_Idx, _Head, true> 74 : public _Head 75 { 76 constexpr _Head_base() 77 : _Head() { } 78 79 constexpr _Head_base(const _Head& __h) 80 : _Head(__h) { } 81 82 constexpr _Head_base(const _Head_base&) = default; 83 constexpr _Head_base(_Head_base&&) = default; 84 85 template<typename _UHead> 86 constexpr _Head_base(_UHead&& __h) 87 : _Head(std::forward<_UHead>(__h)) { } 88 89 _Head_base(allocator_arg_t, __uses_alloc0) 90 : _Head() { } 91 92 template<typename _Alloc> 93 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) 94 : _Head(allocator_arg, *__a._M_a) { } 95 96 template<typename _Alloc> 97 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) 98 : _Head(*__a._M_a) { } 99 100 template<typename _UHead> 101 _Head_base(__uses_alloc0, _UHead&& __uhead) 102 : _Head(std::forward<_UHead>(__uhead)) { } 103 104 template<typename _Alloc, typename _UHead> 105 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 106 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } 107 108 template<typename _Alloc, typename _UHead> 109 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 110 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } 111 112 static constexpr _Head& 113 _M_head(_Head_base& __b) noexcept { return __b; } 114 115 static constexpr const _Head& 116 _M_head(const _Head_base& __b) noexcept { return __b; } 117 }; 118 119 template<std::size_t _Idx, typename _Head> 120 struct _Head_base<_Idx, _Head, false> 121 { 122 constexpr _Head_base() 123 : _M_head_impl() { } 124 125 constexpr _Head_base(const _Head& __h) 126 : _M_head_impl(__h) { } 127 128 constexpr _Head_base(const _Head_base&) = default; 129 constexpr _Head_base(_Head_base&&) = default; 130 131 template<typename _UHead> 132 constexpr _Head_base(_UHead&& __h) 133 : _M_head_impl(std::forward<_UHead>(__h)) { } 134 135 _Head_base(allocator_arg_t, __uses_alloc0) 136 : _M_head_impl() { } 137 138 template<typename _Alloc> 139 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) 140 : _M_head_impl(allocator_arg, *__a._M_a) { } 141 142 template<typename _Alloc> 143 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) 144 : _M_head_impl(*__a._M_a) { } 145 146 template<typename _UHead> 147 _Head_base(__uses_alloc0, _UHead&& __uhead) 148 : _M_head_impl(std::forward<_UHead>(__uhead)) { } 149 150 template<typename _Alloc, typename _UHead> 151 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 152 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) 153 { } 154 155 template<typename _Alloc, typename _UHead> 156 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 157 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } 158 159 static constexpr _Head& 160 _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } 161 162 static constexpr const _Head& 163 _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } 164 165 _Head _M_head_impl; 166 }; 167 168 /** 169 * Contains the actual implementation of the @c tuple template, stored 170 * as a recursive inheritance hierarchy from the first element (most 171 * derived class) to the last (least derived class). The @c Idx 172 * parameter gives the 0-based index of the element stored at this 173 * point in the hierarchy; we use it to implement a constant-time 174 * get() operation. 175 */ 176 template<std::size_t _Idx, typename... _Elements> 177 struct _Tuple_impl; 178 179 /** 180 * Recursive tuple implementation. Here we store the @c Head element 181 * and derive from a @c Tuple_impl containing the remaining elements 182 * (which contains the @c Tail). 183 */ 184 template<std::size_t _Idx, typename _Head, typename... _Tail> 185 struct _Tuple_impl<_Idx, _Head, _Tail...> 186 : public _Tuple_impl<_Idx + 1, _Tail...>, 187 private _Head_base<_Idx, _Head> 188 { 189 template<std::size_t, typename...> friend class _Tuple_impl; 190 191 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; 192 typedef _Head_base<_Idx, _Head> _Base; 193 194 static constexpr _Head& 195 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 196 197 static constexpr const _Head& 198 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 199 200 static constexpr _Inherited& 201 _M_tail(_Tuple_impl& __t) noexcept { return __t; } 202 203 static constexpr const _Inherited& 204 _M_tail(const _Tuple_impl& __t) noexcept { return __t; } 205 206 constexpr _Tuple_impl() 207 : _Inherited(), _Base() { } 208 209 explicit 210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) 211 : _Inherited(__tail...), _Base(__head) { } 212 213 template<typename _UHead, typename... _UTail, typename = typename 214 enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 215 explicit 216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) 217 : _Inherited(std::forward<_UTail>(__tail)...), 218 _Base(std::forward<_UHead>(__head)) { } 219 220 constexpr _Tuple_impl(const _Tuple_impl&) = default; 221 222 constexpr 223 _Tuple_impl(_Tuple_impl&& __in) 224 noexcept(__and_<is_nothrow_move_constructible<_Head>, 225 is_nothrow_move_constructible<_Inherited>>::value) 226 : _Inherited(std::move(_M_tail(__in))), 227 _Base(std::forward<_Head>(_M_head(__in))) { } 228 229 template<typename... _UElements> 230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) 231 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), 232 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } 233 234 template<typename _UHead, typename... _UTails> 235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 236 : _Inherited(std::move 237 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 238 _Base(std::forward<_UHead> 239 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } 240 241 template<typename _Alloc> 242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) 243 : _Inherited(__tag, __a), 244 _Base(__tag, __use_alloc<_Head>(__a)) { } 245 246 template<typename _Alloc> 247 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 248 const _Head& __head, const _Tail&... __tail) 249 : _Inherited(__tag, __a, __tail...), 250 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } 251 252 template<typename _Alloc, typename _UHead, typename... _UTail, 253 typename = typename enable_if<sizeof...(_Tail) 254 == sizeof...(_UTail)>::type> 255 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 256 _UHead&& __head, _UTail&&... __tail) 257 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), 258 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 259 std::forward<_UHead>(__head)) { } 260 261 template<typename _Alloc> 262 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 263 const _Tuple_impl& __in) 264 : _Inherited(__tag, __a, _M_tail(__in)), 265 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } 266 267 template<typename _Alloc> 268 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 269 _Tuple_impl&& __in) 270 : _Inherited(__tag, __a, std::move(_M_tail(__in))), 271 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 272 std::forward<_Head>(_M_head(__in))) { } 273 274 template<typename _Alloc, typename... _UElements> 275 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 276 const _Tuple_impl<_Idx, _UElements...>& __in) 277 : _Inherited(__tag, __a, 278 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), 279 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 280 _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } 281 282 template<typename _Alloc, typename _UHead, typename... _UTails> 283 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 284 _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 285 : _Inherited(__tag, __a, std::move 286 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 287 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 288 std::forward<_UHead> 289 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } 290 291 _Tuple_impl& 292 operator=(const _Tuple_impl& __in) 293 { 294 _M_head(*this) = _M_head(__in); 295 _M_tail(*this) = _M_tail(__in); 296 return *this; 297 } 298 299 _Tuple_impl& 300 operator=(_Tuple_impl&& __in) 301 noexcept(__and_<is_nothrow_move_assignable<_Head>, 302 is_nothrow_move_assignable<_Inherited>>::value) 303 { 304 _M_head(*this) = std::forward<_Head>(_M_head(__in)); 305 _M_tail(*this) = std::move(_M_tail(__in)); 306 return *this; 307 } 308 309 template<typename... _UElements> 310 _Tuple_impl& 311 operator=(const _Tuple_impl<_Idx, _UElements...>& __in) 312 { 313 _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); 314 _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in); 315 return *this; 316 } 317 318 template<typename _UHead, typename... _UTails> 319 _Tuple_impl& 320 operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 321 { 322 _M_head(*this) = std::forward<_UHead> 323 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); 324 _M_tail(*this) = std::move 325 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)); 326 return *this; 327 } 328 329 protected: 330 void 331 _M_swap(_Tuple_impl& __in) 332 noexcept(__is_nothrow_swappable<_Head>::value 333 && noexcept(_M_tail(__in)._M_swap(_M_tail(__in)))) 334 { 335 using std::swap; 336 swap(_M_head(*this), _M_head(__in)); 337 _Inherited::_M_swap(_M_tail(__in)); 338 } 339 }; 340 341 // Basis case of inheritance recursion. 342 template<std::size_t _Idx, typename _Head> 343 struct _Tuple_impl<_Idx, _Head> 344 : private _Head_base<_Idx, _Head> 345 { 346 template<std::size_t, typename...> friend class _Tuple_impl; 347 348 typedef _Head_base<_Idx, _Head> _Base; 349 350 static constexpr _Head& 351 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 352 353 static constexpr const _Head& 354 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 355 356 constexpr _Tuple_impl() 357 : _Base() { } 358 359 explicit 360 constexpr _Tuple_impl(const _Head& __head) 361 : _Base(__head) { } 362 363 template<typename _UHead> 364 explicit 365 constexpr _Tuple_impl(_UHead&& __head) 366 : _Base(std::forward<_UHead>(__head)) { } 367 368 constexpr _Tuple_impl(const _Tuple_impl&) = default; 369 370 constexpr 371 _Tuple_impl(_Tuple_impl&& __in) 372 noexcept(is_nothrow_move_constructible<_Head>::value) 373 : _Base(std::forward<_Head>(_M_head(__in))) { } 374 375 template<typename _UHead> 376 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) 377 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } 378 379 template<typename _UHead> 380 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) 381 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) 382 { } 383 384 template<typename _Alloc> 385 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) 386 : _Base(__tag, __use_alloc<_Head>(__a)) { } 387 388 template<typename _Alloc> 389 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 390 const _Head& __head) 391 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } 392 393 template<typename _Alloc, typename _UHead> 394 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 395 _UHead&& __head) 396 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 397 std::forward<_UHead>(__head)) { } 398 399 template<typename _Alloc> 400 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 401 const _Tuple_impl& __in) 402 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } 403 404 template<typename _Alloc> 405 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 406 _Tuple_impl&& __in) 407 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 408 std::forward<_Head>(_M_head(__in))) { } 409 410 template<typename _Alloc, typename _UHead> 411 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 412 const _Tuple_impl<_Idx, _UHead>& __in) 413 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 414 _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } 415 416 template<typename _Alloc, typename _UHead> 417 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 418 _Tuple_impl<_Idx, _UHead>&& __in) 419 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 420 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) 421 { } 422 423 _Tuple_impl& 424 operator=(const _Tuple_impl& __in) 425 { 426 _M_head(*this) = _M_head(__in); 427 return *this; 428 } 429 430 _Tuple_impl& 431 operator=(_Tuple_impl&& __in) 432 noexcept(is_nothrow_move_assignable<_Head>::value) 433 { 434 _M_head(*this) = std::forward<_Head>(_M_head(__in)); 435 return *this; 436 } 437 438 template<typename _UHead> 439 _Tuple_impl& 440 operator=(const _Tuple_impl<_Idx, _UHead>& __in) 441 { 442 _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); 443 return *this; 444 } 445 446 template<typename _UHead> 447 _Tuple_impl& 448 operator=(_Tuple_impl<_Idx, _UHead>&& __in) 449 { 450 _M_head(*this) 451 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); 452 return *this; 453 } 454 455 protected: 456 void 457 _M_swap(_Tuple_impl& __in) 458 noexcept(__is_nothrow_swappable<_Head>::value) 459 { 460 using std::swap; 461 swap(_M_head(*this), _M_head(__in)); 462 } 463 }; 464 465 // Concept utility functions, reused in conditionally-explicit 466 // constructors. 467 template<bool, typename... _Elements> 468 struct _TC 469 { 470 template<typename... _UElements> 471 static constexpr bool _ConstructibleTuple() 472 { 473 return __and_<is_constructible<_Elements, const _UElements&>...>::value; 474 } 475 476 template<typename... _UElements> 477 static constexpr bool _ImplicitlyConvertibleTuple() 478 { 479 return __and_<is_convertible<const _UElements&, _Elements>...>::value; 480 } 481 482 template<typename... _UElements> 483 static constexpr bool _MoveConstructibleTuple() 484 { 485 return __and_<is_constructible<_Elements, _UElements&&>...>::value; 486 } 487 488 template<typename... _UElements> 489 static constexpr bool _ImplicitlyMoveConvertibleTuple() 490 { 491 return __and_<is_convertible<_UElements&&, _Elements>...>::value; 492 } 493 494 template<typename _SrcTuple> 495 static constexpr bool _NonNestedTuple() 496 { 497 return __and_<__not_<is_same<tuple<_Elements...>, 498 typename remove_cv< 499 typename remove_reference<_SrcTuple>::type 500 >::type>>, 501 __not_<is_convertible<_SrcTuple, _Elements...>>, 502 __not_<is_constructible<_Elements..., _SrcTuple>> 503 >::value; 504 } 505 template<typename... _UElements> 506 static constexpr bool _NotSameTuple() 507 { 508 return __not_<is_same<tuple<_Elements...>, 509 typename remove_const< 510 typename remove_reference<_UElements...>::type 511 >::type>>::value; 512 } 513 }; 514 515 template<typename... _Elements> 516 struct _TC<false, _Elements...> 517 { 518 template<typename... _UElements> 519 static constexpr bool _ConstructibleTuple() 520 { 521 return false; 522 } 523 524 template<typename... _UElements> 525 static constexpr bool _ImplicitlyConvertibleTuple() 526 { 527 return false; 528 } 529 530 template<typename... _UElements> 531 static constexpr bool _MoveConstructibleTuple() 532 { 533 return false; 534 } 535 536 template<typename... _UElements> 537 static constexpr bool _ImplicitlyMoveConvertibleTuple() 538 { 539 return false; 540 } 541 542 template<typename... _UElements> 543 static constexpr bool _NonNestedTuple() 544 { 545 return true; 546 } 547 template<typename... _UElements> 548 static constexpr bool _NotSameTuple() 549 { 550 return true; 551 } 552 }; 553 554 /// Primary class template, tuple 555 template<typename... _Elements> 556 class tuple : public _Tuple_impl<0, _Elements...> 557 { 558 typedef _Tuple_impl<0, _Elements...> _Inherited; 559 560 // Used for constraining the default constructor so 561 // that it becomes dependent on the constraints. 562 template<typename _Dummy> 563 struct _TC2 564 { 565 static constexpr bool _DefaultConstructibleTuple() 566 { 567 return __and_<is_default_constructible<_Elements>...>::value; 568 } 569 static constexpr bool _ImplicitlyDefaultConstructibleTuple() 570 { 571 return __and_<__is_implicitly_default_constructible<_Elements>...> 572 ::value; 573 } 574 }; 575 576 public: 577 template<typename _Dummy = void, 578 typename enable_if<_TC2<_Dummy>:: 579 _ImplicitlyDefaultConstructibleTuple(), 580 bool>::type = true> 581 constexpr tuple() 582 : _Inherited() { } 583 584 template<typename _Dummy = void, 585 typename enable_if<_TC2<_Dummy>:: 586 _DefaultConstructibleTuple() 587 && 588 !_TC2<_Dummy>:: 589 _ImplicitlyDefaultConstructibleTuple(), 590 bool>::type = false> 591 explicit constexpr tuple() 592 : _Inherited() { } 593 594 // Shortcut for the cases where constructors taking _Elements... 595 // need to be constrained. 596 template<typename _Dummy> using _TCC = 597 _TC<is_same<_Dummy, void>::value, 598 _Elements...>; 599 600 template<typename _Dummy = void, 601 typename enable_if< 602 _TCC<_Dummy>::template 603 _ConstructibleTuple<_Elements...>() 604 && _TCC<_Dummy>::template 605 _ImplicitlyConvertibleTuple<_Elements...>() 606 && (sizeof...(_Elements) >= 1), 607 bool>::type=true> 608 constexpr tuple(const _Elements&... __elements) 609 : _Inherited(__elements...) { } 610 611 template<typename _Dummy = void, 612 typename enable_if< 613 _TCC<_Dummy>::template 614 _ConstructibleTuple<_Elements...>() 615 && !_TCC<_Dummy>::template 616 _ImplicitlyConvertibleTuple<_Elements...>() 617 && (sizeof...(_Elements) >= 1), 618 bool>::type=false> 619 explicit constexpr tuple(const _Elements&... __elements) 620 : _Inherited(__elements...) { } 621 622 // Shortcut for the cases where constructors taking _UElements... 623 // need to be constrained. 624 template<typename... _UElements> using _TMC = 625 _TC<(sizeof...(_Elements) == sizeof...(_UElements)) 626 && (_TC<(sizeof...(_UElements)==1), _Elements...>:: 627 template _NotSameTuple<_UElements...>()), 628 _Elements...>; 629 630 // Shortcut for the cases where constructors taking tuple<_UElements...> 631 // need to be constrained. 632 template<typename... _UElements> using _TMCT = 633 _TC<(sizeof...(_Elements) == sizeof...(_UElements)) 634 && !is_same<tuple<_Elements...>, 635 tuple<_UElements...>>::value, 636 _Elements...>; 637 638 template<typename... _UElements, typename 639 enable_if< 640 _TMC<_UElements...>::template 641 _MoveConstructibleTuple<_UElements...>() 642 && _TMC<_UElements...>::template 643 _ImplicitlyMoveConvertibleTuple<_UElements...>() 644 && (sizeof...(_Elements) >= 1), 645 bool>::type=true> 646 constexpr tuple(_UElements&&... __elements) 647 : _Inherited(std::forward<_UElements>(__elements)...) { } 648 649 template<typename... _UElements, typename 650 enable_if< 651 _TMC<_UElements...>::template 652 _MoveConstructibleTuple<_UElements...>() 653 && !_TMC<_UElements...>::template 654 _ImplicitlyMoveConvertibleTuple<_UElements...>() 655 && (sizeof...(_Elements) >= 1), 656 bool>::type=false> 657 explicit constexpr tuple(_UElements&&... __elements) 658 : _Inherited(std::forward<_UElements>(__elements)...) { } 659 660 constexpr tuple(const tuple&) = default; 661 662 constexpr tuple(tuple&&) = default; 663 664 // Shortcut for the cases where constructors taking tuples 665 // must avoid creating temporaries. 666 template<typename _Dummy> using _TNTC = 667 _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1, 668 _Elements...>; 669 670 template<typename... _UElements, typename _Dummy = void, typename 671 enable_if<_TMCT<_UElements...>::template 672 _ConstructibleTuple<_UElements...>() 673 && _TMCT<_UElements...>::template 674 _ImplicitlyConvertibleTuple<_UElements...>() 675 && _TNTC<_Dummy>::template 676 _NonNestedTuple<const tuple<_UElements...>&>(), 677 bool>::type=true> 678 constexpr tuple(const tuple<_UElements...>& __in) 679 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 680 { } 681 682 template<typename... _UElements, typename _Dummy = void, typename 683 enable_if<_TMCT<_UElements...>::template 684 _ConstructibleTuple<_UElements...>() 685 && !_TMCT<_UElements...>::template 686 _ImplicitlyConvertibleTuple<_UElements...>() 687 && _TNTC<_Dummy>::template 688 _NonNestedTuple<const tuple<_UElements...>&>(), 689 bool>::type=false> 690 explicit constexpr tuple(const tuple<_UElements...>& __in) 691 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 692 { } 693 694 template<typename... _UElements, typename _Dummy = void, typename 695 enable_if<_TMCT<_UElements...>::template 696 _MoveConstructibleTuple<_UElements...>() 697 && _TMCT<_UElements...>::template 698 _ImplicitlyMoveConvertibleTuple<_UElements...>() 699 && _TNTC<_Dummy>::template 700 _NonNestedTuple<tuple<_UElements...>&&>(), 701 bool>::type=true> 702 constexpr tuple(tuple<_UElements...>&& __in) 703 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } 704 705 template<typename... _UElements, typename _Dummy = void, typename 706 enable_if<_TMCT<_UElements...>::template 707 _MoveConstructibleTuple<_UElements...>() 708 && !_TMCT<_UElements...>::template 709 _ImplicitlyMoveConvertibleTuple<_UElements...>() 710 && _TNTC<_Dummy>::template 711 _NonNestedTuple<tuple<_UElements...>&&>(), 712 bool>::type=false> 713 explicit constexpr tuple(tuple<_UElements...>&& __in) 714 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } 715 716 // Allocator-extended constructors. 717 718 template<typename _Alloc> 719 tuple(allocator_arg_t __tag, const _Alloc& __a) 720 : _Inherited(__tag, __a) { } 721 722 template<typename _Alloc, typename _Dummy = void, 723 typename enable_if< 724 _TCC<_Dummy>::template 725 _ConstructibleTuple<_Elements...>() 726 && _TCC<_Dummy>::template 727 _ImplicitlyConvertibleTuple<_Elements...>(), 728 bool>::type=true> 729 tuple(allocator_arg_t __tag, const _Alloc& __a, 730 const _Elements&... __elements) 731 : _Inherited(__tag, __a, __elements...) { } 732 733 template<typename _Alloc, typename _Dummy = void, 734 typename enable_if< 735 _TCC<_Dummy>::template 736 _ConstructibleTuple<_Elements...>() 737 && !_TCC<_Dummy>::template 738 _ImplicitlyConvertibleTuple<_Elements...>(), 739 bool>::type=false> 740 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 741 const _Elements&... __elements) 742 : _Inherited(__tag, __a, __elements...) { } 743 744 template<typename _Alloc, typename... _UElements, typename 745 enable_if<_TMC<_UElements...>::template 746 _MoveConstructibleTuple<_UElements...>() 747 && _TMC<_UElements...>::template 748 _ImplicitlyMoveConvertibleTuple<_UElements...>(), 749 bool>::type=true> 750 tuple(allocator_arg_t __tag, const _Alloc& __a, 751 _UElements&&... __elements) 752 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) 753 { } 754 755 template<typename _Alloc, typename... _UElements, typename 756 enable_if<_TMC<_UElements...>::template 757 _MoveConstructibleTuple<_UElements...>() 758 && !_TMC<_UElements...>::template 759 _ImplicitlyMoveConvertibleTuple<_UElements...>(), 760 bool>::type=false> 761 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 762 _UElements&&... __elements) 763 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) 764 { } 765 766 template<typename _Alloc> 767 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 768 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 769 770 template<typename _Alloc> 771 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 772 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 773 774 template<typename _Alloc, typename _Dummy = void, 775 typename... _UElements, typename 776 enable_if<_TMCT<_UElements...>::template 777 _ConstructibleTuple<_UElements...>() 778 && _TMCT<_UElements...>::template 779 _ImplicitlyConvertibleTuple<_UElements...>() 780 && _TNTC<_Dummy>::template 781 _NonNestedTuple<tuple<_UElements...>&&>(), 782 bool>::type=true> 783 tuple(allocator_arg_t __tag, const _Alloc& __a, 784 const tuple<_UElements...>& __in) 785 : _Inherited(__tag, __a, 786 static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 787 { } 788 789 template<typename _Alloc, typename _Dummy = void, 790 typename... _UElements, typename 791 enable_if<_TMCT<_UElements...>::template 792 _ConstructibleTuple<_UElements...>() 793 && !_TMCT<_UElements...>::template 794 _ImplicitlyConvertibleTuple<_UElements...>() 795 && _TNTC<_Dummy>::template 796 _NonNestedTuple<tuple<_UElements...>&&>(), 797 bool>::type=false> 798 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 799 const tuple<_UElements...>& __in) 800 : _Inherited(__tag, __a, 801 static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 802 { } 803 804 template<typename _Alloc, typename _Dummy = void, 805 typename... _UElements, typename 806 enable_if<_TMCT<_UElements...>::template 807 _MoveConstructibleTuple<_UElements...>() 808 && _TMCT<_UElements...>::template 809 _ImplicitlyMoveConvertibleTuple<_UElements...>() 810 && _TNTC<_Dummy>::template 811 _NonNestedTuple<tuple<_UElements...>&&>(), 812 bool>::type=true> 813 tuple(allocator_arg_t __tag, const _Alloc& __a, 814 tuple<_UElements...>&& __in) 815 : _Inherited(__tag, __a, 816 static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) 817 { } 818 819 template<typename _Alloc, typename _Dummy = void, 820 typename... _UElements, typename 821 enable_if<_TMCT<_UElements...>::template 822 _MoveConstructibleTuple<_UElements...>() 823 && !_TMCT<_UElements...>::template 824 _ImplicitlyMoveConvertibleTuple<_UElements...>() 825 && _TNTC<_Dummy>::template 826 _NonNestedTuple<tuple<_UElements...>&&>(), 827 bool>::type=false> 828 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 829 tuple<_UElements...>&& __in) 830 : _Inherited(__tag, __a, 831 static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) 832 { } 833 834 tuple& 835 operator=(const tuple& __in) 836 { 837 static_cast<_Inherited&>(*this) = __in; 838 return *this; 839 } 840 841 tuple& 842 operator=(tuple&& __in) 843 noexcept(is_nothrow_move_assignable<_Inherited>::value) 844 { 845 static_cast<_Inherited&>(*this) = std::move(__in); 846 return *this; 847 } 848 849 template<typename... _UElements> 850 typename 851 enable_if<sizeof...(_UElements) 852 == sizeof...(_Elements), tuple&>::type 853 operator=(const tuple<_UElements...>& __in) 854 { 855 static_cast<_Inherited&>(*this) = __in; 856 return *this; 857 } 858 859 template<typename... _UElements> 860 typename 861 enable_if<sizeof...(_UElements) 862 == sizeof...(_Elements), tuple&>::type 863 operator=(tuple<_UElements...>&& __in) 864 { 865 static_cast<_Inherited&>(*this) = std::move(__in); 866 return *this; 867 } 868 869 void 870 swap(tuple& __in) 871 noexcept(noexcept(__in._M_swap(__in))) 872 { _Inherited::_M_swap(__in); } 873 }; 874 875#if __cpp_deduction_guides >= 201606 876 template<typename... _UTypes> 877 tuple(_UTypes...) -> tuple<_UTypes...>; 878 template<typename _T1, typename _T2> 879 tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; 880 template<typename _Alloc, typename... _UTypes> 881 tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; 882 template<typename _Alloc, typename _T1, typename _T2> 883 tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; 884 template<typename _Alloc, typename... _UTypes> 885 tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; 886#endif 887 888 // Explicit specialization, zero-element tuple. 889 template<> 890 class tuple<> 891 { 892 public: 893 void swap(tuple&) noexcept { /* no-op */ } 894 // We need the default since we're going to define no-op 895 // allocator constructors. 896 tuple() = default; 897 // No-op allocator constructors. 898 template<typename _Alloc> 899 tuple(allocator_arg_t, const _Alloc&) { } 900 template<typename _Alloc> 901 tuple(allocator_arg_t, const _Alloc&, const tuple&) { } 902 }; 903 904 /// Partial specialization, 2-element tuple. 905 /// Includes construction and assignment from a pair. 906 template<typename _T1, typename _T2> 907 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> 908 { 909 typedef _Tuple_impl<0, _T1, _T2> _Inherited; 910 911 public: 912 template <typename _U1 = _T1, 913 typename _U2 = _T2, 914 typename enable_if<__and_< 915 __is_implicitly_default_constructible<_U1>, 916 __is_implicitly_default_constructible<_U2>> 917 ::value, bool>::type = true> 918 919 constexpr tuple() 920 : _Inherited() { } 921 922 template <typename _U1 = _T1, 923 typename _U2 = _T2, 924 typename enable_if< 925 __and_< 926 is_default_constructible<_U1>, 927 is_default_constructible<_U2>, 928 __not_< 929 __and_<__is_implicitly_default_constructible<_U1>, 930 __is_implicitly_default_constructible<_U2>>>> 931 ::value, bool>::type = false> 932 933 explicit constexpr tuple() 934 : _Inherited() { } 935 936 // Shortcut for the cases where constructors taking _T1, _T2 937 // need to be constrained. 938 template<typename _Dummy> using _TCC = 939 _TC<is_same<_Dummy, void>::value, _T1, _T2>; 940 941 template<typename _Dummy = void, typename 942 enable_if<_TCC<_Dummy>::template 943 _ConstructibleTuple<_T1, _T2>() 944 && _TCC<_Dummy>::template 945 _ImplicitlyConvertibleTuple<_T1, _T2>(), 946 bool>::type = true> 947 constexpr tuple(const _T1& __a1, const _T2& __a2) 948 : _Inherited(__a1, __a2) { } 949 950 template<typename _Dummy = void, typename 951 enable_if<_TCC<_Dummy>::template 952 _ConstructibleTuple<_T1, _T2>() 953 && !_TCC<_Dummy>::template 954 _ImplicitlyConvertibleTuple<_T1, _T2>(), 955 bool>::type = false> 956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2) 957 : _Inherited(__a1, __a2) { } 958 959 // Shortcut for the cases where constructors taking _U1, _U2 960 // need to be constrained. 961 using _TMC = _TC<true, _T1, _T2>; 962 963 template<typename _U1, typename _U2, typename 964 enable_if<_TMC::template 965 _MoveConstructibleTuple<_U1, _U2>() 966 && _TMC::template 967 _ImplicitlyMoveConvertibleTuple<_U1, _U2>() 968 && !is_same<typename decay<_U1>::type, 969 allocator_arg_t>::value, 970 bool>::type = true> 971 constexpr tuple(_U1&& __a1, _U2&& __a2) 972 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } 973 974 template<typename _U1, typename _U2, typename 975 enable_if<_TMC::template 976 _MoveConstructibleTuple<_U1, _U2>() 977 && !_TMC::template 978 _ImplicitlyMoveConvertibleTuple<_U1, _U2>() 979 && !is_same<typename decay<_U1>::type, 980 allocator_arg_t>::value, 981 bool>::type = false> 982 explicit constexpr tuple(_U1&& __a1, _U2&& __a2) 983 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } 984 985 constexpr tuple(const tuple&) = default; 986 987 constexpr tuple(tuple&&) = default; 988 989 template<typename _U1, typename _U2, typename 990 enable_if<_TMC::template 991 _ConstructibleTuple<_U1, _U2>() 992 && _TMC::template 993 _ImplicitlyConvertibleTuple<_U1, _U2>(), 994 bool>::type = true> 995 constexpr tuple(const tuple<_U1, _U2>& __in) 996 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } 997 998 template<typename _U1, typename _U2, typename 999 enable_if<_TMC::template 1000 _ConstructibleTuple<_U1, _U2>() 1001 && !_TMC::template 1002 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1003 bool>::type = false> 1004 explicit constexpr tuple(const tuple<_U1, _U2>& __in) 1005 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } 1006 1007 template<typename _U1, typename _U2, typename 1008 enable_if<_TMC::template 1009 _MoveConstructibleTuple<_U1, _U2>() 1010 && _TMC::template 1011 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1012 bool>::type = true> 1013 constexpr tuple(tuple<_U1, _U2>&& __in) 1014 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } 1015 1016 template<typename _U1, typename _U2, typename 1017 enable_if<_TMC::template 1018 _MoveConstructibleTuple<_U1, _U2>() 1019 && !_TMC::template 1020 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1021 bool>::type = false> 1022 explicit constexpr tuple(tuple<_U1, _U2>&& __in) 1023 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } 1024 1025 template<typename _U1, typename _U2, typename 1026 enable_if<_TMC::template 1027 _ConstructibleTuple<_U1, _U2>() 1028 && _TMC::template 1029 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1030 bool>::type = true> 1031 constexpr tuple(const pair<_U1, _U2>& __in) 1032 : _Inherited(__in.first, __in.second) { } 1033 1034 template<typename _U1, typename _U2, typename 1035 enable_if<_TMC::template 1036 _ConstructibleTuple<_U1, _U2>() 1037 && !_TMC::template 1038 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1039 bool>::type = false> 1040 explicit constexpr tuple(const pair<_U1, _U2>& __in) 1041 : _Inherited(__in.first, __in.second) { } 1042 1043 template<typename _U1, typename _U2, typename 1044 enable_if<_TMC::template 1045 _MoveConstructibleTuple<_U1, _U2>() 1046 && _TMC::template 1047 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1048 bool>::type = true> 1049 constexpr tuple(pair<_U1, _U2>&& __in) 1050 : _Inherited(std::forward<_U1>(__in.first), 1051 std::forward<_U2>(__in.second)) { } 1052 1053 template<typename _U1, typename _U2, typename 1054 enable_if<_TMC::template 1055 _MoveConstructibleTuple<_U1, _U2>() 1056 && !_TMC::template 1057 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1058 bool>::type = false> 1059 explicit constexpr tuple(pair<_U1, _U2>&& __in) 1060 : _Inherited(std::forward<_U1>(__in.first), 1061 std::forward<_U2>(__in.second)) { } 1062 1063 // Allocator-extended constructors. 1064 1065 template<typename _Alloc> 1066 tuple(allocator_arg_t __tag, const _Alloc& __a) 1067 : _Inherited(__tag, __a) { } 1068 1069 template<typename _Alloc, typename _Dummy = void, 1070 typename enable_if< 1071 _TCC<_Dummy>::template 1072 _ConstructibleTuple<_T1, _T2>() 1073 && _TCC<_Dummy>::template 1074 _ImplicitlyConvertibleTuple<_T1, _T2>(), 1075 bool>::type=true> 1076 1077 tuple(allocator_arg_t __tag, const _Alloc& __a, 1078 const _T1& __a1, const _T2& __a2) 1079 : _Inherited(__tag, __a, __a1, __a2) { } 1080 1081 template<typename _Alloc, typename _Dummy = void, 1082 typename enable_if< 1083 _TCC<_Dummy>::template 1084 _ConstructibleTuple<_T1, _T2>() 1085 && !_TCC<_Dummy>::template 1086 _ImplicitlyConvertibleTuple<_T1, _T2>(), 1087 bool>::type=false> 1088 1089 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1090 const _T1& __a1, const _T2& __a2) 1091 : _Inherited(__tag, __a, __a1, __a2) { } 1092 1093 template<typename _Alloc, typename _U1, typename _U2, typename 1094 enable_if<_TMC::template 1095 _MoveConstructibleTuple<_U1, _U2>() 1096 && _TMC::template 1097 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1098 bool>::type = true> 1099 tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) 1100 : _Inherited(__tag, __a, std::forward<_U1>(__a1), 1101 std::forward<_U2>(__a2)) { } 1102 1103 template<typename _Alloc, typename _U1, typename _U2, typename 1104 enable_if<_TMC::template 1105 _MoveConstructibleTuple<_U1, _U2>() 1106 && !_TMC::template 1107 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1108 bool>::type = false> 1109 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1110 _U1&& __a1, _U2&& __a2) 1111 : _Inherited(__tag, __a, std::forward<_U1>(__a1), 1112 std::forward<_U2>(__a2)) { } 1113 1114 template<typename _Alloc> 1115 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 1116 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 1117 1118 template<typename _Alloc> 1119 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 1120 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 1121 1122 template<typename _Alloc, typename _U1, typename _U2, typename 1123 enable_if<_TMC::template 1124 _ConstructibleTuple<_U1, _U2>() 1125 && _TMC::template 1126 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1127 bool>::type = true> 1128 tuple(allocator_arg_t __tag, const _Alloc& __a, 1129 const tuple<_U1, _U2>& __in) 1130 : _Inherited(__tag, __a, 1131 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) 1132 { } 1133 1134 template<typename _Alloc, typename _U1, typename _U2, typename 1135 enable_if<_TMC::template 1136 _ConstructibleTuple<_U1, _U2>() 1137 && !_TMC::template 1138 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1139 bool>::type = false> 1140 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1141 const tuple<_U1, _U2>& __in) 1142 : _Inherited(__tag, __a, 1143 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) 1144 { } 1145 1146 template<typename _Alloc, typename _U1, typename _U2, typename 1147 enable_if<_TMC::template 1148 _MoveConstructibleTuple<_U1, _U2>() 1149 && _TMC::template 1150 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1151 bool>::type = true> 1152 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) 1153 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) 1154 { } 1155 1156 template<typename _Alloc, typename _U1, typename _U2, typename 1157 enable_if<_TMC::template 1158 _MoveConstructibleTuple<_U1, _U2>() 1159 && !_TMC::template 1160 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1161 bool>::type = false> 1162 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1163 tuple<_U1, _U2>&& __in) 1164 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) 1165 { } 1166 1167 template<typename _Alloc, typename _U1, typename _U2, typename 1168 enable_if<_TMC::template 1169 _ConstructibleTuple<_U1, _U2>() 1170 && _TMC::template 1171 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1172 bool>::type = true> 1173 tuple(allocator_arg_t __tag, const _Alloc& __a, 1174 const pair<_U1, _U2>& __in) 1175 : _Inherited(__tag, __a, __in.first, __in.second) { } 1176 1177 template<typename _Alloc, typename _U1, typename _U2, typename 1178 enable_if<_TMC::template 1179 _ConstructibleTuple<_U1, _U2>() 1180 && !_TMC::template 1181 _ImplicitlyConvertibleTuple<_U1, _U2>(), 1182 bool>::type = false> 1183 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1184 const pair<_U1, _U2>& __in) 1185 : _Inherited(__tag, __a, __in.first, __in.second) { } 1186 1187 template<typename _Alloc, typename _U1, typename _U2, typename 1188 enable_if<_TMC::template 1189 _MoveConstructibleTuple<_U1, _U2>() 1190 && _TMC::template 1191 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1192 bool>::type = true> 1193 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) 1194 : _Inherited(__tag, __a, std::forward<_U1>(__in.first), 1195 std::forward<_U2>(__in.second)) { } 1196 1197 template<typename _Alloc, typename _U1, typename _U2, typename 1198 enable_if<_TMC::template 1199 _MoveConstructibleTuple<_U1, _U2>() 1200 && !_TMC::template 1201 _ImplicitlyMoveConvertibleTuple<_U1, _U2>(), 1202 bool>::type = false> 1203 explicit tuple(allocator_arg_t __tag, const _Alloc& __a, 1204 pair<_U1, _U2>&& __in) 1205 : _Inherited(__tag, __a, std::forward<_U1>(__in.first), 1206 std::forward<_U2>(__in.second)) { } 1207 1208 tuple& 1209 operator=(const tuple& __in) 1210 { 1211 static_cast<_Inherited&>(*this) = __in; 1212 return *this; 1213 } 1214 1215 tuple& 1216 operator=(tuple&& __in) 1217 noexcept(is_nothrow_move_assignable<_Inherited>::value) 1218 { 1219 static_cast<_Inherited&>(*this) = std::move(__in); 1220 return *this; 1221 } 1222 1223 template<typename _U1, typename _U2> 1224 tuple& 1225 operator=(const tuple<_U1, _U2>& __in) 1226 { 1227 static_cast<_Inherited&>(*this) = __in; 1228 return *this; 1229 } 1230 1231 template<typename _U1, typename _U2> 1232 tuple& 1233 operator=(tuple<_U1, _U2>&& __in) 1234 { 1235 static_cast<_Inherited&>(*this) = std::move(__in); 1236 return *this; 1237 } 1238 1239 template<typename _U1, typename _U2> 1240 tuple& 1241 operator=(const pair<_U1, _U2>& __in) 1242 { 1243 this->_M_head(*this) = __in.first; 1244 this->_M_tail(*this)._M_head(*this) = __in.second; 1245 return *this; 1246 } 1247 1248 template<typename _U1, typename _U2> 1249 tuple& 1250 operator=(pair<_U1, _U2>&& __in) 1251 { 1252 this->_M_head(*this) = std::forward<_U1>(__in.first); 1253 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); 1254 return *this; 1255 } 1256 1257 void 1258 swap(tuple& __in) 1259 noexcept(noexcept(__in._M_swap(__in))) 1260 { _Inherited::_M_swap(__in); } 1261 }; 1262 1263 1264 /// class tuple_size 1265 template<typename... _Elements> 1266 struct tuple_size<tuple<_Elements...>> 1267 : public integral_constant<std::size_t, sizeof...(_Elements)> { }; 1268 1269#if __cplusplus > 201402L 1270 template <typename _Tp> 1271 inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; 1272#endif 1273 1274 /** 1275 * Recursive case for tuple_element: strip off the first element in 1276 * the tuple and retrieve the (i-1)th element of the remaining tuple. 1277 */ 1278 template<std::size_t __i, typename _Head, typename... _Tail> 1279 struct tuple_element<__i, tuple<_Head, _Tail...> > 1280 : tuple_element<__i - 1, tuple<_Tail...> > { }; 1281 1282 /** 1283 * Basis case for tuple_element: The first element is the one we're seeking. 1284 */ 1285 template<typename _Head, typename... _Tail> 1286 struct tuple_element<0, tuple<_Head, _Tail...> > 1287 { 1288 typedef _Head type; 1289 }; 1290 1291 /** 1292 * Error case for tuple_element: invalid index. 1293 */ 1294 template<size_t __i> 1295 struct tuple_element<__i, tuple<>> 1296 { 1297 static_assert(__i < tuple_size<tuple<>>::value, 1298 "tuple index is in range"); 1299 }; 1300 1301 template<std::size_t __i, typename _Head, typename... _Tail> 1302 constexpr _Head& 1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1304 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1305 1306 template<std::size_t __i, typename _Head, typename... _Tail> 1307 constexpr const _Head& 1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1309 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1310 1311 /// Return a reference to the ith element of a tuple. 1312 template<std::size_t __i, typename... _Elements> 1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>& 1314 get(tuple<_Elements...>& __t) noexcept 1315 { return std::__get_helper<__i>(__t); } 1316 1317 /// Return a const reference to the ith element of a const tuple. 1318 template<std::size_t __i, typename... _Elements> 1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>& 1320 get(const tuple<_Elements...>& __t) noexcept 1321 { return std::__get_helper<__i>(__t); } 1322 1323 /// Return an rvalue reference to the ith element of a tuple rvalue. 1324 template<std::size_t __i, typename... _Elements> 1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&& 1326 get(tuple<_Elements...>&& __t) noexcept 1327 { 1328 typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; 1329 return std::forward<__element_type&&>(std::get<__i>(__t)); 1330 } 1331 1332#if __cplusplus > 201103L 1333 1334#define __cpp_lib_tuples_by_type 201304 1335 1336 template<typename _Head, size_t __i, typename... _Tail> 1337 constexpr _Head& 1338 __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1339 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1340 1341 template<typename _Head, size_t __i, typename... _Tail> 1342 constexpr const _Head& 1343 __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 1344 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 1345 1346 /// Return a reference to the unique element of type _Tp of a tuple. 1347 template <typename _Tp, typename... _Types> 1348 constexpr _Tp& 1349 get(tuple<_Types...>& __t) noexcept 1350 { return std::__get_helper2<_Tp>(__t); } 1351 1352 /// Return a reference to the unique element of type _Tp of a tuple rvalue. 1353 template <typename _Tp, typename... _Types> 1354 constexpr _Tp&& 1355 get(tuple<_Types...>&& __t) noexcept 1356 { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); } 1357 1358 /// Return a const reference to the unique element of type _Tp of a tuple. 1359 template <typename _Tp, typename... _Types> 1360 constexpr const _Tp& 1361 get(const tuple<_Types...>& __t) noexcept 1362 { return std::__get_helper2<_Tp>(__t); } 1363#endif 1364 1365 // This class performs the comparison operations on tuples 1366 template<typename _Tp, typename _Up, size_t __i, size_t __size> 1367 struct __tuple_compare 1368 { 1369 static constexpr bool 1370 __eq(const _Tp& __t, const _Up& __u) 1371 { 1372 return bool(std::get<__i>(__t) == std::get<__i>(__u)) 1373 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); 1374 } 1375 1376 static constexpr bool 1377 __less(const _Tp& __t, const _Up& __u) 1378 { 1379 return bool(std::get<__i>(__t) < std::get<__i>(__u)) 1380 || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) 1381 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); 1382 } 1383 }; 1384 1385 template<typename _Tp, typename _Up, size_t __size> 1386 struct __tuple_compare<_Tp, _Up, __size, __size> 1387 { 1388 static constexpr bool 1389 __eq(const _Tp&, const _Up&) { return true; } 1390 1391 static constexpr bool 1392 __less(const _Tp&, const _Up&) { return false; } 1393 }; 1394 1395 template<typename... _TElements, typename... _UElements> 1396 constexpr bool 1397 operator==(const tuple<_TElements...>& __t, 1398 const tuple<_UElements...>& __u) 1399 { 1400 static_assert(sizeof...(_TElements) == sizeof...(_UElements), 1401 "tuple objects can only be compared if they have equal sizes."); 1402 using __compare = __tuple_compare<tuple<_TElements...>, 1403 tuple<_UElements...>, 1404 0, sizeof...(_TElements)>; 1405 return __compare::__eq(__t, __u); 1406 } 1407 1408 template<typename... _TElements, typename... _UElements> 1409 constexpr bool 1410 operator<(const tuple<_TElements...>& __t, 1411 const tuple<_UElements...>& __u) 1412 { 1413 static_assert(sizeof...(_TElements) == sizeof...(_UElements), 1414 "tuple objects can only be compared if they have equal sizes."); 1415 using __compare = __tuple_compare<tuple<_TElements...>, 1416 tuple<_UElements...>, 1417 0, sizeof...(_TElements)>; 1418 return __compare::__less(__t, __u); 1419 } 1420 1421 template<typename... _TElements, typename... _UElements> 1422 constexpr bool 1423 operator!=(const tuple<_TElements...>& __t, 1424 const tuple<_UElements...>& __u) 1425 { return !(__t == __u); } 1426 1427 template<typename... _TElements, typename... _UElements> 1428 constexpr bool 1429 operator>(const tuple<_TElements...>& __t, 1430 const tuple<_UElements...>& __u) 1431 { return __u < __t; } 1432 1433 template<typename... _TElements, typename... _UElements> 1434 constexpr bool 1435 operator<=(const tuple<_TElements...>& __t, 1436 const tuple<_UElements...>& __u) 1437 { return !(__u < __t); } 1438 1439 template<typename... _TElements, typename... _UElements> 1440 constexpr bool 1441 operator>=(const tuple<_TElements...>& __t, 1442 const tuple<_UElements...>& __u) 1443 { return !(__t < __u); } 1444 1445 // NB: DR 705. 1446 template<typename... _Elements> 1447 constexpr tuple<typename __decay_and_strip<_Elements>::__type...> 1448 make_tuple(_Elements&&... __args) 1449 { 1450 typedef tuple<typename __decay_and_strip<_Elements>::__type...> 1451 __result_type; 1452 return __result_type(std::forward<_Elements>(__args)...); 1453 } 1454 1455 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1456 // 2275. Why is forward_as_tuple not constexpr? 1457 template<typename... _Elements> 1458 constexpr tuple<_Elements&&...> 1459 forward_as_tuple(_Elements&&... __args) noexcept 1460 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } 1461 1462 template<size_t, typename, typename, size_t> 1463 struct __make_tuple_impl; 1464 1465 template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm> 1466 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> 1467 : __make_tuple_impl<_Idx + 1, 1468 tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, 1469 _Tuple, _Nm> 1470 { }; 1471 1472 template<std::size_t _Nm, typename _Tuple, typename... _Tp> 1473 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> 1474 { 1475 typedef tuple<_Tp...> __type; 1476 }; 1477 1478 template<typename _Tuple> 1479 struct __do_make_tuple 1480 : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value> 1481 { }; 1482 1483 // Returns the std::tuple equivalent of a tuple-like type. 1484 template<typename _Tuple> 1485 struct __make_tuple 1486 : public __do_make_tuple<typename std::remove_cv 1487 <typename std::remove_reference<_Tuple>::type>::type> 1488 { }; 1489 1490 // Combines several std::tuple's into a single one. 1491 template<typename...> 1492 struct __combine_tuples; 1493 1494 template<> 1495 struct __combine_tuples<> 1496 { 1497 typedef tuple<> __type; 1498 }; 1499 1500 template<typename... _Ts> 1501 struct __combine_tuples<tuple<_Ts...>> 1502 { 1503 typedef tuple<_Ts...> __type; 1504 }; 1505 1506 template<typename... _T1s, typename... _T2s, typename... _Rem> 1507 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> 1508 { 1509 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, 1510 _Rem...>::__type __type; 1511 }; 1512 1513 // Computes the result type of tuple_cat given a set of tuple-like types. 1514 template<typename... _Tpls> 1515 struct __tuple_cat_result 1516 { 1517 typedef typename __combine_tuples 1518 <typename __make_tuple<_Tpls>::__type...>::__type __type; 1519 }; 1520 1521 // Helper to determine the index set for the first tuple-like 1522 // type of a given set. 1523 template<typename...> 1524 struct __make_1st_indices; 1525 1526 template<> 1527 struct __make_1st_indices<> 1528 { 1529 typedef std::_Index_tuple<> __type; 1530 }; 1531 1532 template<typename _Tp, typename... _Tpls> 1533 struct __make_1st_indices<_Tp, _Tpls...> 1534 { 1535 typedef typename std::_Build_index_tuple<std::tuple_size< 1536 typename std::remove_reference<_Tp>::type>::value>::__type __type; 1537 }; 1538 1539 // Performs the actual concatenation by step-wise expanding tuple-like 1540 // objects into the elements, which are finally forwarded into the 1541 // result tuple. 1542 template<typename _Ret, typename _Indices, typename... _Tpls> 1543 struct __tuple_concater; 1544 1545 template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls> 1546 struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> 1547 { 1548 template<typename... _Us> 1549 static constexpr _Ret 1550 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) 1551 { 1552 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1553 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; 1554 return __next::_S_do(std::forward<_Tpls>(__tps)..., 1555 std::forward<_Us>(__us)..., 1556 std::get<_Is>(std::forward<_Tp>(__tp))...); 1557 } 1558 }; 1559 1560 template<typename _Ret> 1561 struct __tuple_concater<_Ret, std::_Index_tuple<>> 1562 { 1563 template<typename... _Us> 1564 static constexpr _Ret 1565 _S_do(_Us&&... __us) 1566 { 1567 return _Ret(std::forward<_Us>(__us)...); 1568 } 1569 }; 1570 1571 /// tuple_cat 1572 template<typename... _Tpls, typename = typename 1573 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type> 1574 constexpr auto 1575 tuple_cat(_Tpls&&... __tpls) 1576 -> typename __tuple_cat_result<_Tpls...>::__type 1577 { 1578 typedef typename __tuple_cat_result<_Tpls...>::__type __ret; 1579 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1580 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; 1581 return __concater::_S_do(std::forward<_Tpls>(__tpls)...); 1582 } 1583 1584 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1585 // 2301. Why is tie not constexpr? 1586 /// tie 1587 template<typename... _Elements> 1588 constexpr tuple<_Elements&...> 1589 tie(_Elements&... __args) noexcept 1590 { return tuple<_Elements&...>(__args...); } 1591 1592 /// swap 1593 template<typename... _Elements> 1594 inline 1595#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 1596 // Constrained free swap overload, see p0185r1 1597 typename enable_if<__and_<__is_swappable<_Elements>...>::value 1598 >::type 1599#else 1600 void 1601#endif 1602 swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) 1603 noexcept(noexcept(__x.swap(__y))) 1604 { __x.swap(__y); } 1605 1606#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 1607 template<typename... _Elements> 1608 typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type 1609 swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; 1610#endif 1611 1612 // A class (and instance) which can be used in 'tie' when an element 1613 // of a tuple is not required. 1614 // _GLIBCXX14_CONSTEXPR 1615 // 2933. PR for LWG 2773 could be clearer 1616 struct _Swallow_assign 1617 { 1618 template<class _Tp> 1619 _GLIBCXX14_CONSTEXPR const _Swallow_assign& 1620 operator=(const _Tp&) const 1621 { return *this; } 1622 }; 1623 1624 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1625 // 2773. Making std::ignore constexpr 1626 _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{}; 1627 1628 /// Partial specialization for tuples 1629 template<typename... _Types, typename _Alloc> 1630 struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { }; 1631 1632 // See stl_pair.h... 1633 template<class _T1, class _T2> 1634 template<typename... _Args1, typename... _Args2> 1635 inline 1636 pair<_T1, _T2>:: 1637 pair(piecewise_construct_t, 1638 tuple<_Args1...> __first, tuple<_Args2...> __second) 1639 : pair(__first, __second, 1640 typename _Build_index_tuple<sizeof...(_Args1)>::__type(), 1641 typename _Build_index_tuple<sizeof...(_Args2)>::__type()) 1642 { } 1643 1644 template<class _T1, class _T2> 1645 template<typename... _Args1, std::size_t... _Indexes1, 1646 typename... _Args2, std::size_t... _Indexes2> 1647 inline 1648 pair<_T1, _T2>:: 1649 pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, 1650 _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) 1651 : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), 1652 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) 1653 { } 1654 1655#if __cplusplus > 201402L 1656# define __cpp_lib_apply 201603 1657 1658 template <typename _Fn, typename _Tuple, size_t... _Idx> 1659 constexpr decltype(auto) 1660 __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) 1661 { 1662 return std::__invoke(std::forward<_Fn>(__f), 1663 std::get<_Idx>(std::forward<_Tuple>(__t))...); 1664 } 1665 1666 template <typename _Fn, typename _Tuple> 1667 constexpr decltype(auto) 1668 apply(_Fn&& __f, _Tuple&& __t) 1669 { 1670 using _Indices = make_index_sequence<tuple_size_v<decay_t<_Tuple>>>; 1671 return std::__apply_impl(std::forward<_Fn>(__f), 1672 std::forward<_Tuple>(__t), 1673 _Indices{}); 1674 } 1675 1676#define __cpp_lib_make_from_tuple 201606 1677 1678 template <typename _Tp, typename _Tuple, size_t... _Idx> 1679 constexpr _Tp 1680 __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) 1681 { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } 1682 1683 template <typename _Tp, typename _Tuple> 1684 constexpr _Tp 1685 make_from_tuple(_Tuple&& __t) 1686 { 1687 return __make_from_tuple_impl<_Tp>( 1688 std::forward<_Tuple>(__t), 1689 make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{}); 1690 } 1691#endif // C++17 1692 1693 /// @} 1694 1695_GLIBCXX_END_NAMESPACE_VERSION 1696} // namespace std 1697 1698#endif // C++11 1699 1700#endif // _GLIBCXX_TUPLE 1701