1 // <tuple> -*- C++ -*- 2 3 // Copyright (C) 2007, 2008, 2009, 2010, 2011 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 #ifndef __GXX_EXPERIMENTAL_CXX0X__ 35 # include <bits/c++0x_warning.h> 36 #else 37 38 #include <utility> 39 #include <bits/uses_allocator.h> 40 41 namespace std _GLIBCXX_VISIBILITY(default) 42 { 43 _GLIBCXX_BEGIN_NAMESPACE_VERSION 44 45 // Adds a const reference to a non-reference type. 46 template<typename _Tp> 47 struct __add_c_ref 48 { typedef const _Tp& type; }; 49 50 template<typename _Tp> 51 struct __add_c_ref<_Tp&> 52 { typedef _Tp& type; }; 53 54 // Adds a reference to a non-reference type. 55 template<typename _Tp> 56 struct __add_ref 57 { typedef _Tp& type; }; 58 59 template<typename _Tp> 60 struct __add_ref<_Tp&> 61 { typedef _Tp& type; }; 62 63 // Adds an rvalue reference to a non-reference type. 64 template<typename _Tp> 65 struct __add_r_ref 66 { typedef _Tp&& type; }; 67 68 template<typename _Tp> 69 struct __add_r_ref<_Tp&> 70 { typedef _Tp& type; }; 71 72 template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal> 73 struct _Head_base; 74 75 template<std::size_t _Idx, typename _Head> 76 struct _Head_base<_Idx, _Head, true> 77 : public _Head 78 { 79 constexpr _Head_base() 80 : _Head() { } 81 82 constexpr _Head_base(const _Head& __h) 83 : _Head(__h) { } 84 85 template<typename _UHead, typename = typename 86 enable_if<!is_convertible<_UHead, 87 __uses_alloc_base>::value>::type> 88 constexpr _Head_base(_UHead&& __h) 89 : _Head(std::forward<_UHead>(__h)) { } 90 91 _Head_base(__uses_alloc0) 92 : _Head() { } 93 94 template<typename _Alloc> 95 _Head_base(__uses_alloc1<_Alloc> __a) 96 : _Head(allocator_arg, *__a._M_a) { } 97 98 template<typename _Alloc> 99 _Head_base(__uses_alloc2<_Alloc> __a) 100 : _Head(*__a._M_a) { } 101 102 template<typename _UHead> 103 _Head_base(__uses_alloc0, _UHead&& __uhead) 104 : _Head(std::forward<_UHead>(__uhead)) { } 105 106 template<typename _Alloc, typename _UHead> 107 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 108 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } 109 110 template<typename _Alloc, typename _UHead> 111 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 112 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } 113 114 static constexpr _Head& 115 _M_head(_Head_base& __b) noexcept { return __b; } 116 117 static constexpr const _Head& 118 _M_head(const _Head_base& __b) noexcept { return __b; } 119 }; 120 121 template<std::size_t _Idx, typename _Head> 122 struct _Head_base<_Idx, _Head, false> 123 { 124 constexpr _Head_base() 125 : _M_head_impl() { } 126 127 constexpr _Head_base(const _Head& __h) 128 : _M_head_impl(__h) { } 129 130 template<typename _UHead, typename = typename 131 enable_if<!is_convertible<_UHead, 132 __uses_alloc_base>::value>::type> 133 constexpr _Head_base(_UHead&& __h) 134 : _M_head_impl(std::forward<_UHead>(__h)) { } 135 136 _Head_base(__uses_alloc0) 137 : _M_head_impl() { } 138 139 template<typename _Alloc> 140 _Head_base(__uses_alloc1<_Alloc> __a) 141 : _M_head_impl(allocator_arg, *__a._M_a) { } 142 143 template<typename _Alloc> 144 _Head_base(__uses_alloc2<_Alloc> __a) 145 : _M_head_impl(*__a._M_a) { } 146 147 template<typename _UHead> 148 _Head_base(__uses_alloc0, _UHead&& __uhead) 149 : _M_head_impl(std::forward<_UHead>(__uhead)) { } 150 151 template<typename _Alloc, typename _UHead> 152 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) 153 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) 154 { } 155 156 template<typename _Alloc, typename _UHead> 157 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) 158 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } 159 160 static constexpr _Head& 161 _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } 162 163 static constexpr const _Head& 164 _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } 165 166 _Head _M_head_impl; 167 }; 168 169 /** 170 * Contains the actual implementation of the @c tuple template, stored 171 * as a recursive inheritance hierarchy from the first element (most 172 * derived class) to the last (least derived class). The @c Idx 173 * parameter gives the 0-based index of the element stored at this 174 * point in the hierarchy; we use it to implement a constant-time 175 * get() operation. 176 */ 177 template<std::size_t _Idx, typename... _Elements> 178 struct _Tuple_impl; 179 180 /** 181 * Zero-element tuple implementation. This is the basis case for the 182 * inheritance recursion. 183 */ 184 template<std::size_t _Idx> 185 struct _Tuple_impl<_Idx> 186 { 187 template<std::size_t, typename...> friend class _Tuple_impl; 188 189 _Tuple_impl() = default; 190 191 template<typename _Alloc> 192 _Tuple_impl(allocator_arg_t, const _Alloc&) { } 193 194 template<typename _Alloc> 195 _Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { } 196 197 template<typename _Alloc> 198 _Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { } 199 200 protected: 201 void _M_swap(_Tuple_impl&) noexcept { /* no-op */ } 202 }; 203 204 // Use the Empty Base-class Optimization for empty, non-final types. 205 template<typename _Tp> 206 using __empty_not_final 207 = typename conditional<__is_final(_Tp), false_type, is_empty<_Tp>>::type; 208 209 /** 210 * Recursive tuple implementation. Here we store the @c Head element 211 * and derive from a @c Tuple_impl containing the remaining elements 212 * (which contains the @c Tail). 213 */ 214 template<std::size_t _Idx, typename _Head, typename... _Tail> 215 struct _Tuple_impl<_Idx, _Head, _Tail...> 216 : public _Tuple_impl<_Idx + 1, _Tail...>, 217 private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> 218 { 219 template<std::size_t, typename...> friend class _Tuple_impl; 220 221 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; 222 typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base; 223 224 static constexpr _Head& 225 _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 226 227 static constexpr const _Head& 228 _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } 229 230 static constexpr _Inherited& 231 _M_tail(_Tuple_impl& __t) noexcept { return __t; } 232 233 static constexpr const _Inherited& 234 _M_tail(const _Tuple_impl& __t) noexcept { return __t; } 235 236 constexpr _Tuple_impl() 237 : _Inherited(), _Base() { } 238 239 explicit 240 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) 241 : _Inherited(__tail...), _Base(__head) { } 242 243 template<typename _UHead, typename... _UTail, typename = typename 244 enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 245 explicit 246 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) 247 : _Inherited(std::forward<_UTail>(__tail)...), 248 _Base(std::forward<_UHead>(__head)) { } 249 250 constexpr _Tuple_impl(const _Tuple_impl&) = default; 251 252 constexpr 253 _Tuple_impl(_Tuple_impl&& __in) 254 noexcept(__and_<is_nothrow_move_constructible<_Head>, 255 is_nothrow_move_constructible<_Inherited>>::value) 256 : _Inherited(std::move(_M_tail(__in))), 257 _Base(std::forward<_Head>(_M_head(__in))) { } 258 259 template<typename... _UElements> 260 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) 261 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), 262 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } 263 264 template<typename _UHead, typename... _UTails> 265 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 266 : _Inherited(std::move 267 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 268 _Base(std::forward<_UHead> 269 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } 270 271 template<typename _Alloc> 272 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) 273 : _Inherited(__tag, __a), 274 _Base(__use_alloc<_Head>(__a)) { } 275 276 template<typename _Alloc> 277 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 278 const _Head& __head, const _Tail&... __tail) 279 : _Inherited(__tag, __a, __tail...), 280 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } 281 282 template<typename _Alloc, typename _UHead, typename... _UTail, 283 typename = typename enable_if<sizeof...(_Tail) 284 == sizeof...(_UTail)>::type> 285 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 286 _UHead&& __head, _UTail&&... __tail) 287 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), 288 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 289 std::forward<_UHead>(__head)) { } 290 291 template<typename _Alloc> 292 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 293 const _Tuple_impl& __in) 294 : _Inherited(__tag, __a, _M_tail(__in)), 295 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } 296 297 template<typename _Alloc> 298 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 299 _Tuple_impl&& __in) 300 : _Inherited(__tag, __a, std::move(_M_tail(__in))), 301 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 302 std::forward<_Head>(_M_head(__in))) { } 303 304 template<typename _Alloc, typename... _UElements> 305 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 306 const _Tuple_impl<_Idx, _UElements...>& __in) 307 : _Inherited(__tag, __a, 308 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), 309 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), 310 _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } 311 312 template<typename _Alloc, typename _UHead, typename... _UTails> 313 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, 314 _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 315 : _Inherited(__tag, __a, std::move 316 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), 317 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), 318 std::forward<_UHead> 319 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } 320 321 _Tuple_impl& 322 operator=(const _Tuple_impl& __in) 323 { 324 _M_head(*this) = _M_head(__in); 325 _M_tail(*this) = _M_tail(__in); 326 return *this; 327 } 328 329 _Tuple_impl& 330 operator=(_Tuple_impl&& __in) 331 noexcept(__and_<is_nothrow_move_assignable<_Head>, 332 is_nothrow_move_assignable<_Inherited>>::value) 333 { 334 _M_head(*this) = std::forward<_Head>(_M_head(__in)); 335 _M_tail(*this) = std::move(_M_tail(__in)); 336 return *this; 337 } 338 339 template<typename... _UElements> 340 _Tuple_impl& 341 operator=(const _Tuple_impl<_Idx, _UElements...>& __in) 342 { 343 _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); 344 _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in); 345 return *this; 346 } 347 348 template<typename _UHead, typename... _UTails> 349 _Tuple_impl& 350 operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) 351 { 352 _M_head(*this) = std::forward<_UHead> 353 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); 354 _M_tail(*this) = std::move 355 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)); 356 return *this; 357 } 358 359 protected: 360 void 361 _M_swap(_Tuple_impl& __in) 362 noexcept(noexcept(swap(std::declval<_Head&>(), 363 std::declval<_Head&>())) 364 && noexcept(_M_tail(__in)._M_swap(_M_tail(__in)))) 365 { 366 using std::swap; 367 swap(_M_head(*this), _M_head(__in)); 368 _Inherited::_M_swap(_M_tail(__in)); 369 } 370 }; 371 372 /// Primary class template, tuple 373 template<typename... _Elements> 374 class tuple : public _Tuple_impl<0, _Elements...> 375 { 376 typedef _Tuple_impl<0, _Elements...> _Inherited; 377 378 public: 379 constexpr tuple() 380 : _Inherited() { } 381 382 explicit 383 constexpr tuple(const _Elements&... __elements) 384 : _Inherited(__elements...) { } 385 386 template<typename... _UElements, typename = typename 387 enable_if<__and_<is_convertible<_UElements, 388 _Elements>...>::value>::type> 389 explicit 390 constexpr tuple(_UElements&&... __elements) 391 : _Inherited(std::forward<_UElements>(__elements)...) { } 392 393 constexpr tuple(const tuple&) = default; 394 395 constexpr tuple(tuple&&) = default; 396 397 template<typename... _UElements, typename = typename 398 enable_if<__and_<is_convertible<const _UElements&, 399 _Elements>...>::value>::type> 400 constexpr tuple(const tuple<_UElements...>& __in) 401 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 402 { } 403 404 template<typename... _UElements, typename = typename 405 enable_if<__and_<is_convertible<_UElements, 406 _Elements>...>::value>::type> 407 constexpr tuple(tuple<_UElements...>&& __in) 408 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } 409 410 // Allocator-extended constructors. 411 412 template<typename _Alloc> 413 tuple(allocator_arg_t __tag, const _Alloc& __a) 414 : _Inherited(__tag, __a) { } 415 416 template<typename _Alloc> 417 tuple(allocator_arg_t __tag, const _Alloc& __a, 418 const _Elements&... __elements) 419 : _Inherited(__tag, __a, __elements...) { } 420 421 template<typename _Alloc, typename... _UElements, typename = typename 422 enable_if<sizeof...(_UElements) 423 == sizeof...(_Elements)>::type> 424 tuple(allocator_arg_t __tag, const _Alloc& __a, 425 _UElements&&... __elements) 426 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) 427 { } 428 429 template<typename _Alloc> 430 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 431 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 432 433 template<typename _Alloc> 434 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 435 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 436 437 template<typename _Alloc, typename... _UElements, typename = typename 438 enable_if<sizeof...(_UElements) 439 == sizeof...(_Elements)>::type> 440 tuple(allocator_arg_t __tag, const _Alloc& __a, 441 const tuple<_UElements...>& __in) 442 : _Inherited(__tag, __a, 443 static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) 444 { } 445 446 template<typename _Alloc, typename... _UElements, typename = typename 447 enable_if<sizeof...(_UElements) 448 == sizeof...(_Elements)>::type> 449 tuple(allocator_arg_t __tag, const _Alloc& __a, 450 tuple<_UElements...>&& __in) 451 : _Inherited(__tag, __a, 452 static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) 453 { } 454 455 tuple& 456 operator=(const tuple& __in) 457 { 458 static_cast<_Inherited&>(*this) = __in; 459 return *this; 460 } 461 462 tuple& 463 operator=(tuple&& __in) 464 noexcept(is_nothrow_move_assignable<_Inherited>::value) 465 { 466 static_cast<_Inherited&>(*this) = std::move(__in); 467 return *this; 468 } 469 470 template<typename... _UElements, typename = typename 471 enable_if<sizeof...(_UElements) 472 == sizeof...(_Elements)>::type> 473 tuple& 474 operator=(const tuple<_UElements...>& __in) 475 { 476 static_cast<_Inherited&>(*this) = __in; 477 return *this; 478 } 479 480 template<typename... _UElements, typename = typename 481 enable_if<sizeof...(_UElements) 482 == sizeof...(_Elements)>::type> 483 tuple& 484 operator=(tuple<_UElements...>&& __in) 485 { 486 static_cast<_Inherited&>(*this) = std::move(__in); 487 return *this; 488 } 489 490 void 491 swap(tuple& __in) 492 noexcept(noexcept(__in._M_swap(__in))) 493 { _Inherited::_M_swap(__in); } 494 }; 495 496 // Explicit specialization, zero-element tuple. 497 template<> 498 class tuple<> 499 { 500 public: 501 void swap(tuple&) noexcept { /* no-op */ } 502 }; 503 504 /// Partial specialization, 2-element tuple. 505 /// Includes construction and assignment from a pair. 506 template<typename _T1, typename _T2> 507 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> 508 { 509 typedef _Tuple_impl<0, _T1, _T2> _Inherited; 510 511 public: 512 constexpr tuple() 513 : _Inherited() { } 514 515 explicit 516 constexpr tuple(const _T1& __a1, const _T2& __a2) 517 : _Inherited(__a1, __a2) { } 518 519 template<typename _U1, typename _U2, typename = typename 520 enable_if<__and_<is_convertible<_U1, _T1>, 521 is_convertible<_U2, _T2>>::value>::type> 522 explicit 523 constexpr tuple(_U1&& __a1, _U2&& __a2) 524 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } 525 526 constexpr tuple(const tuple&) = default; 527 528 constexpr tuple(tuple&&) = default; 529 530 template<typename _U1, typename _U2, typename = typename 531 enable_if<__and_<is_convertible<const _U1&, _T1>, 532 is_convertible<const _U2&, _T2>>::value>::type> 533 constexpr tuple(const tuple<_U1, _U2>& __in) 534 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } 535 536 template<typename _U1, typename _U2, typename = typename 537 enable_if<__and_<is_convertible<_U1, _T1>, 538 is_convertible<_U2, _T2>>::value>::type> 539 constexpr tuple(tuple<_U1, _U2>&& __in) 540 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } 541 542 template<typename _U1, typename _U2, typename = typename 543 enable_if<__and_<is_convertible<const _U1&, _T1>, 544 is_convertible<const _U2&, _T2>>::value>::type> 545 constexpr tuple(const pair<_U1, _U2>& __in) 546 : _Inherited(__in.first, __in.second) { } 547 548 template<typename _U1, typename _U2, typename = typename 549 enable_if<__and_<is_convertible<_U1, _T1>, 550 is_convertible<_U2, _T2>>::value>::type> 551 constexpr tuple(pair<_U1, _U2>&& __in) 552 : _Inherited(std::forward<_U1>(__in.first), 553 std::forward<_U2>(__in.second)) { } 554 555 // Allocator-extended constructors. 556 557 template<typename _Alloc> 558 tuple(allocator_arg_t __tag, const _Alloc& __a) 559 : _Inherited(__tag, __a) { } 560 561 template<typename _Alloc> 562 tuple(allocator_arg_t __tag, const _Alloc& __a, 563 const _T1& __a1, const _T2& __a2) 564 : _Inherited(__tag, __a, __a1, __a2) { } 565 566 template<typename _Alloc, typename _U1, typename _U2> 567 tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) 568 : _Inherited(__tag, __a, std::forward<_U1>(__a1), 569 std::forward<_U2>(__a2)) { } 570 571 template<typename _Alloc> 572 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) 573 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } 574 575 template<typename _Alloc> 576 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) 577 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } 578 579 template<typename _Alloc, typename _U1, typename _U2> 580 tuple(allocator_arg_t __tag, const _Alloc& __a, 581 const tuple<_U1, _U2>& __in) 582 : _Inherited(__tag, __a, 583 static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) 584 { } 585 586 template<typename _Alloc, typename _U1, typename _U2> 587 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) 588 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) 589 { } 590 591 template<typename _Alloc, typename _U1, typename _U2> 592 tuple(allocator_arg_t __tag, const _Alloc& __a, 593 const pair<_U1, _U2>& __in) 594 : _Inherited(__tag, __a, __in.first, __in.second) { } 595 596 template<typename _Alloc, typename _U1, typename _U2> 597 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) 598 : _Inherited(__tag, __a, std::forward<_U1>(__in.first), 599 std::forward<_U2>(__in.second)) { } 600 601 tuple& 602 operator=(const tuple& __in) 603 { 604 static_cast<_Inherited&>(*this) = __in; 605 return *this; 606 } 607 608 tuple& 609 operator=(tuple&& __in) 610 noexcept(is_nothrow_move_assignable<_Inherited>::value) 611 { 612 static_cast<_Inherited&>(*this) = std::move(__in); 613 return *this; 614 } 615 616 template<typename _U1, typename _U2> 617 tuple& 618 operator=(const tuple<_U1, _U2>& __in) 619 { 620 static_cast<_Inherited&>(*this) = __in; 621 return *this; 622 } 623 624 template<typename _U1, typename _U2> 625 tuple& 626 operator=(tuple<_U1, _U2>&& __in) 627 { 628 static_cast<_Inherited&>(*this) = std::move(__in); 629 return *this; 630 } 631 632 template<typename _U1, typename _U2> 633 tuple& 634 operator=(const pair<_U1, _U2>& __in) 635 { 636 this->_M_head(*this) = __in.first; 637 this->_M_tail(*this)._M_head(*this) = __in.second; 638 return *this; 639 } 640 641 template<typename _U1, typename _U2> 642 tuple& 643 operator=(pair<_U1, _U2>&& __in) 644 { 645 this->_M_head(*this) = std::forward<_U1>(__in.first); 646 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); 647 return *this; 648 } 649 650 void 651 swap(tuple& __in) 652 noexcept(noexcept(__in._M_swap(__in))) 653 { _Inherited::_M_swap(__in); } 654 }; 655 656 657 /// Gives the type of the ith element of a given tuple type. 658 template<std::size_t __i, typename _Tp> 659 struct tuple_element; 660 661 /** 662 * Recursive case for tuple_element: strip off the first element in 663 * the tuple and retrieve the (i-1)th element of the remaining tuple. 664 */ 665 template<std::size_t __i, typename _Head, typename... _Tail> 666 struct tuple_element<__i, tuple<_Head, _Tail...> > 667 : tuple_element<__i - 1, tuple<_Tail...> > { }; 668 669 /** 670 * Basis case for tuple_element: The first element is the one we're seeking. 671 */ 672 template<typename _Head, typename... _Tail> 673 struct tuple_element<0, tuple<_Head, _Tail...> > 674 { 675 typedef _Head type; 676 }; 677 678 template<std::size_t __i, typename _Tp> 679 struct tuple_element<__i, const _Tp> 680 { 681 typedef typename 682 add_const<typename tuple_element<__i, _Tp>::type>::type type; 683 }; 684 685 template<std::size_t __i, typename _Tp> 686 struct tuple_element<__i, volatile _Tp> 687 { 688 typedef typename 689 add_volatile<typename tuple_element<__i, _Tp>::type>::type type; 690 }; 691 692 template<std::size_t __i, typename _Tp> 693 struct tuple_element<__i, const volatile _Tp> 694 { 695 typedef typename 696 add_cv<typename tuple_element<__i, _Tp>::type>::type type; 697 }; 698 699 /// Finds the size of a given tuple type. 700 template<typename _Tp> 701 struct tuple_size; 702 703 template<typename _Tp> 704 struct tuple_size<const _Tp> 705 : public integral_constant< 706 typename remove_cv<decltype(tuple_size<_Tp>::value)>::type, 707 tuple_size<_Tp>::value> { }; 708 709 template<typename _Tp> 710 struct tuple_size<volatile _Tp> 711 : public integral_constant< 712 typename remove_cv<decltype(tuple_size<_Tp>::value)>::type, 713 tuple_size<_Tp>::value> { }; 714 715 template<typename _Tp> 716 struct tuple_size<const volatile _Tp> 717 : public integral_constant< 718 typename remove_cv<decltype(tuple_size<_Tp>::value)>::type, 719 tuple_size<_Tp>::value> { }; 720 721 /// class tuple_size 722 template<typename... _Elements> 723 struct tuple_size<tuple<_Elements...>> 724 : public integral_constant<std::size_t, sizeof...(_Elements)> { }; 725 726 template<std::size_t __i, typename _Head, typename... _Tail> 727 constexpr typename __add_ref<_Head>::type 728 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 729 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 730 731 template<std::size_t __i, typename _Head, typename... _Tail> 732 constexpr typename __add_c_ref<_Head>::type 733 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept 734 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } 735 736 // Return a reference (const reference, rvalue reference) to the ith element 737 // of a tuple. Any const or non-const ref elements are returned with their 738 // original type. 739 template<std::size_t __i, typename... _Elements> 740 constexpr typename __add_ref< 741 typename tuple_element<__i, tuple<_Elements...>>::type 742 >::type 743 get(tuple<_Elements...>& __t) noexcept 744 { return __get_helper<__i>(__t); } 745 746 template<std::size_t __i, typename... _Elements> 747 constexpr typename __add_c_ref< 748 typename tuple_element<__i, tuple<_Elements...>>::type 749 >::type 750 get(const tuple<_Elements...>& __t) noexcept 751 { return __get_helper<__i>(__t); } 752 753 template<std::size_t __i, typename... _Elements> 754 constexpr typename __add_r_ref< 755 typename tuple_element<__i, tuple<_Elements...>>::type 756 >::type 757 get(tuple<_Elements...>&& __t) noexcept 758 { return std::forward<typename tuple_element<__i, 759 tuple<_Elements...>>::type&&>(get<__i>(__t)); } 760 761 // This class helps construct the various comparison operations on tuples 762 template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j, 763 typename _Tp, typename _Up> 764 struct __tuple_compare; 765 766 template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up> 767 struct __tuple_compare<0, __i, __j, _Tp, _Up> 768 { 769 static bool 770 __eq(const _Tp& __t, const _Up& __u) 771 { 772 return (get<__i>(__t) == get<__i>(__u) && 773 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u)); 774 } 775 776 static bool 777 __less(const _Tp& __t, const _Up& __u) 778 { 779 return ((get<__i>(__t) < get<__i>(__u)) 780 || !(get<__i>(__u) < get<__i>(__t)) && 781 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u)); 782 } 783 }; 784 785 template<std::size_t __i, typename _Tp, typename _Up> 786 struct __tuple_compare<0, __i, __i, _Tp, _Up> 787 { 788 static bool 789 __eq(const _Tp&, const _Up&) { return true; } 790 791 static bool 792 __less(const _Tp&, const _Up&) { return false; } 793 }; 794 795 template<typename... _TElements, typename... _UElements> 796 bool 797 operator==(const tuple<_TElements...>& __t, 798 const tuple<_UElements...>& __u) 799 { 800 typedef tuple<_TElements...> _Tp; 801 typedef tuple<_UElements...> _Up; 802 return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, 803 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u)); 804 } 805 806 template<typename... _TElements, typename... _UElements> 807 bool 808 operator<(const tuple<_TElements...>& __t, 809 const tuple<_UElements...>& __u) 810 { 811 typedef tuple<_TElements...> _Tp; 812 typedef tuple<_UElements...> _Up; 813 return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, 814 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u)); 815 } 816 817 template<typename... _TElements, typename... _UElements> 818 inline bool 819 operator!=(const tuple<_TElements...>& __t, 820 const tuple<_UElements...>& __u) 821 { return !(__t == __u); } 822 823 template<typename... _TElements, typename... _UElements> 824 inline bool 825 operator>(const tuple<_TElements...>& __t, 826 const tuple<_UElements...>& __u) 827 { return __u < __t; } 828 829 template<typename... _TElements, typename... _UElements> 830 inline bool 831 operator<=(const tuple<_TElements...>& __t, 832 const tuple<_UElements...>& __u) 833 { return !(__u < __t); } 834 835 template<typename... _TElements, typename... _UElements> 836 inline bool 837 operator>=(const tuple<_TElements...>& __t, 838 const tuple<_UElements...>& __u) 839 { return !(__t < __u); } 840 841 // NB: DR 705. 842 template<typename... _Elements> 843 constexpr tuple<typename __decay_and_strip<_Elements>::__type...> 844 make_tuple(_Elements&&... __args) 845 { 846 typedef tuple<typename __decay_and_strip<_Elements>::__type...> 847 __result_type; 848 return __result_type(std::forward<_Elements>(__args)...); 849 } 850 851 template<typename... _Elements> 852 constexpr tuple<_Elements&&...> 853 forward_as_tuple(_Elements&&... __args) noexcept 854 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } 855 856 857 template<typename, std::size_t> struct array; 858 859 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 860 constexpr _Tp& get(array<_Tp, _Nm>&) noexcept; 861 862 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 863 constexpr _Tp&& get(array<_Tp, _Nm>&&) noexcept; 864 865 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 866 constexpr const _Tp& get(const array<_Tp, _Nm>&) noexcept; 867 868 template<typename> 869 struct __is_tuple_like_impl : false_type 870 { }; 871 872 template<typename... _Tps> 873 struct __is_tuple_like_impl<tuple<_Tps...>> : true_type 874 { }; 875 876 template<typename _T1, typename _T2> 877 struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type 878 { }; 879 880 template<typename _Tp, std::size_t _Nm> 881 struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type 882 { }; 883 884 // Internal type trait that allows us to sfinae-protect tuple_cat. 885 template<typename _Tp> 886 struct __is_tuple_like 887 : public __is_tuple_like_impl<typename std::remove_cv 888 <typename std::remove_reference<_Tp>::type>::type>::type 889 { }; 890 891 // Stores a tuple of indices. Also used by bind() to extract the elements 892 // in a tuple. 893 template<std::size_t... _Indexes> 894 struct _Index_tuple 895 { 896 typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next; 897 }; 898 899 // Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. 900 template<std::size_t _Num> 901 struct _Build_index_tuple 902 { 903 typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type; 904 }; 905 906 template<> 907 struct _Build_index_tuple<0> 908 { 909 typedef _Index_tuple<> __type; 910 }; 911 912 template<std::size_t, typename, typename, std::size_t> 913 struct __make_tuple_impl; 914 915 template<std::size_t _Idx, typename _Tuple, typename... _Tp, 916 std::size_t _Nm> 917 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> 918 { 919 typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp..., 920 typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type 921 __type; 922 }; 923 924 template<std::size_t _Nm, typename _Tuple, typename... _Tp> 925 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> 926 { 927 typedef tuple<_Tp...> __type; 928 }; 929 930 template<typename _Tuple> 931 struct __do_make_tuple 932 : public __make_tuple_impl<0, tuple<>, _Tuple, 933 std::tuple_size<_Tuple>::value> 934 { }; 935 936 // Returns the std::tuple equivalent of a tuple-like type. 937 template<typename _Tuple> 938 struct __make_tuple 939 : public __do_make_tuple<typename std::remove_cv 940 <typename std::remove_reference<_Tuple>::type>::type> 941 { }; 942 943 // Combines several std::tuple's into a single one. 944 template<typename...> 945 struct __combine_tuples; 946 947 template<> 948 struct __combine_tuples<> 949 { 950 typedef tuple<> __type; 951 }; 952 953 template<typename... _Ts> 954 struct __combine_tuples<tuple<_Ts...>> 955 { 956 typedef tuple<_Ts...> __type; 957 }; 958 959 template<typename... _T1s, typename... _T2s, typename... _Rem> 960 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> 961 { 962 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, 963 _Rem...>::__type __type; 964 }; 965 966 // Computes the result type of tuple_cat given a set of tuple-like types. 967 template<typename... _Tpls> 968 struct __tuple_cat_result 969 { 970 typedef typename __combine_tuples 971 <typename __make_tuple<_Tpls>::__type...>::__type __type; 972 }; 973 974 // Helper to determine the index set for the first tuple-like 975 // type of a given set. 976 template<typename...> 977 struct __make_1st_indices; 978 979 template<> 980 struct __make_1st_indices<> 981 { 982 typedef std::_Index_tuple<> __type; 983 }; 984 985 template<typename _Tp, typename... _Tpls> 986 struct __make_1st_indices<_Tp, _Tpls...> 987 { 988 typedef typename std::_Build_index_tuple<std::tuple_size< 989 typename std::remove_reference<_Tp>::type>::value>::__type __type; 990 }; 991 992 // Performs the actual concatenation by step-wise expanding tuple-like 993 // objects into the elements, which are finally forwarded into the 994 // result tuple. 995 template<typename _Ret, typename _Indices, typename... _Tpls> 996 struct __tuple_concater; 997 998 template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls> 999 struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> 1000 { 1001 template<typename... _Us> 1002 static constexpr _Ret 1003 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) 1004 { 1005 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1006 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; 1007 return __next::_S_do(std::forward<_Tpls>(__tps)..., 1008 std::forward<_Us>(__us)..., 1009 std::get<_Is>(std::forward<_Tp>(__tp))...); 1010 } 1011 }; 1012 1013 template<typename _Ret> 1014 struct __tuple_concater<_Ret, std::_Index_tuple<>> 1015 { 1016 template<typename... _Us> 1017 static constexpr _Ret 1018 _S_do(_Us&&... __us) 1019 { 1020 return _Ret(std::forward<_Us>(__us)...); 1021 } 1022 }; 1023 1024 template<typename... _Tpls, typename = typename 1025 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type> 1026 constexpr auto 1027 tuple_cat(_Tpls&&... __tpls) 1028 -> typename __tuple_cat_result<_Tpls...>::__type 1029 { 1030 typedef typename __tuple_cat_result<_Tpls...>::__type __ret; 1031 typedef typename __make_1st_indices<_Tpls...>::__type __idx; 1032 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; 1033 return __concater::_S_do(std::forward<_Tpls>(__tpls)...); 1034 } 1035 1036 template<typename... _Elements> 1037 inline tuple<_Elements&...> 1038 tie(_Elements&... __args) noexcept 1039 { return tuple<_Elements&...>(__args...); } 1040 1041 template<typename... _Elements> 1042 inline void 1043 swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) 1044 noexcept(noexcept(__x.swap(__y))) 1045 { __x.swap(__y); } 1046 1047 // A class (and instance) which can be used in 'tie' when an element 1048 // of a tuple is not required 1049 struct _Swallow_assign 1050 { 1051 template<class _Tp> 1052 const _Swallow_assign& 1053 operator=(const _Tp&) const 1054 { return *this; } 1055 }; 1056 1057 const _Swallow_assign ignore{}; 1058 1059 /// Partial specialization for tuples 1060 template<typename... _Types, typename _Alloc> 1061 struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { }; 1062 1063 // See stl_pair.h... 1064 template<class _T1, class _T2> 1065 template<typename... _Args1, typename... _Args2> 1066 inline 1067 pair<_T1, _T2>:: 1068 pair(piecewise_construct_t, 1069 tuple<_Args1...> __first, tuple<_Args2...> __second) 1070 : pair(__first, __second, 1071 typename _Build_index_tuple<sizeof...(_Args1)>::__type(), 1072 typename _Build_index_tuple<sizeof...(_Args2)>::__type()) 1073 { } 1074 1075 template<class _T1, class _T2> 1076 template<typename... _Args1, std::size_t... _Indexes1, 1077 typename... _Args2, std::size_t... _Indexes2> 1078 inline 1079 pair<_T1, _T2>:: 1080 pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, 1081 _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) 1082 : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), 1083 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) 1084 { } 1085 1086 _GLIBCXX_END_NAMESPACE_VERSION 1087 } // namespace 1088 1089 #endif // __GXX_EXPERIMENTAL_CXX0X__ 1090 1091 #endif // _GLIBCXX_TUPLE 1092
