1// C++11 <type_traits> -*- C++ -*- 2 3// Copyright (C) 2007-2019 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/type_traits 26 * This is a Standard C++ Library header. 27 */ 28 29#ifndef _GLIBCXX_TYPE_TRAITS 30#define _GLIBCXX_TYPE_TRAITS 1 31 32#pragma GCC system_header 33 34#if __cplusplus < 201103L 35# include <bits/c++0x_warning.h> 36#else 37 38#include <bits/c++config.h> 39 40namespace std _GLIBCXX_VISIBILITY(default) 41{ 42_GLIBCXX_BEGIN_NAMESPACE_VERSION 43 44 /** 45 * @defgroup metaprogramming Metaprogramming 46 * @ingroup utilities 47 * 48 * Template utilities for compile-time introspection and modification, 49 * including type classification traits, type property inspection traits 50 * and type transformation traits. 51 * 52 * @{ 53 */ 54 55 /// integral_constant 56 template<typename _Tp, _Tp __v> 57 struct integral_constant 58 { 59 static constexpr _Tp value = __v; 60 typedef _Tp value_type; 61 typedef integral_constant<_Tp, __v> type; 62 constexpr operator value_type() const noexcept { return value; } 63#if __cplusplus > 201103L 64 65#define __cpp_lib_integral_constant_callable 201304 66 67 constexpr value_type operator()() const noexcept { return value; } 68#endif 69 }; 70 71 template<typename _Tp, _Tp __v> 72 constexpr _Tp integral_constant<_Tp, __v>::value; 73 74 /// The type used as a compile-time boolean with true value. 75 typedef integral_constant<bool, true> true_type; 76 77 /// The type used as a compile-time boolean with false value. 78 typedef integral_constant<bool, false> false_type; 79 80 template<bool __v> 81 using __bool_constant = integral_constant<bool, __v>; 82 83#if __cplusplus > 201402L 84# define __cpp_lib_bool_constant 201505 85 template<bool __v> 86 using bool_constant = integral_constant<bool, __v>; 87#endif 88 89 // Meta programming helper types. 90 91 template<bool, typename, typename> 92 struct conditional; 93 94 template<typename...> 95 struct __or_; 96 97 template<> 98 struct __or_<> 99 : public false_type 100 { }; 101 102 template<typename _B1> 103 struct __or_<_B1> 104 : public _B1 105 { }; 106 107 template<typename _B1, typename _B2> 108 struct __or_<_B1, _B2> 109 : public conditional<_B1::value, _B1, _B2>::type 110 { }; 111 112 template<typename _B1, typename _B2, typename _B3, typename... _Bn> 113 struct __or_<_B1, _B2, _B3, _Bn...> 114 : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type 115 { }; 116 117 template<typename...> 118 struct __and_; 119 120 template<> 121 struct __and_<> 122 : public true_type 123 { }; 124 125 template<typename _B1> 126 struct __and_<_B1> 127 : public _B1 128 { }; 129 130 template<typename _B1, typename _B2> 131 struct __and_<_B1, _B2> 132 : public conditional<_B1::value, _B2, _B1>::type 133 { }; 134 135 template<typename _B1, typename _B2, typename _B3, typename... _Bn> 136 struct __and_<_B1, _B2, _B3, _Bn...> 137 : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type 138 { }; 139 140 template<typename _Pp> 141 struct __not_ 142 : public __bool_constant<!bool(_Pp::value)> 143 { }; 144 145#if __cplusplus >= 201703L 146 147 template<typename... _Bn> 148 inline constexpr bool __or_v = __or_<_Bn...>::value; 149 template<typename... _Bn> 150 inline constexpr bool __and_v = __and_<_Bn...>::value; 151 152#define __cpp_lib_logical_traits 201510 153 154 template<typename... _Bn> 155 struct conjunction 156 : __and_<_Bn...> 157 { }; 158 159 template<typename... _Bn> 160 struct disjunction 161 : __or_<_Bn...> 162 { }; 163 164 template<typename _Pp> 165 struct negation 166 : __not_<_Pp> 167 { }; 168 169 template<typename... _Bn> 170 inline constexpr bool conjunction_v = conjunction<_Bn...>::value; 171 172 template<typename... _Bn> 173 inline constexpr bool disjunction_v = disjunction<_Bn...>::value; 174 175 template<typename _Pp> 176 inline constexpr bool negation_v = negation<_Pp>::value; 177 178#endif // C++17 179 180 // For several sfinae-friendly trait implementations we transport both the 181 // result information (as the member type) and the failure information (no 182 // member type). This is very similar to std::enable_if, but we cannot use 183 // them, because we need to derive from them as an implementation detail. 184 185 template<typename _Tp> 186 struct __success_type 187 { typedef _Tp type; }; 188 189 struct __failure_type 190 { }; 191 192 // Primary type categories. 193 194 template<typename> 195 struct remove_cv; 196 197 template<typename> 198 struct __is_void_helper 199 : public false_type { }; 200 201 template<> 202 struct __is_void_helper<void> 203 : public true_type { }; 204 205 /// is_void 206 template<typename _Tp> 207 struct is_void 208 : public __is_void_helper<typename remove_cv<_Tp>::type>::type 209 { }; 210 211 template<typename> 212 struct __is_integral_helper 213 : public false_type { }; 214 215 template<> 216 struct __is_integral_helper<bool> 217 : public true_type { }; 218 219 template<> 220 struct __is_integral_helper<char> 221 : public true_type { }; 222 223 template<> 224 struct __is_integral_helper<signed char> 225 : public true_type { }; 226 227 template<> 228 struct __is_integral_helper<unsigned char> 229 : public true_type { }; 230 231#ifdef _GLIBCXX_USE_WCHAR_T 232 template<> 233 struct __is_integral_helper<wchar_t> 234 : public true_type { }; 235#endif 236 237#ifdef _GLIBCXX_USE_CHAR8_T 238 template<> 239 struct __is_integral_helper<char8_t> 240 : public true_type { }; 241#endif 242 243 template<> 244 struct __is_integral_helper<char16_t> 245 : public true_type { }; 246 247 template<> 248 struct __is_integral_helper<char32_t> 249 : public true_type { }; 250 251 template<> 252 struct __is_integral_helper<short> 253 : public true_type { }; 254 255 template<> 256 struct __is_integral_helper<unsigned short> 257 : public true_type { }; 258 259 template<> 260 struct __is_integral_helper<int> 261 : public true_type { }; 262 263 template<> 264 struct __is_integral_helper<unsigned int> 265 : public true_type { }; 266 267 template<> 268 struct __is_integral_helper<long> 269 : public true_type { }; 270 271 template<> 272 struct __is_integral_helper<unsigned long> 273 : public true_type { }; 274 275 template<> 276 struct __is_integral_helper<long long> 277 : public true_type { }; 278 279 template<> 280 struct __is_integral_helper<unsigned long long> 281 : public true_type { }; 282 283 // Conditionalizing on __STRICT_ANSI__ here will break any port that 284 // uses one of these types for size_t. 285#if defined(__GLIBCXX_TYPE_INT_N_0) 286 template<> 287 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0> 288 : public true_type { }; 289 290 template<> 291 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0> 292 : public true_type { }; 293#endif 294#if defined(__GLIBCXX_TYPE_INT_N_1) 295 template<> 296 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1> 297 : public true_type { }; 298 299 template<> 300 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1> 301 : public true_type { }; 302#endif 303#if defined(__GLIBCXX_TYPE_INT_N_2) 304 template<> 305 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2> 306 : public true_type { }; 307 308 template<> 309 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2> 310 : public true_type { }; 311#endif 312#if defined(__GLIBCXX_TYPE_INT_N_3) 313 template<> 314 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3> 315 : public true_type { }; 316 317 template<> 318 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3> 319 : public true_type { }; 320#endif 321 322 /// is_integral 323 template<typename _Tp> 324 struct is_integral 325 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type 326 { }; 327 328 template<typename> 329 struct __is_floating_point_helper 330 : public false_type { }; 331 332 template<> 333 struct __is_floating_point_helper<float> 334 : public true_type { }; 335 336 template<> 337 struct __is_floating_point_helper<double> 338 : public true_type { }; 339 340 template<> 341 struct __is_floating_point_helper<long double> 342 : public true_type { }; 343 344#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) 345 template<> 346 struct __is_floating_point_helper<__float128> 347 : public true_type { }; 348#endif 349 350 /// is_floating_point 351 template<typename _Tp> 352 struct is_floating_point 353 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type 354 { }; 355 356 /// is_array 357 template<typename> 358 struct is_array 359 : public false_type { }; 360 361 template<typename _Tp, std::size_t _Size> 362 struct is_array<_Tp[_Size]> 363 : public true_type { }; 364 365 template<typename _Tp> 366 struct is_array<_Tp[]> 367 : public true_type { }; 368 369 template<typename> 370 struct __is_pointer_helper 371 : public false_type { }; 372 373 template<typename _Tp> 374 struct __is_pointer_helper<_Tp*> 375 : public true_type { }; 376 377 /// is_pointer 378 template<typename _Tp> 379 struct is_pointer 380 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type 381 { }; 382 383 /// is_lvalue_reference 384 template<typename> 385 struct is_lvalue_reference 386 : public false_type { }; 387 388 template<typename _Tp> 389 struct is_lvalue_reference<_Tp&> 390 : public true_type { }; 391 392 /// is_rvalue_reference 393 template<typename> 394 struct is_rvalue_reference 395 : public false_type { }; 396 397 template<typename _Tp> 398 struct is_rvalue_reference<_Tp&&> 399 : public true_type { }; 400 401 template<typename> 402 struct is_function; 403 404 template<typename> 405 struct __is_member_object_pointer_helper 406 : public false_type { }; 407 408 template<typename _Tp, typename _Cp> 409 struct __is_member_object_pointer_helper<_Tp _Cp::*> 410 : public __not_<is_function<_Tp>>::type { }; 411 412 /// is_member_object_pointer 413 template<typename _Tp> 414 struct is_member_object_pointer 415 : public __is_member_object_pointer_helper< 416 typename remove_cv<_Tp>::type>::type 417 { }; 418 419 template<typename> 420 struct __is_member_function_pointer_helper 421 : public false_type { }; 422 423 template<typename _Tp, typename _Cp> 424 struct __is_member_function_pointer_helper<_Tp _Cp::*> 425 : public is_function<_Tp>::type { }; 426 427 /// is_member_function_pointer 428 template<typename _Tp> 429 struct is_member_function_pointer 430 : public __is_member_function_pointer_helper< 431 typename remove_cv<_Tp>::type>::type 432 { }; 433 434 /// is_enum 435 template<typename _Tp> 436 struct is_enum 437 : public integral_constant<bool, __is_enum(_Tp)> 438 { }; 439 440 /// is_union 441 template<typename _Tp> 442 struct is_union 443 : public integral_constant<bool, __is_union(_Tp)> 444 { }; 445 446 /// is_class 447 template<typename _Tp> 448 struct is_class 449 : public integral_constant<bool, __is_class(_Tp)> 450 { }; 451 452 /// is_function 453 template<typename> 454 struct is_function 455 : public false_type { }; 456 457 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 458 struct is_function<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> 459 : public true_type { }; 460 461 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 462 struct is_function<_Res(_ArgTypes...) & _GLIBCXX_NOEXCEPT_QUAL> 463 : public true_type { }; 464 465 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 466 struct is_function<_Res(_ArgTypes...) && _GLIBCXX_NOEXCEPT_QUAL> 467 : public true_type { }; 468 469 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 470 struct is_function<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL> 471 : public true_type { }; 472 473 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 474 struct is_function<_Res(_ArgTypes......) & _GLIBCXX_NOEXCEPT_QUAL> 475 : public true_type { }; 476 477 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 478 struct is_function<_Res(_ArgTypes......) && _GLIBCXX_NOEXCEPT_QUAL> 479 : public true_type { }; 480 481 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 482 struct is_function<_Res(_ArgTypes...) const _GLIBCXX_NOEXCEPT_QUAL> 483 : public true_type { }; 484 485 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 486 struct is_function<_Res(_ArgTypes...) const & _GLIBCXX_NOEXCEPT_QUAL> 487 : public true_type { }; 488 489 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 490 struct is_function<_Res(_ArgTypes...) const && _GLIBCXX_NOEXCEPT_QUAL> 491 : public true_type { }; 492 493 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 494 struct is_function<_Res(_ArgTypes......) const _GLIBCXX_NOEXCEPT_QUAL> 495 : public true_type { }; 496 497 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 498 struct is_function<_Res(_ArgTypes......) const & _GLIBCXX_NOEXCEPT_QUAL> 499 : public true_type { }; 500 501 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 502 struct is_function<_Res(_ArgTypes......) const && _GLIBCXX_NOEXCEPT_QUAL> 503 : public true_type { }; 504 505 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 506 struct is_function<_Res(_ArgTypes...) volatile _GLIBCXX_NOEXCEPT_QUAL> 507 : public true_type { }; 508 509 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 510 struct is_function<_Res(_ArgTypes...) volatile & _GLIBCXX_NOEXCEPT_QUAL> 511 : public true_type { }; 512 513 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 514 struct is_function<_Res(_ArgTypes...) volatile && _GLIBCXX_NOEXCEPT_QUAL> 515 : public true_type { }; 516 517 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 518 struct is_function<_Res(_ArgTypes......) volatile _GLIBCXX_NOEXCEPT_QUAL> 519 : public true_type { }; 520 521 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 522 struct is_function<_Res(_ArgTypes......) volatile & _GLIBCXX_NOEXCEPT_QUAL> 523 : public true_type { }; 524 525 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 526 struct is_function<_Res(_ArgTypes......) volatile && _GLIBCXX_NOEXCEPT_QUAL> 527 : public true_type { }; 528 529 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 530 struct is_function<_Res(_ArgTypes...) const volatile _GLIBCXX_NOEXCEPT_QUAL> 531 : public true_type { }; 532 533 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 534 struct is_function<_Res(_ArgTypes...) const volatile & _GLIBCXX_NOEXCEPT_QUAL> 535 : public true_type { }; 536 537 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 538 struct is_function<_Res(_ArgTypes...) const volatile && _GLIBCXX_NOEXCEPT_QUAL> 539 : public true_type { }; 540 541 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 542 struct is_function<_Res(_ArgTypes......) const volatile _GLIBCXX_NOEXCEPT_QUAL> 543 : public true_type { }; 544 545 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 546 struct is_function<_Res(_ArgTypes......) const volatile & _GLIBCXX_NOEXCEPT_QUAL> 547 : public true_type { }; 548 549 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 550 struct is_function<_Res(_ArgTypes......) const volatile && _GLIBCXX_NOEXCEPT_QUAL> 551 : public true_type { }; 552 553#define __cpp_lib_is_null_pointer 201309 554 555 template<typename> 556 struct __is_null_pointer_helper 557 : public false_type { }; 558 559 template<> 560 struct __is_null_pointer_helper<std::nullptr_t> 561 : public true_type { }; 562 563 /// is_null_pointer (LWG 2247). 564 template<typename _Tp> 565 struct is_null_pointer 566 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type 567 { }; 568 569 /// __is_nullptr_t (extension). 570 template<typename _Tp> 571 struct __is_nullptr_t 572 : public is_null_pointer<_Tp> 573 { }; 574 575 // Composite type categories. 576 577 /// is_reference 578 template<typename _Tp> 579 struct is_reference 580 : public __or_<is_lvalue_reference<_Tp>, 581 is_rvalue_reference<_Tp>>::type 582 { }; 583 584 /// is_arithmetic 585 template<typename _Tp> 586 struct is_arithmetic 587 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type 588 { }; 589 590 /// is_fundamental 591 template<typename _Tp> 592 struct is_fundamental 593 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, 594 is_null_pointer<_Tp>>::type 595 { }; 596 597 /// is_object 598 template<typename _Tp> 599 struct is_object 600 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>, 601 is_void<_Tp>>>::type 602 { }; 603 604 template<typename> 605 struct is_member_pointer; 606 607 /// is_scalar 608 template<typename _Tp> 609 struct is_scalar 610 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, 611 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type 612 { }; 613 614 /// is_compound 615 template<typename _Tp> 616 struct is_compound 617 : public __not_<is_fundamental<_Tp>>::type { }; 618 619 template<typename _Tp> 620 struct __is_member_pointer_helper 621 : public false_type { }; 622 623 template<typename _Tp, typename _Cp> 624 struct __is_member_pointer_helper<_Tp _Cp::*> 625 : public true_type { }; 626 627 /// is_member_pointer 628 template<typename _Tp> 629 struct is_member_pointer 630 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type 631 { }; 632 633 // Utility to detect referenceable types ([defns.referenceable]). 634 635 template<typename _Tp> 636 struct __is_referenceable 637 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type 638 { }; 639 640 template<typename _Res, typename... _Args _GLIBCXX_NOEXCEPT_PARM> 641 struct __is_referenceable<_Res(_Args...) _GLIBCXX_NOEXCEPT_QUAL> 642 : public true_type 643 { }; 644 645 template<typename _Res, typename... _Args _GLIBCXX_NOEXCEPT_PARM> 646 struct __is_referenceable<_Res(_Args......) _GLIBCXX_NOEXCEPT_QUAL> 647 : public true_type 648 { }; 649 650 // Type properties. 651 652 /// is_const 653 template<typename> 654 struct is_const 655 : public false_type { }; 656 657 template<typename _Tp> 658 struct is_const<_Tp const> 659 : public true_type { }; 660 661 /// is_volatile 662 template<typename> 663 struct is_volatile 664 : public false_type { }; 665 666 template<typename _Tp> 667 struct is_volatile<_Tp volatile> 668 : public true_type { }; 669 670 /// is_trivial 671 template<typename _Tp> 672 struct is_trivial 673 : public integral_constant<bool, __is_trivial(_Tp)> 674 { }; 675 676 // is_trivially_copyable 677 template<typename _Tp> 678 struct is_trivially_copyable 679 : public integral_constant<bool, __is_trivially_copyable(_Tp)> 680 { }; 681 682 /// is_standard_layout 683 template<typename _Tp> 684 struct is_standard_layout 685 : public integral_constant<bool, __is_standard_layout(_Tp)> 686 { }; 687 688 /// is_pod 689 // Could use is_standard_layout && is_trivial instead of the builtin. 690 template<typename _Tp> 691 struct is_pod 692 : public integral_constant<bool, __is_pod(_Tp)> 693 { }; 694 695 /// is_literal_type 696 template<typename _Tp> 697 struct is_literal_type 698 : public integral_constant<bool, __is_literal_type(_Tp)> 699 { }; 700 701 /// is_empty 702 template<typename _Tp> 703 struct is_empty 704 : public integral_constant<bool, __is_empty(_Tp)> 705 { }; 706 707 /// is_polymorphic 708 template<typename _Tp> 709 struct is_polymorphic 710 : public integral_constant<bool, __is_polymorphic(_Tp)> 711 { }; 712 713#if __cplusplus >= 201402L 714#define __cpp_lib_is_final 201402L 715 /// is_final 716 template<typename _Tp> 717 struct is_final 718 : public integral_constant<bool, __is_final(_Tp)> 719 { }; 720#endif 721 722 /// is_abstract 723 template<typename _Tp> 724 struct is_abstract 725 : public integral_constant<bool, __is_abstract(_Tp)> 726 { }; 727 728 template<typename _Tp, 729 bool = is_arithmetic<_Tp>::value> 730 struct __is_signed_helper 731 : public false_type { }; 732 733 template<typename _Tp> 734 struct __is_signed_helper<_Tp, true> 735 : public integral_constant<bool, _Tp(-1) < _Tp(0)> 736 { }; 737 738 /// is_signed 739 template<typename _Tp> 740 struct is_signed 741 : public __is_signed_helper<_Tp>::type 742 { }; 743 744 /// is_unsigned 745 template<typename _Tp> 746 struct is_unsigned 747 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>> 748 { }; 749 750 751 // Destructible and constructible type properties. 752 753 /** 754 * @brief Utility to simplify expressions used in unevaluated operands 755 * @ingroup utilities 756 */ 757 758 template<typename _Tp, typename _Up = _Tp&&> 759 _Up 760 __declval(int); 761 762 template<typename _Tp> 763 _Tp 764 __declval(long); 765 766 template<typename _Tp> 767 auto declval() noexcept -> decltype(__declval<_Tp>(0)); 768 769 template<typename, unsigned = 0> 770 struct extent; 771 772 template<typename> 773 struct remove_all_extents; 774 775 template<typename _Tp> 776 struct __is_array_known_bounds 777 : public integral_constant<bool, (extent<_Tp>::value > 0)> 778 { }; 779 780 template<typename _Tp> 781 struct __is_array_unknown_bounds 782 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>> 783 { }; 784 785 // In N3290 is_destructible does not say anything about function 786 // types and abstract types, see LWG 2049. This implementation 787 // describes function types as non-destructible and all complete 788 // object types as destructible, iff the explicit destructor 789 // call expression is wellformed. 790 struct __do_is_destructible_impl 791 { 792 template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())> 793 static true_type __test(int); 794 795 template<typename> 796 static false_type __test(...); 797 }; 798 799 template<typename _Tp> 800 struct __is_destructible_impl 801 : public __do_is_destructible_impl 802 { 803 typedef decltype(__test<_Tp>(0)) type; 804 }; 805 806 template<typename _Tp, 807 bool = __or_<is_void<_Tp>, 808 __is_array_unknown_bounds<_Tp>, 809 is_function<_Tp>>::value, 810 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 811 struct __is_destructible_safe; 812 813 template<typename _Tp> 814 struct __is_destructible_safe<_Tp, false, false> 815 : public __is_destructible_impl<typename 816 remove_all_extents<_Tp>::type>::type 817 { }; 818 819 template<typename _Tp> 820 struct __is_destructible_safe<_Tp, true, false> 821 : public false_type { }; 822 823 template<typename _Tp> 824 struct __is_destructible_safe<_Tp, false, true> 825 : public true_type { }; 826 827 /// is_destructible 828 template<typename _Tp> 829 struct is_destructible 830 : public __is_destructible_safe<_Tp>::type 831 { }; 832 833 // is_nothrow_destructible requires that is_destructible is 834 // satisfied as well. We realize that by mimicing the 835 // implementation of is_destructible but refer to noexcept(expr) 836 // instead of decltype(expr). 837 struct __do_is_nt_destructible_impl 838 { 839 template<typename _Tp> 840 static __bool_constant<noexcept(declval<_Tp&>().~_Tp())> 841 __test(int); 842 843 template<typename> 844 static false_type __test(...); 845 }; 846 847 template<typename _Tp> 848 struct __is_nt_destructible_impl 849 : public __do_is_nt_destructible_impl 850 { 851 typedef decltype(__test<_Tp>(0)) type; 852 }; 853 854 template<typename _Tp, 855 bool = __or_<is_void<_Tp>, 856 __is_array_unknown_bounds<_Tp>, 857 is_function<_Tp>>::value, 858 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 859 struct __is_nt_destructible_safe; 860 861 template<typename _Tp> 862 struct __is_nt_destructible_safe<_Tp, false, false> 863 : public __is_nt_destructible_impl<typename 864 remove_all_extents<_Tp>::type>::type 865 { }; 866 867 template<typename _Tp> 868 struct __is_nt_destructible_safe<_Tp, true, false> 869 : public false_type { }; 870 871 template<typename _Tp> 872 struct __is_nt_destructible_safe<_Tp, false, true> 873 : public true_type { }; 874 875 /// is_nothrow_destructible 876 template<typename _Tp> 877 struct is_nothrow_destructible 878 : public __is_nt_destructible_safe<_Tp>::type 879 { }; 880 881 /// is_constructible 882 template<typename _Tp, typename... _Args> 883 struct is_constructible 884 : public __bool_constant<__is_constructible(_Tp, _Args...)> 885 { }; 886 887 /// is_default_constructible 888 template<typename _Tp> 889 struct is_default_constructible 890 : public is_constructible<_Tp>::type 891 { }; 892 893 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 894 struct __is_copy_constructible_impl; 895 896 template<typename _Tp> 897 struct __is_copy_constructible_impl<_Tp, false> 898 : public false_type { }; 899 900 template<typename _Tp> 901 struct __is_copy_constructible_impl<_Tp, true> 902 : public is_constructible<_Tp, const _Tp&> 903 { }; 904 905 /// is_copy_constructible 906 template<typename _Tp> 907 struct is_copy_constructible 908 : public __is_copy_constructible_impl<_Tp> 909 { }; 910 911 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 912 struct __is_move_constructible_impl; 913 914 template<typename _Tp> 915 struct __is_move_constructible_impl<_Tp, false> 916 : public false_type { }; 917 918 template<typename _Tp> 919 struct __is_move_constructible_impl<_Tp, true> 920 : public is_constructible<_Tp, _Tp&&> 921 { }; 922 923 /// is_move_constructible 924 template<typename _Tp> 925 struct is_move_constructible 926 : public __is_move_constructible_impl<_Tp> 927 { }; 928 929 template<bool, typename _Tp, typename... _Args> 930 struct __is_nt_constructible_impl 931 : public false_type 932 { }; 933 934 template<typename _Tp, typename... _Args> 935 struct __is_nt_constructible_impl<true, _Tp, _Args...> 936 : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))> 937 { }; 938 939 template<typename _Tp, typename _Arg> 940 struct __is_nt_constructible_impl<true, _Tp, _Arg> 941 : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))> 942 { }; 943 944 template<typename _Tp> 945 struct __is_nt_constructible_impl<true, _Tp> 946 : public __bool_constant<noexcept(_Tp())> 947 { }; 948 949 template<typename _Tp, size_t _Num> 950 struct __is_nt_constructible_impl<true, _Tp[_Num]> 951 : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())> 952 { }; 953 954 template<typename _Tp, typename... _Args> 955 using __is_nothrow_constructible_impl 956 = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...), 957 _Tp, _Args...>; 958 959 /// is_nothrow_constructible 960 template<typename _Tp, typename... _Args> 961 struct is_nothrow_constructible 962 : public __is_nothrow_constructible_impl<_Tp, _Args...>::type 963 { }; 964 965 /// is_nothrow_default_constructible 966 template<typename _Tp> 967 struct is_nothrow_default_constructible 968 : public __is_nothrow_constructible_impl<_Tp>::type 969 { }; 970 971 972 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 973 struct __is_nothrow_copy_constructible_impl; 974 975 template<typename _Tp> 976 struct __is_nothrow_copy_constructible_impl<_Tp, false> 977 : public false_type { }; 978 979 template<typename _Tp> 980 struct __is_nothrow_copy_constructible_impl<_Tp, true> 981 : public is_nothrow_constructible<_Tp, const _Tp&> 982 { }; 983 984 /// is_nothrow_copy_constructible 985 template<typename _Tp> 986 struct is_nothrow_copy_constructible 987 : public __is_nothrow_copy_constructible_impl<_Tp> 988 { }; 989 990 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 991 struct __is_nothrow_move_constructible_impl; 992 993 template<typename _Tp> 994 struct __is_nothrow_move_constructible_impl<_Tp, false> 995 : public false_type { }; 996 997 template<typename _Tp> 998 struct __is_nothrow_move_constructible_impl<_Tp, true> 999 : public is_nothrow_constructible<_Tp, _Tp&&> 1000 { }; 1001 1002 /// is_nothrow_move_constructible 1003 template<typename _Tp> 1004 struct is_nothrow_move_constructible 1005 : public __is_nothrow_move_constructible_impl<_Tp> 1006 { }; 1007 1008 /// is_assignable 1009 template<typename _Tp, typename _Up> 1010 struct is_assignable 1011 : public __bool_constant<__is_assignable(_Tp, _Up)> 1012 { }; 1013 1014 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1015 struct __is_copy_assignable_impl; 1016 1017 template<typename _Tp> 1018 struct __is_copy_assignable_impl<_Tp, false> 1019 : public false_type { }; 1020 1021 template<typename _Tp> 1022 struct __is_copy_assignable_impl<_Tp, true> 1023 : public is_assignable<_Tp&, const _Tp&> 1024 { }; 1025 1026 /// is_copy_assignable 1027 template<typename _Tp> 1028 struct is_copy_assignable 1029 : public __is_copy_assignable_impl<_Tp> 1030 { }; 1031 1032 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1033 struct __is_move_assignable_impl; 1034 1035 template<typename _Tp> 1036 struct __is_move_assignable_impl<_Tp, false> 1037 : public false_type { }; 1038 1039 template<typename _Tp> 1040 struct __is_move_assignable_impl<_Tp, true> 1041 : public is_assignable<_Tp&, _Tp&&> 1042 { }; 1043 1044 /// is_move_assignable 1045 template<typename _Tp> 1046 struct is_move_assignable 1047 : public __is_move_assignable_impl<_Tp> 1048 { }; 1049 1050 template<typename _Tp, typename _Up> 1051 struct __is_nt_assignable_impl 1052 : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())> 1053 { }; 1054 1055 /// is_nothrow_assignable 1056 template<typename _Tp, typename _Up> 1057 struct is_nothrow_assignable 1058 : public __and_<is_assignable<_Tp, _Up>, 1059 __is_nt_assignable_impl<_Tp, _Up>> 1060 { }; 1061 1062 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1063 struct __is_nt_copy_assignable_impl; 1064 1065 template<typename _Tp> 1066 struct __is_nt_copy_assignable_impl<_Tp, false> 1067 : public false_type { }; 1068 1069 template<typename _Tp> 1070 struct __is_nt_copy_assignable_impl<_Tp, true> 1071 : public is_nothrow_assignable<_Tp&, const _Tp&> 1072 { }; 1073 1074 /// is_nothrow_copy_assignable 1075 template<typename _Tp> 1076 struct is_nothrow_copy_assignable 1077 : public __is_nt_copy_assignable_impl<_Tp> 1078 { }; 1079 1080 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1081 struct __is_nt_move_assignable_impl; 1082 1083 template<typename _Tp> 1084 struct __is_nt_move_assignable_impl<_Tp, false> 1085 : public false_type { }; 1086 1087 template<typename _Tp> 1088 struct __is_nt_move_assignable_impl<_Tp, true> 1089 : public is_nothrow_assignable<_Tp&, _Tp&&> 1090 { }; 1091 1092 /// is_nothrow_move_assignable 1093 template<typename _Tp> 1094 struct is_nothrow_move_assignable 1095 : public __is_nt_move_assignable_impl<_Tp> 1096 { }; 1097 1098 /// is_trivially_constructible 1099 template<typename _Tp, typename... _Args> 1100 struct is_trivially_constructible 1101 : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> 1102 { }; 1103 1104 /// is_trivially_default_constructible 1105 template<typename _Tp> 1106 struct is_trivially_default_constructible 1107 : public is_trivially_constructible<_Tp>::type 1108 { }; 1109 1110 struct __do_is_implicitly_default_constructible_impl 1111 { 1112 template <typename _Tp> 1113 static void __helper(const _Tp&); 1114 1115 template <typename _Tp> 1116 static true_type __test(const _Tp&, 1117 decltype(__helper<const _Tp&>({}))* = 0); 1118 1119 static false_type __test(...); 1120 }; 1121 1122 template<typename _Tp> 1123 struct __is_implicitly_default_constructible_impl 1124 : public __do_is_implicitly_default_constructible_impl 1125 { 1126 typedef decltype(__test(declval<_Tp>())) type; 1127 }; 1128 1129 template<typename _Tp> 1130 struct __is_implicitly_default_constructible_safe 1131 : public __is_implicitly_default_constructible_impl<_Tp>::type 1132 { }; 1133 1134 template <typename _Tp> 1135 struct __is_implicitly_default_constructible 1136 : public __and_<is_default_constructible<_Tp>, 1137 __is_implicitly_default_constructible_safe<_Tp>> 1138 { }; 1139 1140 /// is_trivially_copy_constructible 1141 1142 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1143 struct __is_trivially_copy_constructible_impl; 1144 1145 template<typename _Tp> 1146 struct __is_trivially_copy_constructible_impl<_Tp, false> 1147 : public false_type { }; 1148 1149 template<typename _Tp> 1150 struct __is_trivially_copy_constructible_impl<_Tp, true> 1151 : public __and_<is_copy_constructible<_Tp>, 1152 integral_constant<bool, 1153 __is_trivially_constructible(_Tp, const _Tp&)>> 1154 { }; 1155 1156 template<typename _Tp> 1157 struct is_trivially_copy_constructible 1158 : public __is_trivially_copy_constructible_impl<_Tp> 1159 { }; 1160 1161 /// is_trivially_move_constructible 1162 1163 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1164 struct __is_trivially_move_constructible_impl; 1165 1166 template<typename _Tp> 1167 struct __is_trivially_move_constructible_impl<_Tp, false> 1168 : public false_type { }; 1169 1170 template<typename _Tp> 1171 struct __is_trivially_move_constructible_impl<_Tp, true> 1172 : public __and_<is_move_constructible<_Tp>, 1173 integral_constant<bool, 1174 __is_trivially_constructible(_Tp, _Tp&&)>> 1175 { }; 1176 1177 template<typename _Tp> 1178 struct is_trivially_move_constructible 1179 : public __is_trivially_move_constructible_impl<_Tp> 1180 { }; 1181 1182 /// is_trivially_assignable 1183 template<typename _Tp, typename _Up> 1184 struct is_trivially_assignable 1185 : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> 1186 { }; 1187 1188 /// is_trivially_copy_assignable 1189 1190 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1191 struct __is_trivially_copy_assignable_impl; 1192 1193 template<typename _Tp> 1194 struct __is_trivially_copy_assignable_impl<_Tp, false> 1195 : public false_type { }; 1196 1197 template<typename _Tp> 1198 struct __is_trivially_copy_assignable_impl<_Tp, true> 1199 : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> 1200 { }; 1201 1202 template<typename _Tp> 1203 struct is_trivially_copy_assignable 1204 : public __is_trivially_copy_assignable_impl<_Tp> 1205 { }; 1206 1207 /// is_trivially_move_assignable 1208 1209 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1210 struct __is_trivially_move_assignable_impl; 1211 1212 template<typename _Tp> 1213 struct __is_trivially_move_assignable_impl<_Tp, false> 1214 : public false_type { }; 1215 1216 template<typename _Tp> 1217 struct __is_trivially_move_assignable_impl<_Tp, true> 1218 : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> 1219 { }; 1220 1221 template<typename _Tp> 1222 struct is_trivially_move_assignable 1223 : public __is_trivially_move_assignable_impl<_Tp> 1224 { }; 1225 1226 /// is_trivially_destructible 1227 template<typename _Tp> 1228 struct is_trivially_destructible 1229 : public __and_<is_destructible<_Tp>, 1230 __bool_constant<__has_trivial_destructor(_Tp)>> 1231 { }; 1232 1233 1234 /// has_virtual_destructor 1235 template<typename _Tp> 1236 struct has_virtual_destructor 1237 : public integral_constant<bool, __has_virtual_destructor(_Tp)> 1238 { }; 1239 1240 1241 // type property queries. 1242 1243 /// alignment_of 1244 template<typename _Tp> 1245 struct alignment_of 1246 : public integral_constant<std::size_t, alignof(_Tp)> { }; 1247 1248 /// rank 1249 template<typename> 1250 struct rank 1251 : public integral_constant<std::size_t, 0> { }; 1252 1253 template<typename _Tp, std::size_t _Size> 1254 struct rank<_Tp[_Size]> 1255 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1256 1257 template<typename _Tp> 1258 struct rank<_Tp[]> 1259 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1260 1261 /// extent 1262 template<typename, unsigned _Uint> 1263 struct extent 1264 : public integral_constant<std::size_t, 0> { }; 1265 1266 template<typename _Tp, unsigned _Uint, std::size_t _Size> 1267 struct extent<_Tp[_Size], _Uint> 1268 : public integral_constant<std::size_t, 1269 _Uint == 0 ? _Size : extent<_Tp, 1270 _Uint - 1>::value> 1271 { }; 1272 1273 template<typename _Tp, unsigned _Uint> 1274 struct extent<_Tp[], _Uint> 1275 : public integral_constant<std::size_t, 1276 _Uint == 0 ? 0 : extent<_Tp, 1277 _Uint - 1>::value> 1278 { }; 1279 1280 1281 // Type relations. 1282 1283 /// is_same 1284 template<typename, typename> 1285 struct is_same 1286 : public false_type { }; 1287 1288 template<typename _Tp> 1289 struct is_same<_Tp, _Tp> 1290 : public true_type { }; 1291 1292 /// is_base_of 1293 template<typename _Base, typename _Derived> 1294 struct is_base_of 1295 : public integral_constant<bool, __is_base_of(_Base, _Derived)> 1296 { }; 1297 1298 template<typename _From, typename _To, 1299 bool = __or_<is_void<_From>, is_function<_To>, 1300 is_array<_To>>::value> 1301 struct __is_convertible_helper 1302 { 1303 typedef typename is_void<_To>::type type; 1304 }; 1305 1306 template<typename _From, typename _To> 1307 class __is_convertible_helper<_From, _To, false> 1308 { 1309 template<typename _To1> 1310 static void __test_aux(_To1) noexcept; 1311 1312 template<typename _From1, typename _To1, 1313 typename = decltype(__test_aux<_To1>(std::declval<_From1>()))> 1314 static true_type 1315 __test(int); 1316 1317 template<typename, typename> 1318 static false_type 1319 __test(...); 1320 1321 public: 1322 typedef decltype(__test<_From, _To>(0)) type; 1323 }; 1324 1325 1326 /// is_convertible 1327 template<typename _From, typename _To> 1328 struct is_convertible 1329 : public __is_convertible_helper<_From, _To>::type 1330 { }; 1331 1332#if __cplusplus > 201703L 1333 template<typename _From, typename _To, 1334 bool = __or_<is_void<_From>, is_function<_To>, 1335 is_array<_To>>::value> 1336 struct __is_nt_convertible_helper 1337 : is_void<_To> 1338 { }; 1339 1340 template<typename _From, typename _To> 1341 class __is_nt_convertible_helper<_From, _To, false> 1342 { 1343 template<typename _To1> 1344 static void __test_aux(_To1) noexcept; 1345 1346 template<typename _From1, typename _To1> 1347 static bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))> 1348 __test(int); 1349 1350 template<typename, typename> 1351 static false_type 1352 __test(...); 1353 1354 public: 1355 using type = decltype(__test<_From, _To>(0)); 1356 }; 1357 1358#define __cpp_lib_is_nothrow_convertible 201806L 1359 /// is_nothrow_convertible 1360 template<typename _From, typename _To> 1361 struct is_nothrow_convertible 1362 : public __is_nt_convertible_helper<_From, _To>::type 1363 { }; 1364 1365 /// is_nothrow_convertible_v 1366 template<typename _From, typename _To> 1367 inline constexpr bool is_nothrow_convertible_v 1368 = is_nothrow_convertible<_From, _To>::value; 1369#endif // C++2a 1370 1371 // Const-volatile modifications. 1372 1373 /// remove_const 1374 template<typename _Tp> 1375 struct remove_const 1376 { typedef _Tp type; }; 1377 1378 template<typename _Tp> 1379 struct remove_const<_Tp const> 1380 { typedef _Tp type; }; 1381 1382 /// remove_volatile 1383 template<typename _Tp> 1384 struct remove_volatile 1385 { typedef _Tp type; }; 1386 1387 template<typename _Tp> 1388 struct remove_volatile<_Tp volatile> 1389 { typedef _Tp type; }; 1390 1391 /// remove_cv 1392 template<typename _Tp> 1393 struct remove_cv 1394 { 1395 typedef typename 1396 remove_const<typename remove_volatile<_Tp>::type>::type type; 1397 }; 1398 1399 /// add_const 1400 template<typename _Tp> 1401 struct add_const 1402 { typedef _Tp const type; }; 1403 1404 /// add_volatile 1405 template<typename _Tp> 1406 struct add_volatile 1407 { typedef _Tp volatile type; }; 1408 1409 /// add_cv 1410 template<typename _Tp> 1411 struct add_cv 1412 { 1413 typedef typename 1414 add_const<typename add_volatile<_Tp>::type>::type type; 1415 }; 1416 1417#if __cplusplus > 201103L 1418 1419#define __cpp_lib_transformation_trait_aliases 201304 1420 1421 /// Alias template for remove_const 1422 template<typename _Tp> 1423 using remove_const_t = typename remove_const<_Tp>::type; 1424 1425 /// Alias template for remove_volatile 1426 template<typename _Tp> 1427 using remove_volatile_t = typename remove_volatile<_Tp>::type; 1428 1429 /// Alias template for remove_cv 1430 template<typename _Tp> 1431 using remove_cv_t = typename remove_cv<_Tp>::type; 1432 1433 /// Alias template for add_const 1434 template<typename _Tp> 1435 using add_const_t = typename add_const<_Tp>::type; 1436 1437 /// Alias template for add_volatile 1438 template<typename _Tp> 1439 using add_volatile_t = typename add_volatile<_Tp>::type; 1440 1441 /// Alias template for add_cv 1442 template<typename _Tp> 1443 using add_cv_t = typename add_cv<_Tp>::type; 1444#endif 1445 1446 // Reference transformations. 1447 1448 /// remove_reference 1449 template<typename _Tp> 1450 struct remove_reference 1451 { typedef _Tp type; }; 1452 1453 template<typename _Tp> 1454 struct remove_reference<_Tp&> 1455 { typedef _Tp type; }; 1456 1457 template<typename _Tp> 1458 struct remove_reference<_Tp&&> 1459 { typedef _Tp type; }; 1460 1461 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1462 struct __add_lvalue_reference_helper 1463 { typedef _Tp type; }; 1464 1465 template<typename _Tp> 1466 struct __add_lvalue_reference_helper<_Tp, true> 1467 { typedef _Tp& type; }; 1468 1469 /// add_lvalue_reference 1470 template<typename _Tp> 1471 struct add_lvalue_reference 1472 : public __add_lvalue_reference_helper<_Tp> 1473 { }; 1474 1475 template<typename _Tp, bool = __is_referenceable<_Tp>::value> 1476 struct __add_rvalue_reference_helper 1477 { typedef _Tp type; }; 1478 1479 template<typename _Tp> 1480 struct __add_rvalue_reference_helper<_Tp, true> 1481 { typedef _Tp&& type; }; 1482 1483 /// add_rvalue_reference 1484 template<typename _Tp> 1485 struct add_rvalue_reference 1486 : public __add_rvalue_reference_helper<_Tp> 1487 { }; 1488 1489#if __cplusplus > 201103L 1490 /// Alias template for remove_reference 1491 template<typename _Tp> 1492 using remove_reference_t = typename remove_reference<_Tp>::type; 1493 1494 /// Alias template for add_lvalue_reference 1495 template<typename _Tp> 1496 using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; 1497 1498 /// Alias template for add_rvalue_reference 1499 template<typename _Tp> 1500 using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; 1501#endif 1502 1503 // Sign modifications. 1504 1505 // Utility for constructing identically cv-qualified types. 1506 template<typename _Unqualified, bool _IsConst, bool _IsVol> 1507 struct __cv_selector; 1508 1509 template<typename _Unqualified> 1510 struct __cv_selector<_Unqualified, false, false> 1511 { typedef _Unqualified __type; }; 1512 1513 template<typename _Unqualified> 1514 struct __cv_selector<_Unqualified, false, true> 1515 { typedef volatile _Unqualified __type; }; 1516 1517 template<typename _Unqualified> 1518 struct __cv_selector<_Unqualified, true, false> 1519 { typedef const _Unqualified __type; }; 1520 1521 template<typename _Unqualified> 1522 struct __cv_selector<_Unqualified, true, true> 1523 { typedef const volatile _Unqualified __type; }; 1524 1525 template<typename _Qualified, typename _Unqualified, 1526 bool _IsConst = is_const<_Qualified>::value, 1527 bool _IsVol = is_volatile<_Qualified>::value> 1528 class __match_cv_qualifiers 1529 { 1530 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; 1531 1532 public: 1533 typedef typename __match::__type __type; 1534 }; 1535 1536 // Utility for finding the unsigned versions of signed integral types. 1537 template<typename _Tp> 1538 struct __make_unsigned 1539 { typedef _Tp __type; }; 1540 1541 template<> 1542 struct __make_unsigned<char> 1543 { typedef unsigned char __type; }; 1544 1545 template<> 1546 struct __make_unsigned<signed char> 1547 { typedef unsigned char __type; }; 1548 1549 template<> 1550 struct __make_unsigned<short> 1551 { typedef unsigned short __type; }; 1552 1553 template<> 1554 struct __make_unsigned<int> 1555 { typedef unsigned int __type; }; 1556 1557 template<> 1558 struct __make_unsigned<long> 1559 { typedef unsigned long __type; }; 1560 1561 template<> 1562 struct __make_unsigned<long long> 1563 { typedef unsigned long long __type; }; 1564 1565#if defined(__GLIBCXX_TYPE_INT_N_0) 1566 template<> 1567 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0> 1568 { typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; }; 1569#endif 1570#if defined(__GLIBCXX_TYPE_INT_N_1) 1571 template<> 1572 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1> 1573 { typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; }; 1574#endif 1575#if defined(__GLIBCXX_TYPE_INT_N_2) 1576 template<> 1577 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2> 1578 { typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; }; 1579#endif 1580#if defined(__GLIBCXX_TYPE_INT_N_3) 1581 template<> 1582 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3> 1583 { typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; }; 1584#endif 1585 1586 // Select between integral and enum: not possible to be both. 1587 template<typename _Tp, 1588 bool _IsInt = is_integral<_Tp>::value, 1589 bool _IsEnum = is_enum<_Tp>::value> 1590 class __make_unsigned_selector; 1591 1592 template<typename _Tp> 1593 class __make_unsigned_selector<_Tp, true, false> 1594 { 1595 using __unsigned_type 1596 = typename __make_unsigned<typename remove_cv<_Tp>::type>::__type; 1597 1598 public: 1599 using __type 1600 = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; 1601 }; 1602 1603 class __make_unsigned_selector_base 1604 { 1605 protected: 1606 template<typename...> struct _List { }; 1607 1608 template<typename _Tp, typename... _Up> 1609 struct _List<_Tp, _Up...> : _List<_Up...> 1610 { static constexpr size_t __size = sizeof(_Tp); }; 1611 1612 template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)> 1613 struct __select; 1614 1615 template<size_t _Sz, typename _Uint, typename... _UInts> 1616 struct __select<_Sz, _List<_Uint, _UInts...>, true> 1617 { using __type = _Uint; }; 1618 1619 template<size_t _Sz, typename _Uint, typename... _UInts> 1620 struct __select<_Sz, _List<_Uint, _UInts...>, false> 1621 : __select<_Sz, _List<_UInts...>> 1622 { }; 1623 }; 1624 1625 // Choose unsigned integer type with the smallest rank and same size as _Tp 1626 template<typename _Tp> 1627 class __make_unsigned_selector<_Tp, false, true> 1628 : __make_unsigned_selector_base 1629 { 1630 // With -fshort-enums, an enum may be as small as a char. 1631 using _UInts = _List<unsigned char, unsigned short, unsigned int, 1632 unsigned long, unsigned long long>; 1633 1634 using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type; 1635 1636 public: 1637 using __type 1638 = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; 1639 }; 1640 1641 // wchar_t, char8_t, char16_t and char32_t are integral types but are 1642 // neither signed integer types nor unsigned integer types, so must be 1643 // transformed to the unsigned integer type with the smallest rank. 1644 // Use the partial specialization for enumeration types to do that. 1645#if defined(_GLIBCXX_USE_WCHAR_T) 1646 template<> 1647 struct __make_unsigned<wchar_t> 1648 { 1649 using __type 1650 = typename __make_unsigned_selector<wchar_t, false, true>::__type; 1651 }; 1652#endif 1653 1654#ifdef _GLIBCXX_USE_CHAR8_T 1655 template<> 1656 struct __make_unsigned<char8_t> 1657 { 1658 using __type 1659 = typename __make_unsigned_selector<char8_t, false, true>::__type; 1660 }; 1661#endif 1662 1663 template<> 1664 struct __make_unsigned<char16_t> 1665 { 1666 using __type 1667 = typename __make_unsigned_selector<char16_t, false, true>::__type; 1668 }; 1669 1670 template<> 1671 struct __make_unsigned<char32_t> 1672 { 1673 using __type 1674 = typename __make_unsigned_selector<char32_t, false, true>::__type; 1675 }; 1676 1677 // Given an integral/enum type, return the corresponding unsigned 1678 // integer type. 1679 // Primary template. 1680 /// make_unsigned 1681 template<typename _Tp> 1682 struct make_unsigned 1683 { typedef typename __make_unsigned_selector<_Tp>::__type type; }; 1684 1685 // Integral, but don't define. 1686 template<> 1687 struct make_unsigned<bool>; 1688 1689 1690 // Utility for finding the signed versions of unsigned integral types. 1691 template<typename _Tp> 1692 struct __make_signed 1693 { typedef _Tp __type; }; 1694 1695 template<> 1696 struct __make_signed<char> 1697 { typedef signed char __type; }; 1698 1699 template<> 1700 struct __make_signed<unsigned char> 1701 { typedef signed char __type; }; 1702 1703 template<> 1704 struct __make_signed<unsigned short> 1705 { typedef signed short __type; }; 1706 1707 template<> 1708 struct __make_signed<unsigned int> 1709 { typedef signed int __type; }; 1710 1711 template<> 1712 struct __make_signed<unsigned long> 1713 { typedef signed long __type; }; 1714 1715 template<> 1716 struct __make_signed<unsigned long long> 1717 { typedef signed long long __type; }; 1718 1719#if defined(__GLIBCXX_TYPE_INT_N_0) 1720 template<> 1721 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0> 1722 { typedef __GLIBCXX_TYPE_INT_N_0 __type; }; 1723#endif 1724#if defined(__GLIBCXX_TYPE_INT_N_1) 1725 template<> 1726 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1> 1727 { typedef __GLIBCXX_TYPE_INT_N_1 __type; }; 1728#endif 1729#if defined(__GLIBCXX_TYPE_INT_N_2) 1730 template<> 1731 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2> 1732 { typedef __GLIBCXX_TYPE_INT_N_2 __type; }; 1733#endif 1734#if defined(__GLIBCXX_TYPE_INT_N_3) 1735 template<> 1736 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3> 1737 { typedef __GLIBCXX_TYPE_INT_N_3 __type; }; 1738#endif 1739 1740 // Select between integral and enum: not possible to be both. 1741 template<typename _Tp, 1742 bool _IsInt = is_integral<_Tp>::value, 1743 bool _IsEnum = is_enum<_Tp>::value> 1744 class __make_signed_selector; 1745 1746 template<typename _Tp> 1747 class __make_signed_selector<_Tp, true, false> 1748 { 1749 using __signed_type 1750 = typename __make_signed<typename remove_cv<_Tp>::type>::__type; 1751 1752 public: 1753 using __type 1754 = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; 1755 }; 1756 1757 // Choose signed integer type with the smallest rank and same size as _Tp 1758 template<typename _Tp> 1759 class __make_signed_selector<_Tp, false, true> 1760 { 1761 typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; 1762 1763 public: 1764 typedef typename __make_signed_selector<__unsigned_type>::__type __type; 1765 }; 1766 1767 // wchar_t, char16_t and char32_t are integral types but are neither 1768 // signed integer types nor unsigned integer types, so must be 1769 // transformed to the signed integer type with the smallest rank. 1770 // Use the partial specialization for enumeration types to do that. 1771#if defined(_GLIBCXX_USE_WCHAR_T) 1772 template<> 1773 struct __make_signed<wchar_t> 1774 { 1775 using __type 1776 = typename __make_signed_selector<wchar_t, false, true>::__type; 1777 }; 1778#endif 1779 1780#if defined(_GLIBCXX_USE_CHAR8_T) 1781 template<> 1782 struct __make_signed<char8_t> 1783 { 1784 using __type 1785 = typename __make_signed_selector<char8_t, false, true>::__type; 1786 }; 1787#endif 1788 1789 template<> 1790 struct __make_signed<char16_t> 1791 { 1792 using __type 1793 = typename __make_signed_selector<char16_t, false, true>::__type; 1794 }; 1795 1796 template<> 1797 struct __make_signed<char32_t> 1798 { 1799 using __type 1800 = typename __make_signed_selector<char32_t, false, true>::__type; 1801 }; 1802 1803 // Given an integral/enum type, return the corresponding signed 1804 // integer type. 1805 // Primary template. 1806 /// make_signed 1807 template<typename _Tp> 1808 struct make_signed 1809 { typedef typename __make_signed_selector<_Tp>::__type type; }; 1810 1811 // Integral, but don't define. 1812 template<> 1813 struct make_signed<bool>; 1814 1815#if __cplusplus > 201103L 1816 /// Alias template for make_signed 1817 template<typename _Tp> 1818 using make_signed_t = typename make_signed<_Tp>::type; 1819 1820 /// Alias template for make_unsigned 1821 template<typename _Tp> 1822 using make_unsigned_t = typename make_unsigned<_Tp>::type; 1823#endif 1824 1825 // Array modifications. 1826 1827 /// remove_extent 1828 template<typename _Tp> 1829 struct remove_extent 1830 { typedef _Tp type; }; 1831 1832 template<typename _Tp, std::size_t _Size> 1833 struct remove_extent<_Tp[_Size]> 1834 { typedef _Tp type; }; 1835 1836 template<typename _Tp> 1837 struct remove_extent<_Tp[]> 1838 { typedef _Tp type; }; 1839 1840 /// remove_all_extents 1841 template<typename _Tp> 1842 struct remove_all_extents 1843 { typedef _Tp type; }; 1844 1845 template<typename _Tp, std::size_t _Size> 1846 struct remove_all_extents<_Tp[_Size]> 1847 { typedef typename remove_all_extents<_Tp>::type type; }; 1848 1849 template<typename _Tp> 1850 struct remove_all_extents<_Tp[]> 1851 { typedef typename remove_all_extents<_Tp>::type type; }; 1852 1853#if __cplusplus > 201103L 1854 /// Alias template for remove_extent 1855 template<typename _Tp> 1856 using remove_extent_t = typename remove_extent<_Tp>::type; 1857 1858 /// Alias template for remove_all_extents 1859 template<typename _Tp> 1860 using remove_all_extents_t = typename remove_all_extents<_Tp>::type; 1861#endif 1862 1863 // Pointer modifications. 1864 1865 template<typename _Tp, typename> 1866 struct __remove_pointer_helper 1867 { typedef _Tp type; }; 1868 1869 template<typename _Tp, typename _Up> 1870 struct __remove_pointer_helper<_Tp, _Up*> 1871 { typedef _Up type; }; 1872 1873 /// remove_pointer 1874 template<typename _Tp> 1875 struct remove_pointer 1876 : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> 1877 { }; 1878 1879 /// add_pointer 1880 template<typename _Tp, bool = __or_<__is_referenceable<_Tp>, 1881 is_void<_Tp>>::value> 1882 struct __add_pointer_helper 1883 { typedef _Tp type; }; 1884 1885 template<typename _Tp> 1886 struct __add_pointer_helper<_Tp, true> 1887 { typedef typename remove_reference<_Tp>::type* type; }; 1888 1889 template<typename _Tp> 1890 struct add_pointer 1891 : public __add_pointer_helper<_Tp> 1892 { }; 1893 1894#if __cplusplus > 201103L 1895 /// Alias template for remove_pointer 1896 template<typename _Tp> 1897 using remove_pointer_t = typename remove_pointer<_Tp>::type; 1898 1899 /// Alias template for add_pointer 1900 template<typename _Tp> 1901 using add_pointer_t = typename add_pointer<_Tp>::type; 1902#endif 1903 1904 template<std::size_t _Len> 1905 struct __aligned_storage_msa 1906 { 1907 union __type 1908 { 1909 unsigned char __data[_Len]; 1910 struct __attribute__((__aligned__)) { } __align; 1911 }; 1912 }; 1913 1914 /** 1915 * @brief Alignment type. 1916 * 1917 * The value of _Align is a default-alignment which shall be the 1918 * most stringent alignment requirement for any C++ object type 1919 * whose size is no greater than _Len (3.9). The member typedef 1920 * type shall be a POD type suitable for use as uninitialized 1921 * storage for any object whose size is at most _Len and whose 1922 * alignment is a divisor of _Align. 1923 */ 1924 template<std::size_t _Len, std::size_t _Align = 1925 __alignof__(typename __aligned_storage_msa<_Len>::__type)> 1926 struct aligned_storage 1927 { 1928 union type 1929 { 1930 unsigned char __data[_Len]; 1931 struct __attribute__((__aligned__((_Align)))) { } __align; 1932 }; 1933 }; 1934 1935 template <typename... _Types> 1936 struct __strictest_alignment 1937 { 1938 static const size_t _S_alignment = 0; 1939 static const size_t _S_size = 0; 1940 }; 1941 1942 template <typename _Tp, typename... _Types> 1943 struct __strictest_alignment<_Tp, _Types...> 1944 { 1945 static const size_t _S_alignment = 1946 alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment 1947 ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; 1948 static const size_t _S_size = 1949 sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size 1950 ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; 1951 }; 1952 1953 /** 1954 * @brief Provide aligned storage for types. 1955 * 1956 * [meta.trans.other] 1957 * 1958 * Provides aligned storage for any of the provided types of at 1959 * least size _Len. 1960 * 1961 * @see aligned_storage 1962 */ 1963 template <size_t _Len, typename... _Types> 1964 struct aligned_union 1965 { 1966 private: 1967 static_assert(sizeof...(_Types) != 0, "At least one type is required"); 1968 1969 using __strictest = __strictest_alignment<_Types...>; 1970 static const size_t _S_len = _Len > __strictest::_S_size 1971 ? _Len : __strictest::_S_size; 1972 public: 1973 /// The value of the strictest alignment of _Types. 1974 static const size_t alignment_value = __strictest::_S_alignment; 1975 /// The storage. 1976 typedef typename aligned_storage<_S_len, alignment_value>::type type; 1977 }; 1978 1979 template <size_t _Len, typename... _Types> 1980 const size_t aligned_union<_Len, _Types...>::alignment_value; 1981 1982 // Decay trait for arrays and functions, used for perfect forwarding 1983 // in make_pair, make_tuple, etc. 1984 template<typename _Up, 1985 bool _IsArray = is_array<_Up>::value, 1986 bool _IsFunction = is_function<_Up>::value> 1987 struct __decay_selector; 1988 1989 // NB: DR 705. 1990 template<typename _Up> 1991 struct __decay_selector<_Up, false, false> 1992 { typedef typename remove_cv<_Up>::type __type; }; 1993 1994 template<typename _Up> 1995 struct __decay_selector<_Up, true, false> 1996 { typedef typename remove_extent<_Up>::type* __type; }; 1997 1998 template<typename _Up> 1999 struct __decay_selector<_Up, false, true> 2000 { typedef typename add_pointer<_Up>::type __type; }; 2001 2002 /// decay 2003 template<typename _Tp> 2004 class decay 2005 { 2006 typedef typename remove_reference<_Tp>::type __remove_type; 2007 2008 public: 2009 typedef typename __decay_selector<__remove_type>::__type type; 2010 }; 2011 2012 template<typename _Tp> 2013 class reference_wrapper; 2014 2015 // Helper which adds a reference to a type when given a reference_wrapper 2016 template<typename _Tp> 2017 struct __strip_reference_wrapper 2018 { 2019 typedef _Tp __type; 2020 }; 2021 2022 template<typename _Tp> 2023 struct __strip_reference_wrapper<reference_wrapper<_Tp> > 2024 { 2025 typedef _Tp& __type; 2026 }; 2027 2028 template<typename _Tp> 2029 struct __decay_and_strip 2030 { 2031 typedef typename __strip_reference_wrapper< 2032 typename decay<_Tp>::type>::__type __type; 2033 }; 2034 2035 2036 // Primary template. 2037 /// Define a member typedef @c type only if a boolean constant is true. 2038 template<bool, typename _Tp = void> 2039 struct enable_if 2040 { }; 2041 2042 // Partial specialization for true. 2043 template<typename _Tp> 2044 struct enable_if<true, _Tp> 2045 { typedef _Tp type; }; 2046 2047 template<typename... _Cond> 2048 using _Require = typename enable_if<__and_<_Cond...>::value>::type; 2049 2050 // Primary template. 2051 /// Define a member typedef @c type to one of two argument types. 2052 template<bool _Cond, typename _Iftrue, typename _Iffalse> 2053 struct conditional 2054 { typedef _Iftrue type; }; 2055 2056 // Partial specialization for false. 2057 template<typename _Iftrue, typename _Iffalse> 2058 struct conditional<false, _Iftrue, _Iffalse> 2059 { typedef _Iffalse type; }; 2060 2061 /// common_type 2062 template<typename... _Tp> 2063 struct common_type; 2064 2065 // Sfinae-friendly common_type implementation: 2066 2067 struct __do_common_type_impl 2068 { 2069 template<typename _Tp, typename _Up> 2070 static __success_type<typename decay<decltype 2071 (true ? std::declval<_Tp>() 2072 : std::declval<_Up>())>::type> _S_test(int); 2073 2074 template<typename, typename> 2075 static __failure_type _S_test(...); 2076 }; 2077 2078 template<typename _Tp, typename _Up> 2079 struct __common_type_impl 2080 : private __do_common_type_impl 2081 { 2082 typedef decltype(_S_test<_Tp, _Up>(0)) type; 2083 }; 2084 2085 struct __do_member_type_wrapper 2086 { 2087 template<typename _Tp> 2088 static __success_type<typename _Tp::type> _S_test(int); 2089 2090 template<typename> 2091 static __failure_type _S_test(...); 2092 }; 2093 2094 template<typename _Tp> 2095 struct __member_type_wrapper 2096 : private __do_member_type_wrapper 2097 { 2098 typedef decltype(_S_test<_Tp>(0)) type; 2099 }; 2100 2101 template<typename _CTp, typename... _Args> 2102 struct __expanded_common_type_wrapper 2103 { 2104 typedef common_type<typename _CTp::type, _Args...> type; 2105 }; 2106 2107 template<typename... _Args> 2108 struct __expanded_common_type_wrapper<__failure_type, _Args...> 2109 { typedef __failure_type type; }; 2110 2111 template<> 2112 struct common_type<> 2113 { }; 2114 2115 template<typename _Tp> 2116 struct common_type<_Tp> 2117 : common_type<_Tp, _Tp> 2118 { }; 2119 2120 template<typename _Tp, typename _Up> 2121 struct common_type<_Tp, _Up> 2122 : public __common_type_impl<_Tp, _Up>::type 2123 { }; 2124 2125 template<typename _Tp, typename _Up, typename... _Vp> 2126 struct common_type<_Tp, _Up, _Vp...> 2127 : public __expanded_common_type_wrapper<typename __member_type_wrapper< 2128 common_type<_Tp, _Up>>::type, _Vp...>::type 2129 { }; 2130 2131 template<typename _Tp, bool = is_enum<_Tp>::value> 2132 struct __underlying_type_impl 2133 { 2134 using type = __underlying_type(_Tp); 2135 }; 2136 2137 template<typename _Tp> 2138 struct __underlying_type_impl<_Tp, false> 2139 { }; 2140 2141 /// The underlying type of an enum. 2142 template<typename _Tp> 2143 struct underlying_type 2144 : public __underlying_type_impl<_Tp> 2145 { }; 2146 2147 template<typename _Tp> 2148 struct __declval_protector 2149 { 2150 static const bool __stop = false; 2151 }; 2152 2153 template<typename _Tp> 2154 auto declval() noexcept -> decltype(__declval<_Tp>(0)) 2155 { 2156 static_assert(__declval_protector<_Tp>::__stop, 2157 "declval() must not be used!"); 2158 return __declval<_Tp>(0); 2159 } 2160 2161 // __remove_cvref_t (std::remove_cvref_t for C++11). 2162 template<typename _Tp> 2163 using __remove_cvref_t 2164 = typename remove_cv<typename remove_reference<_Tp>::type>::type; 2165 2166 /// result_of 2167 template<typename _Signature> 2168 class result_of; 2169 2170 // Sfinae-friendly result_of implementation: 2171 2172#define __cpp_lib_result_of_sfinae 201210 2173 2174 struct __invoke_memfun_ref { }; 2175 struct __invoke_memfun_deref { }; 2176 struct __invoke_memobj_ref { }; 2177 struct __invoke_memobj_deref { }; 2178 struct __invoke_other { }; 2179 2180 // Associate a tag type with a specialization of __success_type. 2181 template<typename _Tp, typename _Tag> 2182 struct __result_of_success : __success_type<_Tp> 2183 { using __invoke_type = _Tag; }; 2184 2185 // [func.require] paragraph 1 bullet 1: 2186 struct __result_of_memfun_ref_impl 2187 { 2188 template<typename _Fp, typename _Tp1, typename... _Args> 2189 static __result_of_success<decltype( 2190 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...) 2191 ), __invoke_memfun_ref> _S_test(int); 2192 2193 template<typename...> 2194 static __failure_type _S_test(...); 2195 }; 2196 2197 template<typename _MemPtr, typename _Arg, typename... _Args> 2198 struct __result_of_memfun_ref 2199 : private __result_of_memfun_ref_impl 2200 { 2201 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 2202 }; 2203 2204 // [func.require] paragraph 1 bullet 2: 2205 struct __result_of_memfun_deref_impl 2206 { 2207 template<typename _Fp, typename _Tp1, typename... _Args> 2208 static __result_of_success<decltype( 2209 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...) 2210 ), __invoke_memfun_deref> _S_test(int); 2211 2212 template<typename...> 2213 static __failure_type _S_test(...); 2214 }; 2215 2216 template<typename _MemPtr, typename _Arg, typename... _Args> 2217 struct __result_of_memfun_deref 2218 : private __result_of_memfun_deref_impl 2219 { 2220 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 2221 }; 2222 2223 // [func.require] paragraph 1 bullet 3: 2224 struct __result_of_memobj_ref_impl 2225 { 2226 template<typename _Fp, typename _Tp1> 2227 static __result_of_success<decltype( 2228 std::declval<_Tp1>().*std::declval<_Fp>() 2229 ), __invoke_memobj_ref> _S_test(int); 2230 2231 template<typename, typename> 2232 static __failure_type _S_test(...); 2233 }; 2234 2235 template<typename _MemPtr, typename _Arg> 2236 struct __result_of_memobj_ref 2237 : private __result_of_memobj_ref_impl 2238 { 2239 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 2240 }; 2241 2242 // [func.require] paragraph 1 bullet 4: 2243 struct __result_of_memobj_deref_impl 2244 { 2245 template<typename _Fp, typename _Tp1> 2246 static __result_of_success<decltype( 2247 (*std::declval<_Tp1>()).*std::declval<_Fp>() 2248 ), __invoke_memobj_deref> _S_test(int); 2249 2250 template<typename, typename> 2251 static __failure_type _S_test(...); 2252 }; 2253 2254 template<typename _MemPtr, typename _Arg> 2255 struct __result_of_memobj_deref 2256 : private __result_of_memobj_deref_impl 2257 { 2258 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 2259 }; 2260 2261 template<typename _MemPtr, typename _Arg> 2262 struct __result_of_memobj; 2263 2264 template<typename _Res, typename _Class, typename _Arg> 2265 struct __result_of_memobj<_Res _Class::*, _Arg> 2266 { 2267 typedef __remove_cvref_t<_Arg> _Argval; 2268 typedef _Res _Class::* _MemPtr; 2269 typedef typename conditional<__or_<is_same<_Argval, _Class>, 2270 is_base_of<_Class, _Argval>>::value, 2271 __result_of_memobj_ref<_MemPtr, _Arg>, 2272 __result_of_memobj_deref<_MemPtr, _Arg> 2273 >::type::type type; 2274 }; 2275 2276 template<typename _MemPtr, typename _Arg, typename... _Args> 2277 struct __result_of_memfun; 2278 2279 template<typename _Res, typename _Class, typename _Arg, typename... _Args> 2280 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> 2281 { 2282 typedef typename remove_reference<_Arg>::type _Argval; 2283 typedef _Res _Class::* _MemPtr; 2284 typedef typename conditional<is_base_of<_Class, _Argval>::value, 2285 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, 2286 __result_of_memfun_deref<_MemPtr, _Arg, _Args...> 2287 >::type::type type; 2288 }; 2289 2290 // _GLIBCXX_RESOLVE_LIB_DEFECTS 2291 // 2219. INVOKE-ing a pointer to member with a reference_wrapper 2292 // as the object expression 2293 2294 // Used by result_of, invoke etc. to unwrap a reference_wrapper. 2295 template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>> 2296 struct __inv_unwrap 2297 { 2298 using type = _Tp; 2299 }; 2300 2301 template<typename _Tp, typename _Up> 2302 struct __inv_unwrap<_Tp, reference_wrapper<_Up>> 2303 { 2304 using type = _Up&; 2305 }; 2306 2307 template<bool, bool, typename _Functor, typename... _ArgTypes> 2308 struct __result_of_impl 2309 { 2310 typedef __failure_type type; 2311 }; 2312 2313 template<typename _MemPtr, typename _Arg> 2314 struct __result_of_impl<true, false, _MemPtr, _Arg> 2315 : public __result_of_memobj<typename decay<_MemPtr>::type, 2316 typename __inv_unwrap<_Arg>::type> 2317 { }; 2318 2319 template<typename _MemPtr, typename _Arg, typename... _Args> 2320 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...> 2321 : public __result_of_memfun<typename decay<_MemPtr>::type, 2322 typename __inv_unwrap<_Arg>::type, _Args...> 2323 { }; 2324 2325 // [func.require] paragraph 1 bullet 5: 2326 struct __result_of_other_impl 2327 { 2328 template<typename _Fn, typename... _Args> 2329 static __result_of_success<decltype( 2330 std::declval<_Fn>()(std::declval<_Args>()...) 2331 ), __invoke_other> _S_test(int); 2332 2333 template<typename...> 2334 static __failure_type _S_test(...); 2335 }; 2336 2337 template<typename _Functor, typename... _ArgTypes> 2338 struct __result_of_impl<false, false, _Functor, _ArgTypes...> 2339 : private __result_of_other_impl 2340 { 2341 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; 2342 }; 2343 2344 // __invoke_result (std::invoke_result for C++11) 2345 template<typename _Functor, typename... _ArgTypes> 2346 struct __invoke_result 2347 : public __result_of_impl< 2348 is_member_object_pointer< 2349 typename remove_reference<_Functor>::type 2350 >::value, 2351 is_member_function_pointer< 2352 typename remove_reference<_Functor>::type 2353 >::value, 2354 _Functor, _ArgTypes... 2355 >::type 2356 { }; 2357 2358 template<typename _Functor, typename... _ArgTypes> 2359 struct result_of<_Functor(_ArgTypes...)> 2360 : public __invoke_result<_Functor, _ArgTypes...> 2361 { }; 2362 2363#if __cplusplus >= 201402L 2364 /// Alias template for aligned_storage 2365 template<size_t _Len, size_t _Align = 2366 __alignof__(typename __aligned_storage_msa<_Len>::__type)> 2367 using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; 2368 2369 template <size_t _Len, typename... _Types> 2370 using aligned_union_t = typename aligned_union<_Len, _Types...>::type; 2371 2372 /// Alias template for decay 2373 template<typename _Tp> 2374 using decay_t = typename decay<_Tp>::type; 2375 2376 /// Alias template for enable_if 2377 template<bool _Cond, typename _Tp = void> 2378 using enable_if_t = typename enable_if<_Cond, _Tp>::type; 2379 2380 /// Alias template for conditional 2381 template<bool _Cond, typename _Iftrue, typename _Iffalse> 2382 using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; 2383 2384 /// Alias template for common_type 2385 template<typename... _Tp> 2386 using common_type_t = typename common_type<_Tp...>::type; 2387 2388 /// Alias template for underlying_type 2389 template<typename _Tp> 2390 using underlying_type_t = typename underlying_type<_Tp>::type; 2391 2392 /// Alias template for result_of 2393 template<typename _Tp> 2394 using result_of_t = typename result_of<_Tp>::type; 2395#endif // C++14 2396 2397 // __enable_if_t (std::enable_if_t for C++11) 2398 template<bool _Cond, typename _Tp = void> 2399 using __enable_if_t = typename enable_if<_Cond, _Tp>::type; 2400 2401 // __void_t (std::void_t for C++11) 2402 template<typename...> using __void_t = void; 2403 2404#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11 2405#define __cpp_lib_void_t 201411 2406 /// A metafunction that always yields void, used for detecting valid types. 2407 template<typename...> using void_t = void; 2408#endif 2409 2410 /// Implementation of the detection idiom (negative case). 2411 template<typename _Default, typename _AlwaysVoid, 2412 template<typename...> class _Op, typename... _Args> 2413 struct __detector 2414 { 2415 using value_t = false_type; 2416 using type = _Default; 2417 }; 2418 2419 /// Implementation of the detection idiom (positive case). 2420 template<typename _Default, template<typename...> class _Op, 2421 typename... _Args> 2422 struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> 2423 { 2424 using value_t = true_type; 2425 using type = _Op<_Args...>; 2426 }; 2427 2428 // Detect whether _Op<_Args...> is a valid type, use _Default if not. 2429 template<typename _Default, template<typename...> class _Op, 2430 typename... _Args> 2431 using __detected_or = __detector<_Default, void, _Op, _Args...>; 2432 2433 // _Op<_Args...> if that is a valid type, otherwise _Default. 2434 template<typename _Default, template<typename...> class _Op, 2435 typename... _Args> 2436 using __detected_or_t 2437 = typename __detected_or<_Default, _Op, _Args...>::type; 2438 2439 /// @} group metaprogramming 2440 2441 /** 2442 * Use SFINAE to determine if the type _Tp has a publicly-accessible 2443 * member type _NTYPE. 2444 */ 2445#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \ 2446 template<typename _Tp, typename = __void_t<>> \ 2447 struct __has_##_NTYPE \ 2448 : false_type \ 2449 { }; \ 2450 template<typename _Tp> \ 2451 struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \ 2452 : true_type \ 2453 { }; 2454 2455 template <typename _Tp> 2456 struct __is_swappable; 2457 2458 template <typename _Tp> 2459 struct __is_nothrow_swappable; 2460 2461 template<typename... _Elements> 2462 class tuple; 2463 2464 template<typename> 2465 struct __is_tuple_like_impl : false_type 2466 { }; 2467 2468 template<typename... _Tps> 2469 struct __is_tuple_like_impl<tuple<_Tps...>> : true_type 2470 { }; 2471 2472 // Internal type trait that allows us to sfinae-protect tuple_cat. 2473 template<typename _Tp> 2474 struct __is_tuple_like 2475 : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type 2476 { }; 2477 2478 template<typename _Tp> 2479 inline 2480 typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, 2481 is_move_constructible<_Tp>, 2482 is_move_assignable<_Tp>>::value>::type 2483 swap(_Tp&, _Tp&) 2484 noexcept(__and_<is_nothrow_move_constructible<_Tp>, 2485 is_nothrow_move_assignable<_Tp>>::value); 2486 2487 template<typename _Tp, size_t _Nm> 2488 inline 2489 typename enable_if<__is_swappable<_Tp>::value>::type 2490 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) 2491 noexcept(__is_nothrow_swappable<_Tp>::value); 2492 2493 namespace __swappable_details { 2494 using std::swap; 2495 2496 struct __do_is_swappable_impl 2497 { 2498 template<typename _Tp, typename 2499 = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))> 2500 static true_type __test(int); 2501 2502 template<typename> 2503 static false_type __test(...); 2504 }; 2505 2506 struct __do_is_nothrow_swappable_impl 2507 { 2508 template<typename _Tp> 2509 static __bool_constant< 2510 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) 2511 > __test(int); 2512 2513 template<typename> 2514 static false_type __test(...); 2515 }; 2516 2517 } // namespace __swappable_details 2518 2519 template<typename _Tp> 2520 struct __is_swappable_impl 2521 : public __swappable_details::__do_is_swappable_impl 2522 { 2523 typedef decltype(__test<_Tp>(0)) type; 2524 }; 2525 2526 template<typename _Tp> 2527 struct __is_nothrow_swappable_impl 2528 : public __swappable_details::__do_is_nothrow_swappable_impl 2529 { 2530 typedef decltype(__test<_Tp>(0)) type; 2531 }; 2532 2533 template<typename _Tp> 2534 struct __is_swappable 2535 : public __is_swappable_impl<_Tp>::type 2536 { }; 2537 2538 template<typename _Tp> 2539 struct __is_nothrow_swappable 2540 : public __is_nothrow_swappable_impl<_Tp>::type 2541 { }; 2542 2543#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 2544#define __cpp_lib_is_swappable 201603 2545 /// Metafunctions used for detecting swappable types: p0185r1 2546 2547 /// is_swappable 2548 template<typename _Tp> 2549 struct is_swappable 2550 : public __is_swappable_impl<_Tp>::type 2551 { }; 2552 2553 /// is_nothrow_swappable 2554 template<typename _Tp> 2555 struct is_nothrow_swappable 2556 : public __is_nothrow_swappable_impl<_Tp>::type 2557 { }; 2558 2559#if __cplusplus >= 201402L 2560 /// is_swappable_v 2561 template<typename _Tp> 2562 _GLIBCXX17_INLINE constexpr bool is_swappable_v = 2563 is_swappable<_Tp>::value; 2564 2565 /// is_nothrow_swappable_v 2566 template<typename _Tp> 2567 _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v = 2568 is_nothrow_swappable<_Tp>::value; 2569#endif // __cplusplus >= 201402L 2570 2571 namespace __swappable_with_details { 2572 using std::swap; 2573 2574 struct __do_is_swappable_with_impl 2575 { 2576 template<typename _Tp, typename _Up, typename 2577 = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())), 2578 typename 2579 = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> 2580 static true_type __test(int); 2581 2582 template<typename, typename> 2583 static false_type __test(...); 2584 }; 2585 2586 struct __do_is_nothrow_swappable_with_impl 2587 { 2588 template<typename _Tp, typename _Up> 2589 static __bool_constant< 2590 noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) 2591 && 2592 noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) 2593 > __test(int); 2594 2595 template<typename, typename> 2596 static false_type __test(...); 2597 }; 2598 2599 } // namespace __swappable_with_details 2600 2601 template<typename _Tp, typename _Up> 2602 struct __is_swappable_with_impl 2603 : public __swappable_with_details::__do_is_swappable_with_impl 2604 { 2605 typedef decltype(__test<_Tp, _Up>(0)) type; 2606 }; 2607 2608 // Optimization for the homogenous lvalue case, not required: 2609 template<typename _Tp> 2610 struct __is_swappable_with_impl<_Tp&, _Tp&> 2611 : public __swappable_details::__do_is_swappable_impl 2612 { 2613 typedef decltype(__test<_Tp&>(0)) type; 2614 }; 2615 2616 template<typename _Tp, typename _Up> 2617 struct __is_nothrow_swappable_with_impl 2618 : public __swappable_with_details::__do_is_nothrow_swappable_with_impl 2619 { 2620 typedef decltype(__test<_Tp, _Up>(0)) type; 2621 }; 2622 2623 // Optimization for the homogenous lvalue case, not required: 2624 template<typename _Tp> 2625 struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> 2626 : public __swappable_details::__do_is_nothrow_swappable_impl 2627 { 2628 typedef decltype(__test<_Tp&>(0)) type; 2629 }; 2630 2631 /// is_swappable_with 2632 template<typename _Tp, typename _Up> 2633 struct is_swappable_with 2634 : public __is_swappable_with_impl<_Tp, _Up>::type 2635 { }; 2636 2637 /// is_nothrow_swappable_with 2638 template<typename _Tp, typename _Up> 2639 struct is_nothrow_swappable_with 2640 : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type 2641 { }; 2642 2643#if __cplusplus >= 201402L 2644 /// is_swappable_with_v 2645 template<typename _Tp, typename _Up> 2646 _GLIBCXX17_INLINE constexpr bool is_swappable_with_v = 2647 is_swappable_with<_Tp, _Up>::value; 2648 2649 /// is_nothrow_swappable_with_v 2650 template<typename _Tp, typename _Up> 2651 _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_with_v = 2652 is_nothrow_swappable_with<_Tp, _Up>::value; 2653#endif // __cplusplus >= 201402L 2654 2655#endif// c++1z or gnu++11 2656 2657 // __is_invocable (std::is_invocable for C++11) 2658 2659 // The primary template is used for invalid INVOKE expressions. 2660 template<typename _Result, typename _Ret, 2661 bool = is_void<_Ret>::value, typename = void> 2662 struct __is_invocable_impl : false_type { }; 2663 2664 // Used for valid INVOKE and INVOKE<void> expressions. 2665 template<typename _Result, typename _Ret> 2666 struct __is_invocable_impl<_Result, _Ret, 2667 /* is_void<_Ret> = */ true, 2668 __void_t<typename _Result::type>> 2669 : true_type 2670 { }; 2671 2672#pragma GCC diagnostic push 2673#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" 2674 // Used for INVOKE<R> expressions to check the implicit conversion to R. 2675 template<typename _Result, typename _Ret> 2676 struct __is_invocable_impl<_Result, _Ret, 2677 /* is_void<_Ret> = */ false, 2678 __void_t<typename _Result::type>> 2679 { 2680 private: 2681 // The type of the INVOKE expression. 2682 // Unlike declval, this doesn't add_rvalue_reference. 2683 static typename _Result::type _S_get(); 2684 2685 template<typename _Tp> 2686 static void _S_conv(_Tp); 2687 2688 // This overload is viable if INVOKE(f, args...) can convert to _Tp. 2689 template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))> 2690 static true_type 2691 _S_test(int); 2692 2693 template<typename _Tp> 2694 static false_type 2695 _S_test(...); 2696 2697 public: 2698 using type = decltype(_S_test<_Ret>(1)); 2699 }; 2700#pragma GCC diagnostic pop 2701 2702 template<typename _Fn, typename... _ArgTypes> 2703 struct __is_invocable 2704 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type 2705 { }; 2706 2707 template<typename _Fn, typename _Tp, typename... _Args> 2708 constexpr bool __call_is_nt(__invoke_memfun_ref) 2709 { 2710 using _Up = typename __inv_unwrap<_Tp>::type; 2711 return noexcept((std::declval<_Up>().*std::declval<_Fn>())( 2712 std::declval<_Args>()...)); 2713 } 2714 2715 template<typename _Fn, typename _Tp, typename... _Args> 2716 constexpr bool __call_is_nt(__invoke_memfun_deref) 2717 { 2718 return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( 2719 std::declval<_Args>()...)); 2720 } 2721 2722 template<typename _Fn, typename _Tp> 2723 constexpr bool __call_is_nt(__invoke_memobj_ref) 2724 { 2725 using _Up = typename __inv_unwrap<_Tp>::type; 2726 return noexcept(std::declval<_Up>().*std::declval<_Fn>()); 2727 } 2728 2729 template<typename _Fn, typename _Tp> 2730 constexpr bool __call_is_nt(__invoke_memobj_deref) 2731 { 2732 return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); 2733 } 2734 2735 template<typename _Fn, typename... _Args> 2736 constexpr bool __call_is_nt(__invoke_other) 2737 { 2738 return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); 2739 } 2740 2741 template<typename _Result, typename _Fn, typename... _Args> 2742 struct __call_is_nothrow 2743 : __bool_constant< 2744 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) 2745 > 2746 { }; 2747 2748 template<typename _Fn, typename... _Args> 2749 using __call_is_nothrow_ 2750 = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; 2751 2752 // __is_nothrow_invocable (std::is_nothrow_invocable for C++11) 2753 template<typename _Fn, typename... _Args> 2754 struct __is_nothrow_invocable 2755 : __and_<__is_invocable<_Fn, _Args...>, 2756 __call_is_nothrow_<_Fn, _Args...>>::type 2757 { }; 2758 2759 struct __nonesuch { 2760 __nonesuch() = delete; 2761 ~__nonesuch() = delete; 2762 __nonesuch(__nonesuch const&) = delete; 2763 void operator=(__nonesuch const&) = delete; 2764 }; 2765 2766#if __cplusplus >= 201703L 2767# define __cpp_lib_is_invocable 201703 2768 2769 /// std::invoke_result 2770 template<typename _Functor, typename... _ArgTypes> 2771 struct invoke_result 2772 : public __invoke_result<_Functor, _ArgTypes...> 2773 { }; 2774 2775 /// std::invoke_result_t 2776 template<typename _Fn, typename... _Args> 2777 using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; 2778 2779 /// std::is_invocable 2780 template<typename _Fn, typename... _ArgTypes> 2781 struct is_invocable 2782 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type 2783 { }; 2784 2785 /// std::is_invocable_r 2786 template<typename _Ret, typename _Fn, typename... _ArgTypes> 2787 struct is_invocable_r 2788 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type 2789 { }; 2790 2791 /// std::is_nothrow_invocable 2792 template<typename _Fn, typename... _ArgTypes> 2793 struct is_nothrow_invocable 2794 : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, 2795 __call_is_nothrow_<_Fn, _ArgTypes...>>::type 2796 { }; 2797 2798 template<typename _Result, typename _Ret, typename = void> 2799 struct __is_nt_invocable_impl : false_type { }; 2800 2801 template<typename _Result, typename _Ret> 2802 struct __is_nt_invocable_impl<_Result, _Ret, 2803 __void_t<typename _Result::type>> 2804 : __or_<is_void<_Ret>, 2805 __and_<is_convertible<typename _Result::type, _Ret>, 2806 is_nothrow_constructible<_Ret, typename _Result::type>>> 2807 { }; 2808 2809 /// std::is_nothrow_invocable_r 2810 template<typename _Ret, typename _Fn, typename... _ArgTypes> 2811 struct is_nothrow_invocable_r 2812 : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, 2813 __call_is_nothrow_<_Fn, _ArgTypes...>>::type 2814 { }; 2815 2816 /// std::is_invocable_v 2817 template<typename _Fn, typename... _Args> 2818 inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; 2819 2820 /// std::is_nothrow_invocable_v 2821 template<typename _Fn, typename... _Args> 2822 inline constexpr bool is_nothrow_invocable_v 2823 = is_nothrow_invocable<_Fn, _Args...>::value; 2824 2825 /// std::is_invocable_r_v 2826 template<typename _Fn, typename... _Args> 2827 inline constexpr bool is_invocable_r_v 2828 = is_invocable_r<_Fn, _Args...>::value; 2829 2830 /// std::is_nothrow_invocable_r_v 2831 template<typename _Fn, typename... _Args> 2832 inline constexpr bool is_nothrow_invocable_r_v 2833 = is_nothrow_invocable_r<_Fn, _Args...>::value; 2834#endif // C++17 2835 2836#if __cplusplus >= 201703L 2837# define __cpp_lib_type_trait_variable_templates 201510L 2838template <typename _Tp> 2839 inline constexpr bool is_void_v = is_void<_Tp>::value; 2840template <typename _Tp> 2841 inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; 2842template <typename _Tp> 2843 inline constexpr bool is_integral_v = is_integral<_Tp>::value; 2844template <typename _Tp> 2845 inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; 2846template <typename _Tp> 2847 inline constexpr bool is_array_v = is_array<_Tp>::value; 2848template <typename _Tp> 2849 inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; 2850template <typename _Tp> 2851 inline constexpr bool is_lvalue_reference_v = 2852 is_lvalue_reference<_Tp>::value; 2853template <typename _Tp> 2854 inline constexpr bool is_rvalue_reference_v = 2855 is_rvalue_reference<_Tp>::value; 2856template <typename _Tp> 2857 inline constexpr bool is_member_object_pointer_v = 2858 is_member_object_pointer<_Tp>::value; 2859template <typename _Tp> 2860 inline constexpr bool is_member_function_pointer_v = 2861 is_member_function_pointer<_Tp>::value; 2862template <typename _Tp> 2863 inline constexpr bool is_enum_v = is_enum<_Tp>::value; 2864template <typename _Tp> 2865 inline constexpr bool is_union_v = is_union<_Tp>::value; 2866template <typename _Tp> 2867 inline constexpr bool is_class_v = is_class<_Tp>::value; 2868template <typename _Tp> 2869 inline constexpr bool is_function_v = is_function<_Tp>::value; 2870template <typename _Tp> 2871 inline constexpr bool is_reference_v = is_reference<_Tp>::value; 2872template <typename _Tp> 2873 inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; 2874template <typename _Tp> 2875 inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; 2876template <typename _Tp> 2877 inline constexpr bool is_object_v = is_object<_Tp>::value; 2878template <typename _Tp> 2879 inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; 2880template <typename _Tp> 2881 inline constexpr bool is_compound_v = is_compound<_Tp>::value; 2882template <typename _Tp> 2883 inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; 2884template <typename _Tp> 2885 inline constexpr bool is_const_v = is_const<_Tp>::value; 2886template <typename _Tp> 2887 inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; 2888template <typename _Tp> 2889 inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; 2890template <typename _Tp> 2891 inline constexpr bool is_trivially_copyable_v = 2892 is_trivially_copyable<_Tp>::value; 2893template <typename _Tp> 2894 inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; 2895template <typename _Tp> 2896 inline constexpr bool is_pod_v = is_pod<_Tp>::value; 2897template <typename _Tp> 2898 inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; 2899template <typename _Tp> 2900 inline constexpr bool is_empty_v = is_empty<_Tp>::value; 2901template <typename _Tp> 2902 inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; 2903template <typename _Tp> 2904 inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; 2905template <typename _Tp> 2906 inline constexpr bool is_final_v = is_final<_Tp>::value; 2907template <typename _Tp> 2908 inline constexpr bool is_signed_v = is_signed<_Tp>::value; 2909template <typename _Tp> 2910 inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; 2911template <typename _Tp, typename... _Args> 2912 inline constexpr bool is_constructible_v = 2913 is_constructible<_Tp, _Args...>::value; 2914template <typename _Tp> 2915 inline constexpr bool is_default_constructible_v = 2916 is_default_constructible<_Tp>::value; 2917template <typename _Tp> 2918 inline constexpr bool is_copy_constructible_v = 2919 is_copy_constructible<_Tp>::value; 2920template <typename _Tp> 2921 inline constexpr bool is_move_constructible_v = 2922 is_move_constructible<_Tp>::value; 2923template <typename _Tp, typename _Up> 2924 inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; 2925template <typename _Tp> 2926 inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; 2927template <typename _Tp> 2928 inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; 2929template <typename _Tp> 2930 inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; 2931template <typename _Tp, typename... _Args> 2932 inline constexpr bool is_trivially_constructible_v = 2933 is_trivially_constructible<_Tp, _Args...>::value; 2934template <typename _Tp> 2935 inline constexpr bool is_trivially_default_constructible_v = 2936 is_trivially_default_constructible<_Tp>::value; 2937template <typename _Tp> 2938 inline constexpr bool is_trivially_copy_constructible_v = 2939 is_trivially_copy_constructible<_Tp>::value; 2940template <typename _Tp> 2941 inline constexpr bool is_trivially_move_constructible_v = 2942 is_trivially_move_constructible<_Tp>::value; 2943template <typename _Tp, typename _Up> 2944 inline constexpr bool is_trivially_assignable_v = 2945 is_trivially_assignable<_Tp, _Up>::value; 2946template <typename _Tp> 2947 inline constexpr bool is_trivially_copy_assignable_v = 2948 is_trivially_copy_assignable<_Tp>::value; 2949template <typename _Tp> 2950 inline constexpr bool is_trivially_move_assignable_v = 2951 is_trivially_move_assignable<_Tp>::value; 2952template <typename _Tp> 2953 inline constexpr bool is_trivially_destructible_v = 2954 is_trivially_destructible<_Tp>::value; 2955template <typename _Tp, typename... _Args> 2956 inline constexpr bool is_nothrow_constructible_v = 2957 is_nothrow_constructible<_Tp, _Args...>::value; 2958template <typename _Tp> 2959 inline constexpr bool is_nothrow_default_constructible_v = 2960 is_nothrow_default_constructible<_Tp>::value; 2961template <typename _Tp> 2962 inline constexpr bool is_nothrow_copy_constructible_v = 2963 is_nothrow_copy_constructible<_Tp>::value; 2964template <typename _Tp> 2965 inline constexpr bool is_nothrow_move_constructible_v = 2966 is_nothrow_move_constructible<_Tp>::value; 2967template <typename _Tp, typename _Up> 2968 inline constexpr bool is_nothrow_assignable_v = 2969 is_nothrow_assignable<_Tp, _Up>::value; 2970template <typename _Tp> 2971 inline constexpr bool is_nothrow_copy_assignable_v = 2972 is_nothrow_copy_assignable<_Tp>::value; 2973template <typename _Tp> 2974 inline constexpr bool is_nothrow_move_assignable_v = 2975 is_nothrow_move_assignable<_Tp>::value; 2976template <typename _Tp> 2977 inline constexpr bool is_nothrow_destructible_v = 2978 is_nothrow_destructible<_Tp>::value; 2979template <typename _Tp> 2980 inline constexpr bool has_virtual_destructor_v = 2981 has_virtual_destructor<_Tp>::value; 2982template <typename _Tp> 2983 inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; 2984template <typename _Tp> 2985 inline constexpr size_t rank_v = rank<_Tp>::value; 2986template <typename _Tp, unsigned _Idx = 0> 2987 inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; 2988template <typename _Tp, typename _Up> 2989 inline constexpr bool is_same_v = is_same<_Tp, _Up>::value; 2990template <typename _Base, typename _Derived> 2991 inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; 2992template <typename _From, typename _To> 2993 inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; 2994 2995#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 2996# define __cpp_lib_has_unique_object_representations 201606 2997 /// has_unique_object_representations 2998 template<typename _Tp> 2999 struct has_unique_object_representations 3000 : bool_constant<__has_unique_object_representations( 3001 remove_cv_t<remove_all_extents_t<_Tp>> 3002 )> 3003 { }; 3004 3005 template<typename _Tp> 3006 inline constexpr bool has_unique_object_representations_v 3007 = has_unique_object_representations<_Tp>::value; 3008#endif 3009 3010#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 3011# define __cpp_lib_is_aggregate 201703 3012 /// is_aggregate 3013 template<typename _Tp> 3014 struct is_aggregate 3015 : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { }; 3016 3017 /// is_aggregate_v 3018 template<typename _Tp> 3019 inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value; 3020#endif 3021#endif // C++17 3022 3023#if __cplusplus > 201703L 3024#define __cpp_lib_remove_cvref 201711L 3025 3026 /// Remove references and cv-qualifiers. 3027 template<typename _Tp> 3028 struct remove_cvref 3029 { 3030 using type = __remove_cvref_t<_Tp>; 3031 }; 3032 3033 template<typename _Tp> 3034 using remove_cvref_t = __remove_cvref_t<_Tp>; 3035 3036#define __cpp_lib_type_identity 201806L 3037 /// Identity metafunction. 3038 template<typename _Tp> 3039 struct type_identity { using type = _Tp; }; 3040 3041 template<typename _Tp> 3042 using type_identity_t = typename type_identity<_Tp>::type; 3043 3044#define __cpp_lib_unwrap_ref 201811L 3045 3046 /// Unwrap a reference_wrapper 3047 template<typename _Tp> 3048 struct unwrap_reference { using type = _Tp; }; 3049 3050 template<typename _Tp> 3051 struct unwrap_reference<reference_wrapper<_Tp>> { using type = _Tp&; }; 3052 3053 template<typename _Tp> 3054 using unwrap_reference_t = typename unwrap_reference<_Tp>::type; 3055 3056 /// Decay type and if it's a reference_wrapper, unwrap it 3057 template<typename _Tp> 3058 struct unwrap_ref_decay { using type = unwrap_reference_t<decay_t<_Tp>>; }; 3059 3060 template<typename _Tp> 3061 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type; 3062 3063#define __cpp_lib_bounded_array_traits 201902L 3064 3065 /// True for a type that is an array of known bound. 3066 template<typename _Tp> 3067 struct is_bounded_array 3068 : public __is_array_known_bounds<_Tp> 3069 { }; 3070 3071 /// True for a type that is an array of unknown bound. 3072 template<typename _Tp> 3073 struct is_unbounded_array 3074 : public __is_array_unknown_bounds<_Tp> 3075 { }; 3076 3077 template<typename _Tp> 3078 inline constexpr bool is_bounded_array_v 3079 = is_bounded_array<_Tp>::value; 3080 3081 template<typename _Tp> 3082 inline constexpr bool is_unbounded_array_v 3083 = is_unbounded_array<_Tp>::value; 3084 3085#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED 3086 3087#define __cpp_lib_is_constant_evaluated 201811L 3088 3089 constexpr inline bool 3090 is_constant_evaluated() noexcept 3091 { return __builtin_is_constant_evaluated(); } 3092#endif 3093 3094#endif // C++2a 3095 3096_GLIBCXX_END_NAMESPACE_VERSION 3097} // namespace std 3098 3099#endif // C++11 3100 3101#endif // _GLIBCXX_TYPE_TRAITS 3102