1 // C++11 <type_traits> -*- C++ -*- 2 3 // Copyright (C) 2007-2013 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 40 namespace 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() { return value; } 63 }; 64 65 template<typename _Tp, _Tp __v> 66 constexpr _Tp integral_constant<_Tp, __v>::value; 67 68 /// The type used as a compile-time boolean with true value. 69 typedef integral_constant<bool, true> true_type; 70 71 /// The type used as a compile-time boolean with false value. 72 typedef integral_constant<bool, false> false_type; 73 74 // Meta programming helper types. 75 76 template<bool, typename, typename> 77 struct conditional; 78 79 template<typename...> 80 struct __or_; 81 82 template<> 83 struct __or_<> 84 : public false_type 85 { }; 86 87 template<typename _B1> 88 struct __or_<_B1> 89 : public _B1 90 { }; 91 92 template<typename _B1, typename _B2> 93 struct __or_<_B1, _B2> 94 : public conditional<_B1::value, _B1, _B2>::type 95 { }; 96 97 template<typename _B1, typename _B2, typename _B3, typename... _Bn> 98 struct __or_<_B1, _B2, _B3, _Bn...> 99 : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type 100 { }; 101 102 template<typename...> 103 struct __and_; 104 105 template<> 106 struct __and_<> 107 : public true_type 108 { }; 109 110 template<typename _B1> 111 struct __and_<_B1> 112 : public _B1 113 { }; 114 115 template<typename _B1, typename _B2> 116 struct __and_<_B1, _B2> 117 : public conditional<_B1::value, _B2, _B1>::type 118 { }; 119 120 template<typename _B1, typename _B2, typename _B3, typename... _Bn> 121 struct __and_<_B1, _B2, _B3, _Bn...> 122 : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type 123 { }; 124 125 template<typename _Pp> 126 struct __not_ 127 : public integral_constant<bool, !_Pp::value> 128 { }; 129 130 struct __sfinae_types 131 { 132 typedef char __one; 133 typedef struct { char __arr[2]; } __two; 134 }; 135 136 // For several sfinae-friendly trait implementations we transport both the 137 // result information (as the member type) and the failure information (no 138 // member type). This is very similar to std::enable_if, but we cannot use 139 // them, because we need to derive from them as an implementation detail. 140 141 template<typename _Tp> 142 struct __success_type 143 { typedef _Tp type; }; 144 145 struct __failure_type 146 { }; 147 148 // Primary type categories. 149 150 template<typename> 151 struct remove_cv; 152 153 template<typename> 154 struct __is_void_helper 155 : public false_type { }; 156 157 template<> 158 struct __is_void_helper<void> 159 : public true_type { }; 160 161 /// is_void 162 template<typename _Tp> 163 struct is_void 164 : public integral_constant<bool, (__is_void_helper<typename 165 remove_cv<_Tp>::type>::value)> 166 { }; 167 168 template<typename> 169 struct __is_integral_helper 170 : public false_type { }; 171 172 template<> 173 struct __is_integral_helper<bool> 174 : public true_type { }; 175 176 template<> 177 struct __is_integral_helper<char> 178 : public true_type { }; 179 180 template<> 181 struct __is_integral_helper<signed char> 182 : public true_type { }; 183 184 template<> 185 struct __is_integral_helper<unsigned char> 186 : public true_type { }; 187 188 #ifdef _GLIBCXX_USE_WCHAR_T 189 template<> 190 struct __is_integral_helper<wchar_t> 191 : public true_type { }; 192 #endif 193 194 template<> 195 struct __is_integral_helper<char16_t> 196 : public true_type { }; 197 198 template<> 199 struct __is_integral_helper<char32_t> 200 : public true_type { }; 201 202 template<> 203 struct __is_integral_helper<short> 204 : public true_type { }; 205 206 template<> 207 struct __is_integral_helper<unsigned short> 208 : public true_type { }; 209 210 template<> 211 struct __is_integral_helper<int> 212 : public true_type { }; 213 214 template<> 215 struct __is_integral_helper<unsigned int> 216 : public true_type { }; 217 218 template<> 219 struct __is_integral_helper<long> 220 : public true_type { }; 221 222 template<> 223 struct __is_integral_helper<unsigned long> 224 : public true_type { }; 225 226 template<> 227 struct __is_integral_helper<long long> 228 : public true_type { }; 229 230 template<> 231 struct __is_integral_helper<unsigned long long> 232 : public true_type { }; 233 234 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128) 235 template<> 236 struct __is_integral_helper<__int128> 237 : public true_type { }; 238 239 template<> 240 struct __is_integral_helper<unsigned __int128> 241 : public true_type { }; 242 #endif 243 244 /// is_integral 245 template<typename _Tp> 246 struct is_integral 247 : public integral_constant<bool, (__is_integral_helper<typename 248 remove_cv<_Tp>::type>::value)> 249 { }; 250 251 template<typename> 252 struct __is_floating_point_helper 253 : public false_type { }; 254 255 template<> 256 struct __is_floating_point_helper<float> 257 : public true_type { }; 258 259 template<> 260 struct __is_floating_point_helper<double> 261 : public true_type { }; 262 263 template<> 264 struct __is_floating_point_helper<long double> 265 : public true_type { }; 266 267 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) && !defined(__clang__) 268 template<> 269 struct __is_floating_point_helper<__float128> 270 : public true_type { }; 271 #endif 272 273 /// is_floating_point 274 template<typename _Tp> 275 struct is_floating_point 276 : public integral_constant<bool, (__is_floating_point_helper<typename 277 remove_cv<_Tp>::type>::value)> 278 { }; 279 280 /// is_array 281 template<typename> 282 struct is_array 283 : public false_type { }; 284 285 template<typename _Tp, std::size_t _Size> 286 struct is_array<_Tp[_Size]> 287 : public true_type { }; 288 289 template<typename _Tp> 290 struct is_array<_Tp[]> 291 : public true_type { }; 292 293 template<typename> 294 struct __is_pointer_helper 295 : public false_type { }; 296 297 template<typename _Tp> 298 struct __is_pointer_helper<_Tp*> 299 : public true_type { }; 300 301 /// is_pointer 302 template<typename _Tp> 303 struct is_pointer 304 : public integral_constant<bool, (__is_pointer_helper<typename 305 remove_cv<_Tp>::type>::value)> 306 { }; 307 308 /// is_lvalue_reference 309 template<typename> 310 struct is_lvalue_reference 311 : public false_type { }; 312 313 template<typename _Tp> 314 struct is_lvalue_reference<_Tp&> 315 : public true_type { }; 316 317 /// is_rvalue_reference 318 template<typename> 319 struct is_rvalue_reference 320 : public false_type { }; 321 322 template<typename _Tp> 323 struct is_rvalue_reference<_Tp&&> 324 : public true_type { }; 325 326 template<typename> 327 struct is_function; 328 329 template<typename> 330 struct __is_member_object_pointer_helper 331 : public false_type { }; 332 333 template<typename _Tp, typename _Cp> 334 struct __is_member_object_pointer_helper<_Tp _Cp::*> 335 : public integral_constant<bool, !is_function<_Tp>::value> { }; 336 337 /// is_member_object_pointer 338 template<typename _Tp> 339 struct is_member_object_pointer 340 : public integral_constant<bool, (__is_member_object_pointer_helper< 341 typename remove_cv<_Tp>::type>::value)> 342 { }; 343 344 template<typename> 345 struct __is_member_function_pointer_helper 346 : public false_type { }; 347 348 template<typename _Tp, typename _Cp> 349 struct __is_member_function_pointer_helper<_Tp _Cp::*> 350 : public integral_constant<bool, is_function<_Tp>::value> { }; 351 352 /// is_member_function_pointer 353 template<typename _Tp> 354 struct is_member_function_pointer 355 : public integral_constant<bool, (__is_member_function_pointer_helper< 356 typename remove_cv<_Tp>::type>::value)> 357 { }; 358 359 /// is_enum 360 template<typename _Tp> 361 struct is_enum 362 : public integral_constant<bool, __is_enum(_Tp)> 363 { }; 364 365 /// is_union 366 template<typename _Tp> 367 struct is_union 368 : public integral_constant<bool, __is_union(_Tp)> 369 { }; 370 371 /// is_class 372 template<typename _Tp> 373 struct is_class 374 : public integral_constant<bool, __is_class(_Tp)> 375 { }; 376 377 /// is_function 378 template<typename> 379 struct is_function 380 : public false_type { }; 381 382 template<typename _Res, typename... _ArgTypes> 383 struct is_function<_Res(_ArgTypes...)> 384 : public true_type { }; 385 386 template<typename _Res, typename... _ArgTypes> 387 struct is_function<_Res(_ArgTypes......)> 388 : public true_type { }; 389 390 template<typename _Res, typename... _ArgTypes> 391 struct is_function<_Res(_ArgTypes...) const> 392 : public true_type { }; 393 394 template<typename _Res, typename... _ArgTypes> 395 struct is_function<_Res(_ArgTypes......) const> 396 : public true_type { }; 397 398 template<typename _Res, typename... _ArgTypes> 399 struct is_function<_Res(_ArgTypes...) volatile> 400 : public true_type { }; 401 402 template<typename _Res, typename... _ArgTypes> 403 struct is_function<_Res(_ArgTypes......) volatile> 404 : public true_type { }; 405 406 template<typename _Res, typename... _ArgTypes> 407 struct is_function<_Res(_ArgTypes...) const volatile> 408 : public true_type { }; 409 410 template<typename _Res, typename... _ArgTypes> 411 struct is_function<_Res(_ArgTypes......) const volatile> 412 : public true_type { }; 413 414 template<typename> 415 struct __is_nullptr_t_helper 416 : public false_type { }; 417 418 template<> 419 struct __is_nullptr_t_helper<std::nullptr_t> 420 : public true_type { }; 421 422 // __is_nullptr_t (extension). 423 template<typename _Tp> 424 struct __is_nullptr_t 425 : public integral_constant<bool, (__is_nullptr_t_helper<typename 426 remove_cv<_Tp>::type>::value)> 427 { }; 428 429 // Composite type categories. 430 431 /// is_reference 432 template<typename _Tp> 433 struct is_reference 434 : public __or_<is_lvalue_reference<_Tp>, 435 is_rvalue_reference<_Tp>>::type 436 { }; 437 438 /// is_arithmetic 439 template<typename _Tp> 440 struct is_arithmetic 441 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type 442 { }; 443 444 /// is_fundamental 445 template<typename _Tp> 446 struct is_fundamental 447 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, __is_nullptr_t<_Tp>>::type 448 { }; 449 450 /// is_object 451 template<typename _Tp> 452 struct is_object 453 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>, 454 is_void<_Tp>>>::type 455 { }; 456 457 template<typename> 458 struct is_member_pointer; 459 460 /// is_scalar 461 template<typename _Tp> 462 struct is_scalar 463 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, 464 is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type 465 { }; 466 467 /// is_compound 468 template<typename _Tp> 469 struct is_compound 470 : public integral_constant<bool, !is_fundamental<_Tp>::value> { }; 471 472 template<typename _Tp> 473 struct __is_member_pointer_helper 474 : public false_type { }; 475 476 template<typename _Tp, typename _Cp> 477 struct __is_member_pointer_helper<_Tp _Cp::*> 478 : public true_type { }; 479 480 /// is_member_pointer 481 template<typename _Tp> 482 struct is_member_pointer 483 : public integral_constant<bool, (__is_member_pointer_helper< 484 typename remove_cv<_Tp>::type>::value)> 485 { }; 486 487 // Type properties. 488 489 /// is_const 490 template<typename> 491 struct is_const 492 : public false_type { }; 493 494 template<typename _Tp> 495 struct is_const<_Tp const> 496 : public true_type { }; 497 498 /// is_volatile 499 template<typename> 500 struct is_volatile 501 : public false_type { }; 502 503 template<typename _Tp> 504 struct is_volatile<_Tp volatile> 505 : public true_type { }; 506 507 /// is_trivial 508 template<typename _Tp> 509 struct is_trivial 510 : public integral_constant<bool, __is_trivial(_Tp)> 511 { }; 512 513 // is_trivially_copyable (still unimplemented) 514 515 /// is_standard_layout 516 template<typename _Tp> 517 struct is_standard_layout 518 : public integral_constant<bool, __is_standard_layout(_Tp)> 519 { }; 520 521 /// is_pod 522 // Could use is_standard_layout && is_trivial instead of the builtin. 523 template<typename _Tp> 524 struct is_pod 525 : public integral_constant<bool, __is_pod(_Tp)> 526 { }; 527 528 /// is_literal_type 529 template<typename _Tp> 530 struct is_literal_type 531 : public integral_constant<bool, __is_literal_type(_Tp)> 532 { }; 533 534 /// is_empty 535 template<typename _Tp> 536 struct is_empty 537 : public integral_constant<bool, __is_empty(_Tp)> 538 { }; 539 540 /// is_polymorphic 541 template<typename _Tp> 542 struct is_polymorphic 543 : public integral_constant<bool, __is_polymorphic(_Tp)> 544 { }; 545 546 /// is_abstract 547 template<typename _Tp> 548 struct is_abstract 549 : public integral_constant<bool, __is_abstract(_Tp)> 550 { }; 551 552 template<typename _Tp, 553 bool = is_integral<_Tp>::value, 554 bool = is_floating_point<_Tp>::value> 555 struct __is_signed_helper 556 : public false_type { }; 557 558 template<typename _Tp> 559 struct __is_signed_helper<_Tp, false, true> 560 : public true_type { }; 561 562 template<typename _Tp> 563 struct __is_signed_helper<_Tp, true, false> 564 : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))> 565 { }; 566 567 /// is_signed 568 template<typename _Tp> 569 struct is_signed 570 : public integral_constant<bool, __is_signed_helper<_Tp>::value> 571 { }; 572 573 /// is_unsigned 574 template<typename _Tp> 575 struct is_unsigned 576 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type 577 { }; 578 579 580 // Destructible and constructible type properties. 581 582 template<typename> 583 struct add_rvalue_reference; 584 585 /** 586 * @brief Utility to simplify expressions used in unevaluated operands 587 * @ingroup utilities 588 */ 589 template<typename _Tp> 590 typename add_rvalue_reference<_Tp>::type declval() noexcept; 591 592 template<typename, unsigned = 0> 593 struct extent; 594 595 template<typename> 596 struct remove_all_extents; 597 598 template<typename _Tp> 599 struct __is_array_known_bounds 600 : public integral_constant<bool, (extent<_Tp>::value > 0)> 601 { }; 602 603 template<typename _Tp> 604 struct __is_array_unknown_bounds 605 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type 606 { }; 607 608 // In N3290 is_destructible does not say anything about function 609 // types and abstract types, see LWG 2049. This implementation 610 // describes function types as non-destructible and all complete 611 // object types as destructible, iff the explicit destructor 612 // call expression is wellformed. 613 struct __do_is_destructible_impl 614 { 615 template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())> 616 static true_type __test(int); 617 618 template<typename> 619 static false_type __test(...); 620 }; 621 622 template<typename _Tp> 623 struct __is_destructible_impl 624 : public __do_is_destructible_impl 625 { 626 typedef decltype(__test<_Tp>(0)) type; 627 }; 628 629 template<typename _Tp, 630 bool = __or_<is_void<_Tp>, 631 __is_array_unknown_bounds<_Tp>, 632 is_function<_Tp>>::value, 633 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 634 struct __is_destructible_safe; 635 636 template<typename _Tp> 637 struct __is_destructible_safe<_Tp, false, false> 638 : public __is_destructible_impl<typename 639 remove_all_extents<_Tp>::type>::type 640 { }; 641 642 template<typename _Tp> 643 struct __is_destructible_safe<_Tp, true, false> 644 : public false_type { }; 645 646 template<typename _Tp> 647 struct __is_destructible_safe<_Tp, false, true> 648 : public true_type { }; 649 650 /// is_destructible 651 template<typename _Tp> 652 struct is_destructible 653 : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)> 654 { }; 655 656 // is_nothrow_destructible requires that is_destructible is 657 // satisfied as well. We realize that by mimicing the 658 // implementation of is_destructible but refer to noexcept(expr) 659 // instead of decltype(expr). 660 struct __do_is_nt_destructible_impl 661 { 662 template<typename _Tp> 663 static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())> 664 __test(int); 665 666 template<typename> 667 static false_type __test(...); 668 }; 669 670 template<typename _Tp> 671 struct __is_nt_destructible_impl 672 : public __do_is_nt_destructible_impl 673 { 674 typedef decltype(__test<_Tp>(0)) type; 675 }; 676 677 template<typename _Tp, 678 bool = __or_<is_void<_Tp>, 679 __is_array_unknown_bounds<_Tp>, 680 is_function<_Tp>>::value, 681 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 682 struct __is_nt_destructible_safe; 683 684 template<typename _Tp> 685 struct __is_nt_destructible_safe<_Tp, false, false> 686 : public __is_nt_destructible_impl<typename 687 remove_all_extents<_Tp>::type>::type 688 { }; 689 690 template<typename _Tp> 691 struct __is_nt_destructible_safe<_Tp, true, false> 692 : public false_type { }; 693 694 template<typename _Tp> 695 struct __is_nt_destructible_safe<_Tp, false, true> 696 : public true_type { }; 697 698 /// is_nothrow_destructible 699 template<typename _Tp> 700 struct is_nothrow_destructible 701 : public integral_constant<bool, (__is_nt_destructible_safe<_Tp>::value)> 702 { }; 703 704 struct __do_is_default_constructible_impl 705 { 706 template<typename _Tp, typename = decltype(_Tp())> 707 static true_type __test(int); 708 709 template<typename> 710 static false_type __test(...); 711 }; 712 713 template<typename _Tp> 714 struct __is_default_constructible_impl 715 : public __do_is_default_constructible_impl 716 { 717 typedef decltype(__test<_Tp>(0)) type; 718 }; 719 720 template<typename _Tp> 721 struct __is_default_constructible_atom 722 : public __and_<__not_<is_void<_Tp>>, 723 __is_default_constructible_impl<_Tp>>::type 724 { }; 725 726 template<typename _Tp, bool = is_array<_Tp>::value> 727 struct __is_default_constructible_safe; 728 729 // The following technique is a workaround for a current core language 730 // restriction, which does not allow for array types to occur in 731 // functional casts of the form T(). Complete arrays can be default- 732 // constructed, if the element type is default-constructible, but 733 // arrays with unknown bounds are not. 734 template<typename _Tp> 735 struct __is_default_constructible_safe<_Tp, true> 736 : public __and_<__is_array_known_bounds<_Tp>, 737 __is_default_constructible_atom<typename 738 remove_all_extents<_Tp>::type>>::type 739 { }; 740 741 template<typename _Tp> 742 struct __is_default_constructible_safe<_Tp, false> 743 : public __is_default_constructible_atom<_Tp>::type 744 { }; 745 746 /// is_default_constructible 747 template<typename _Tp> 748 struct is_default_constructible 749 : public integral_constant<bool, (__is_default_constructible_safe< 750 _Tp>::value)> 751 { }; 752 753 754 // Implementation of is_constructible. 755 756 // The hardest part of this trait is the binary direct-initialization 757 // case, because we hit into a functional cast of the form T(arg). 758 // This implementation uses different strategies depending on the 759 // target type to reduce the test overhead as much as possible: 760 // 761 // a) For a reference target type, we use a static_cast expression 762 // modulo its extra cases. 763 // 764 // b) For a non-reference target type we use a ::new expression. 765 struct __do_is_static_castable_impl 766 { 767 template<typename _From, typename _To, typename 768 = decltype(static_cast<_To>(declval<_From>()))> 769 static true_type __test(int); 770 771 template<typename, typename> 772 static false_type __test(...); 773 }; 774 775 template<typename _From, typename _To> 776 struct __is_static_castable_impl 777 : public __do_is_static_castable_impl 778 { 779 typedef decltype(__test<_From, _To>(0)) type; 780 }; 781 782 template<typename _From, typename _To> 783 struct __is_static_castable_safe 784 : public __is_static_castable_impl<_From, _To>::type 785 { }; 786 787 // __is_static_castable 788 template<typename _From, typename _To> 789 struct __is_static_castable 790 : public integral_constant<bool, (__is_static_castable_safe< 791 _From, _To>::value)> 792 { }; 793 794 // Implementation for non-reference types. To meet the proper 795 // variable definition semantics, we also need to test for 796 // is_destructible in this case. 797 // This form should be simplified by a single expression: 798 // ::delete ::new _Tp(declval<_Arg>()), see c++/51222. 799 struct __do_is_direct_constructible_impl 800 { 801 template<typename _Tp, typename _Arg, typename 802 = decltype(::new _Tp(declval<_Arg>()))> 803 static true_type __test(int); 804 805 template<typename, typename> 806 static false_type __test(...); 807 }; 808 809 template<typename _Tp, typename _Arg> 810 struct __is_direct_constructible_impl 811 : public __do_is_direct_constructible_impl 812 { 813 typedef decltype(__test<_Tp, _Arg>(0)) type; 814 }; 815 816 template<typename _Tp, typename _Arg> 817 struct __is_direct_constructible_new_safe 818 : public __and_<is_destructible<_Tp>, 819 __is_direct_constructible_impl<_Tp, _Arg>>::type 820 { }; 821 822 template<typename, typename> 823 struct is_same; 824 825 template<typename, typename> 826 struct is_base_of; 827 828 template<typename> 829 struct remove_reference; 830 831 template<typename _From, typename _To, bool 832 = __not_<__or_<is_void<_From>, 833 is_function<_From>>>::value> 834 struct __is_base_to_derived_ref; 835 836 // Detect whether we have a downcast situation during 837 // reference binding. 838 template<typename _From, typename _To> 839 struct __is_base_to_derived_ref<_From, _To, true> 840 { 841 typedef typename remove_cv<typename remove_reference<_From 842 >::type>::type __src_t; 843 typedef typename remove_cv<typename remove_reference<_To 844 >::type>::type __dst_t; 845 typedef __and_<__not_<is_same<__src_t, __dst_t>>, 846 is_base_of<__src_t, __dst_t>> type; 847 static constexpr bool value = type::value; 848 }; 849 850 template<typename _From, typename _To> 851 struct __is_base_to_derived_ref<_From, _To, false> 852 : public false_type 853 { }; 854 855 template<typename _From, typename _To, bool 856 = __and_<is_lvalue_reference<_From>, 857 is_rvalue_reference<_To>>::value> 858 struct __is_lvalue_to_rvalue_ref; 859 860 // Detect whether we have an lvalue of non-function type 861 // bound to a reference-compatible rvalue-reference. 862 template<typename _From, typename _To> 863 struct __is_lvalue_to_rvalue_ref<_From, _To, true> 864 { 865 typedef typename remove_cv<typename remove_reference< 866 _From>::type>::type __src_t; 867 typedef typename remove_cv<typename remove_reference< 868 _To>::type>::type __dst_t; 869 typedef __and_<__not_<is_function<__src_t>>, 870 __or_<is_same<__src_t, __dst_t>, 871 is_base_of<__dst_t, __src_t>>> type; 872 static constexpr bool value = type::value; 873 }; 874 875 template<typename _From, typename _To> 876 struct __is_lvalue_to_rvalue_ref<_From, _To, false> 877 : public false_type 878 { }; 879 880 // Here we handle direct-initialization to a reference type as 881 // equivalent to a static_cast modulo overshooting conversions. 882 // These are restricted to the following conversions: 883 // a) A base class value to a derived class reference 884 // b) An lvalue to an rvalue-reference of reference-compatible 885 // types that are not functions 886 template<typename _Tp, typename _Arg> 887 struct __is_direct_constructible_ref_cast 888 : public __and_<__is_static_castable<_Arg, _Tp>, 889 __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, 890 __is_lvalue_to_rvalue_ref<_Arg, _Tp> 891 >>>::type 892 { }; 893 894 template<typename _Tp, typename _Arg> 895 struct __is_direct_constructible_new 896 : public conditional<is_reference<_Tp>::value, 897 __is_direct_constructible_ref_cast<_Tp, _Arg>, 898 __is_direct_constructible_new_safe<_Tp, _Arg> 899 >::type 900 { }; 901 902 template<typename _Tp, typename _Arg> 903 struct __is_direct_constructible 904 : public integral_constant<bool, (__is_direct_constructible_new< 905 _Tp, _Arg>::value)> 906 { }; 907 908 // Since default-construction and binary direct-initialization have 909 // been handled separately, the implementation of the remaining 910 // n-ary construction cases is rather straightforward. We can use 911 // here a functional cast, because array types are excluded anyway 912 // and this form is never interpreted as a C cast. 913 struct __do_is_nary_constructible_impl 914 { 915 template<typename _Tp, typename... _Args, typename 916 = decltype(_Tp(declval<_Args>()...))> 917 static true_type __test(int); 918 919 template<typename, typename...> 920 static false_type __test(...); 921 }; 922 923 template<typename _Tp, typename... _Args> 924 struct __is_nary_constructible_impl 925 : public __do_is_nary_constructible_impl 926 { 927 typedef decltype(__test<_Tp, _Args...>(0)) type; 928 }; 929 930 template<typename _Tp, typename... _Args> 931 struct __is_nary_constructible 932 : public __is_nary_constructible_impl<_Tp, _Args...>::type 933 { 934 static_assert(sizeof...(_Args) > 1, 935 "Only useful for > 1 arguments"); 936 }; 937 938 template<typename _Tp, typename... _Args> 939 struct __is_constructible_impl 940 : public __is_nary_constructible<_Tp, _Args...> 941 { }; 942 943 template<typename _Tp, typename _Arg> 944 struct __is_constructible_impl<_Tp, _Arg> 945 : public __is_direct_constructible<_Tp, _Arg> 946 { }; 947 948 template<typename _Tp> 949 struct __is_constructible_impl<_Tp> 950 : public is_default_constructible<_Tp> 951 { }; 952 953 /// is_constructible 954 template<typename _Tp, typename... _Args> 955 struct is_constructible 956 : public integral_constant<bool, (__is_constructible_impl<_Tp, 957 _Args...>::value)> 958 { }; 959 960 template<typename _Tp, bool = is_void<_Tp>::value> 961 struct __is_copy_constructible_impl; 962 963 template<typename _Tp> 964 struct __is_copy_constructible_impl<_Tp, true> 965 : public false_type { }; 966 967 template<typename _Tp> 968 struct __is_copy_constructible_impl<_Tp, false> 969 : public is_constructible<_Tp, const _Tp&> 970 { }; 971 972 /// is_copy_constructible 973 template<typename _Tp> 974 struct is_copy_constructible 975 : public __is_copy_constructible_impl<_Tp> 976 { }; 977 978 template<typename _Tp, bool = is_void<_Tp>::value> 979 struct __is_move_constructible_impl; 980 981 template<typename _Tp> 982 struct __is_move_constructible_impl<_Tp, true> 983 : public false_type { }; 984 985 template<typename _Tp> 986 struct __is_move_constructible_impl<_Tp, false> 987 : public is_constructible<_Tp, _Tp&&> 988 { }; 989 990 /// is_move_constructible 991 template<typename _Tp> 992 struct is_move_constructible 993 : public __is_move_constructible_impl<_Tp> 994 { }; 995 996 template<typename _Tp> 997 struct __is_nt_default_constructible_atom 998 : public integral_constant<bool, noexcept(_Tp())> 999 { }; 1000 1001 template<typename _Tp, bool = is_array<_Tp>::value> 1002 struct __is_nt_default_constructible_impl; 1003 1004 template<typename _Tp> 1005 struct __is_nt_default_constructible_impl<_Tp, true> 1006 : public __and_<__is_array_known_bounds<_Tp>, 1007 __is_nt_default_constructible_atom<typename 1008 remove_all_extents<_Tp>::type>>::type 1009 { }; 1010 1011 template<typename _Tp> 1012 struct __is_nt_default_constructible_impl<_Tp, false> 1013 : public __is_nt_default_constructible_atom<_Tp> 1014 { }; 1015 1016 /// is_nothrow_default_constructible 1017 template<typename _Tp> 1018 struct is_nothrow_default_constructible 1019 : public __and_<is_default_constructible<_Tp>, 1020 __is_nt_default_constructible_impl<_Tp>>::type 1021 { }; 1022 1023 template<typename _Tp, typename... _Args> 1024 struct __is_nt_constructible_impl 1025 : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))> 1026 { }; 1027 1028 template<typename _Tp, typename _Arg> 1029 struct __is_nt_constructible_impl<_Tp, _Arg> 1030 : public integral_constant<bool, 1031 noexcept(static_cast<_Tp>(declval<_Arg>()))> 1032 { }; 1033 1034 template<typename _Tp> 1035 struct __is_nt_constructible_impl<_Tp> 1036 : public is_nothrow_default_constructible<_Tp> 1037 { }; 1038 1039 /// is_nothrow_constructible 1040 template<typename _Tp, typename... _Args> 1041 struct is_nothrow_constructible 1042 : public __and_<is_constructible<_Tp, _Args...>, 1043 __is_nt_constructible_impl<_Tp, _Args...>>::type 1044 { }; 1045 1046 template<typename _Tp, bool = is_void<_Tp>::value> 1047 struct __is_nothrow_copy_constructible_impl; 1048 1049 template<typename _Tp> 1050 struct __is_nothrow_copy_constructible_impl<_Tp, true> 1051 : public false_type { }; 1052 1053 template<typename _Tp> 1054 struct __is_nothrow_copy_constructible_impl<_Tp, false> 1055 : public is_nothrow_constructible<_Tp, const _Tp&> 1056 { }; 1057 1058 /// is_nothrow_copy_constructible 1059 template<typename _Tp> 1060 struct is_nothrow_copy_constructible 1061 : public __is_nothrow_copy_constructible_impl<_Tp> 1062 { }; 1063 1064 template<typename _Tp, bool = is_void<_Tp>::value> 1065 struct __is_nothrow_move_constructible_impl; 1066 1067 template<typename _Tp> 1068 struct __is_nothrow_move_constructible_impl<_Tp, true> 1069 : public false_type { }; 1070 1071 template<typename _Tp> 1072 struct __is_nothrow_move_constructible_impl<_Tp, false> 1073 : public is_nothrow_constructible<_Tp, _Tp&&> 1074 { }; 1075 1076 /// is_nothrow_move_constructible 1077 template<typename _Tp> 1078 struct is_nothrow_move_constructible 1079 : public __is_nothrow_move_constructible_impl<_Tp> 1080 { }; 1081 1082 template<typename _Tp, typename _Up> 1083 class __is_assignable_helper 1084 : public __sfinae_types 1085 { 1086 template<typename _Tp1, typename _Up1> 1087 static decltype(declval<_Tp1>() = declval<_Up1>(), __one()) 1088 __test(int); 1089 1090 template<typename, typename> 1091 static __two __test(...); 1092 1093 public: 1094 static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1; 1095 }; 1096 1097 /// is_assignable 1098 template<typename _Tp, typename _Up> 1099 struct is_assignable 1100 : public integral_constant<bool, 1101 __is_assignable_helper<_Tp, _Up>::value> 1102 { }; 1103 1104 template<typename _Tp, bool = is_void<_Tp>::value> 1105 struct __is_copy_assignable_impl; 1106 1107 template<typename _Tp> 1108 struct __is_copy_assignable_impl<_Tp, true> 1109 : public false_type { }; 1110 1111 template<typename _Tp> 1112 struct __is_copy_assignable_impl<_Tp, false> 1113 : public is_assignable<_Tp&, const _Tp&> 1114 { }; 1115 1116 /// is_copy_assignable 1117 template<typename _Tp> 1118 struct is_copy_assignable 1119 : public __is_copy_assignable_impl<_Tp> 1120 { }; 1121 1122 template<typename _Tp, bool = is_void<_Tp>::value> 1123 struct __is_move_assignable_impl; 1124 1125 template<typename _Tp> 1126 struct __is_move_assignable_impl<_Tp, true> 1127 : public false_type { }; 1128 1129 template<typename _Tp> 1130 struct __is_move_assignable_impl<_Tp, false> 1131 : public is_assignable<_Tp&, _Tp&&> 1132 { }; 1133 1134 /// is_move_assignable 1135 template<typename _Tp> 1136 struct is_move_assignable 1137 : public __is_move_assignable_impl<_Tp> 1138 { }; 1139 1140 template<typename _Tp, typename _Up> 1141 struct __is_nt_assignable_impl 1142 : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())> 1143 { }; 1144 1145 /// is_nothrow_assignable 1146 template<typename _Tp, typename _Up> 1147 struct is_nothrow_assignable 1148 : public __and_<is_assignable<_Tp, _Up>, 1149 __is_nt_assignable_impl<_Tp, _Up>>::type 1150 { }; 1151 1152 template<typename _Tp, bool = is_void<_Tp>::value> 1153 struct __is_nt_copy_assignable_impl; 1154 1155 template<typename _Tp> 1156 struct __is_nt_copy_assignable_impl<_Tp, true> 1157 : public false_type { }; 1158 1159 template<typename _Tp> 1160 struct __is_nt_copy_assignable_impl<_Tp, false> 1161 : public is_nothrow_assignable<_Tp&, const _Tp&> 1162 { }; 1163 1164 /// is_nothrow_copy_assignable 1165 template<typename _Tp> 1166 struct is_nothrow_copy_assignable 1167 : public __is_nt_copy_assignable_impl<_Tp> 1168 { }; 1169 1170 template<typename _Tp, bool = is_void<_Tp>::value> 1171 struct __is_nt_move_assignable_impl; 1172 1173 template<typename _Tp> 1174 struct __is_nt_move_assignable_impl<_Tp, true> 1175 : public false_type { }; 1176 1177 template<typename _Tp> 1178 struct __is_nt_move_assignable_impl<_Tp, false> 1179 : public is_nothrow_assignable<_Tp&, _Tp&&> 1180 { }; 1181 1182 /// is_nothrow_move_assignable 1183 template<typename _Tp> 1184 struct is_nothrow_move_assignable 1185 : public __is_nt_move_assignable_impl<_Tp> 1186 { }; 1187 1188 /// is_trivially_constructible (still unimplemented) 1189 1190 /// is_trivially_default_constructible (still unimplemented) 1191 1192 /// is_trivially_copy_constructible (still unimplemented) 1193 1194 /// is_trivially_move_constructible (still unimplemented) 1195 1196 /// is_trivially_assignable (still unimplemented) 1197 1198 /// is_trivially_copy_assignable (still unimplemented) 1199 1200 /// is_trivially_move_assignable (still unimplemented) 1201 1202 /// is_trivially_destructible 1203 template<typename _Tp> 1204 struct is_trivially_destructible 1205 : public __and_<is_destructible<_Tp>, integral_constant<bool, 1206 __has_trivial_destructor(_Tp)>>::type 1207 { }; 1208 1209 /// has_trivial_default_constructor (temporary legacy) 1210 template<typename _Tp> 1211 struct has_trivial_default_constructor 1212 : public integral_constant<bool, __has_trivial_constructor(_Tp)> 1213 { }; 1214 1215 /// has_trivial_copy_constructor (temporary legacy) 1216 template<typename _Tp> 1217 struct has_trivial_copy_constructor 1218 : public integral_constant<bool, __has_trivial_copy(_Tp)> 1219 { }; 1220 1221 /// has_trivial_copy_assign (temporary legacy) 1222 template<typename _Tp> 1223 struct has_trivial_copy_assign 1224 : public integral_constant<bool, __has_trivial_assign(_Tp)> 1225 { }; 1226 1227 /// has_virtual_destructor 1228 template<typename _Tp> 1229 struct has_virtual_destructor 1230 : public integral_constant<bool, __has_virtual_destructor(_Tp)> 1231 { }; 1232 1233 1234 // type property queries. 1235 1236 /// alignment_of 1237 template<typename _Tp> 1238 struct alignment_of 1239 : public integral_constant<std::size_t, __alignof__(_Tp)> { }; 1240 1241 /// rank 1242 template<typename> 1243 struct rank 1244 : public integral_constant<std::size_t, 0> { }; 1245 1246 template<typename _Tp, std::size_t _Size> 1247 struct rank<_Tp[_Size]> 1248 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1249 1250 template<typename _Tp> 1251 struct rank<_Tp[]> 1252 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1253 1254 /// extent 1255 template<typename, unsigned _Uint> 1256 struct extent 1257 : public integral_constant<std::size_t, 0> { }; 1258 1259 template<typename _Tp, unsigned _Uint, std::size_t _Size> 1260 struct extent<_Tp[_Size], _Uint> 1261 : public integral_constant<std::size_t, 1262 _Uint == 0 ? _Size : extent<_Tp, 1263 _Uint - 1>::value> 1264 { }; 1265 1266 template<typename _Tp, unsigned _Uint> 1267 struct extent<_Tp[], _Uint> 1268 : public integral_constant<std::size_t, 1269 _Uint == 0 ? 0 : extent<_Tp, 1270 _Uint - 1>::value> 1271 { }; 1272 1273 1274 // Type relations. 1275 1276 /// is_same 1277 template<typename, typename> 1278 struct is_same 1279 : public false_type { }; 1280 1281 template<typename _Tp> 1282 struct is_same<_Tp, _Tp> 1283 : public true_type { }; 1284 1285 /// is_base_of 1286 template<typename _Base, typename _Derived> 1287 struct is_base_of 1288 : public integral_constant<bool, __is_base_of(_Base, _Derived)> 1289 { }; 1290 1291 template<typename _From, typename _To, 1292 bool = __or_<is_void<_From>, is_function<_To>, 1293 is_array<_To>>::value> 1294 struct __is_convertible_helper 1295 { static constexpr bool value = is_void<_To>::value; }; 1296 1297 template<typename _From, typename _To> 1298 class __is_convertible_helper<_From, _To, false> 1299 : public __sfinae_types 1300 { 1301 template<typename _To1> 1302 static void __test_aux(_To1); 1303 1304 template<typename _From1, typename _To1> 1305 static decltype(__test_aux<_To1>(std::declval<_From1>()), __one()) 1306 __test(int); 1307 1308 template<typename, typename> 1309 static __two __test(...); 1310 1311 public: 1312 static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1; 1313 }; 1314 1315 /// is_convertible 1316 template<typename _From, typename _To> 1317 struct is_convertible 1318 : public integral_constant<bool, 1319 __is_convertible_helper<_From, _To>::value> 1320 { }; 1321 1322 1323 // Const-volatile modifications. 1324 1325 /// remove_const 1326 template<typename _Tp> 1327 struct remove_const 1328 { typedef _Tp type; }; 1329 1330 template<typename _Tp> 1331 struct remove_const<_Tp const> 1332 { typedef _Tp type; }; 1333 1334 /// remove_volatile 1335 template<typename _Tp> 1336 struct remove_volatile 1337 { typedef _Tp type; }; 1338 1339 template<typename _Tp> 1340 struct remove_volatile<_Tp volatile> 1341 { typedef _Tp type; }; 1342 1343 /// remove_cv 1344 template<typename _Tp> 1345 struct remove_cv 1346 { 1347 typedef typename 1348 remove_const<typename remove_volatile<_Tp>::type>::type type; 1349 }; 1350 1351 /// add_const 1352 template<typename _Tp> 1353 struct add_const 1354 { typedef _Tp const type; }; 1355 1356 /// add_volatile 1357 template<typename _Tp> 1358 struct add_volatile 1359 { typedef _Tp volatile type; }; 1360 1361 /// add_cv 1362 template<typename _Tp> 1363 struct add_cv 1364 { 1365 typedef typename 1366 add_const<typename add_volatile<_Tp>::type>::type type; 1367 }; 1368 1369 1370 // Reference transformations. 1371 1372 /// remove_reference 1373 template<typename _Tp> 1374 struct remove_reference 1375 { typedef _Tp type; }; 1376 1377 template<typename _Tp> 1378 struct remove_reference<_Tp&> 1379 { typedef _Tp type; }; 1380 1381 template<typename _Tp> 1382 struct remove_reference<_Tp&&> 1383 { typedef _Tp type; }; 1384 1385 template<typename _Tp, 1386 bool = __and_<__not_<is_reference<_Tp>>, 1387 __not_<is_void<_Tp>>>::value, 1388 bool = is_rvalue_reference<_Tp>::value> 1389 struct __add_lvalue_reference_helper 1390 { typedef _Tp type; }; 1391 1392 template<typename _Tp> 1393 struct __add_lvalue_reference_helper<_Tp, true, false> 1394 { typedef _Tp& type; }; 1395 1396 template<typename _Tp> 1397 struct __add_lvalue_reference_helper<_Tp, false, true> 1398 { typedef typename remove_reference<_Tp>::type& type; }; 1399 1400 /// add_lvalue_reference 1401 template<typename _Tp> 1402 struct add_lvalue_reference 1403 : public __add_lvalue_reference_helper<_Tp> 1404 { }; 1405 1406 template<typename _Tp, 1407 bool = __and_<__not_<is_reference<_Tp>>, 1408 __not_<is_void<_Tp>>>::value> 1409 struct __add_rvalue_reference_helper 1410 { typedef _Tp type; }; 1411 1412 template<typename _Tp> 1413 struct __add_rvalue_reference_helper<_Tp, true> 1414 { typedef _Tp&& type; }; 1415 1416 /// add_rvalue_reference 1417 template<typename _Tp> 1418 struct add_rvalue_reference 1419 : public __add_rvalue_reference_helper<_Tp> 1420 { }; 1421 1422 1423 // Sign modifications. 1424 1425 // Utility for constructing identically cv-qualified types. 1426 template<typename _Unqualified, bool _IsConst, bool _IsVol> 1427 struct __cv_selector; 1428 1429 template<typename _Unqualified> 1430 struct __cv_selector<_Unqualified, false, false> 1431 { typedef _Unqualified __type; }; 1432 1433 template<typename _Unqualified> 1434 struct __cv_selector<_Unqualified, false, true> 1435 { typedef volatile _Unqualified __type; }; 1436 1437 template<typename _Unqualified> 1438 struct __cv_selector<_Unqualified, true, false> 1439 { typedef const _Unqualified __type; }; 1440 1441 template<typename _Unqualified> 1442 struct __cv_selector<_Unqualified, true, true> 1443 { typedef const volatile _Unqualified __type; }; 1444 1445 template<typename _Qualified, typename _Unqualified, 1446 bool _IsConst = is_const<_Qualified>::value, 1447 bool _IsVol = is_volatile<_Qualified>::value> 1448 class __match_cv_qualifiers 1449 { 1450 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; 1451 1452 public: 1453 typedef typename __match::__type __type; 1454 }; 1455 1456 // Utility for finding the unsigned versions of signed integral types. 1457 template<typename _Tp> 1458 struct __make_unsigned 1459 { typedef _Tp __type; }; 1460 1461 template<> 1462 struct __make_unsigned<char> 1463 { typedef unsigned char __type; }; 1464 1465 template<> 1466 struct __make_unsigned<signed char> 1467 { typedef unsigned char __type; }; 1468 1469 template<> 1470 struct __make_unsigned<short> 1471 { typedef unsigned short __type; }; 1472 1473 template<> 1474 struct __make_unsigned<int> 1475 { typedef unsigned int __type; }; 1476 1477 template<> 1478 struct __make_unsigned<long> 1479 { typedef unsigned long __type; }; 1480 1481 template<> 1482 struct __make_unsigned<long long> 1483 { typedef unsigned long long __type; }; 1484 1485 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128) 1486 template<> 1487 struct __make_unsigned<__int128> 1488 { typedef unsigned __int128 __type; }; 1489 #endif 1490 1491 // Select between integral and enum: not possible to be both. 1492 template<typename _Tp, 1493 bool _IsInt = is_integral<_Tp>::value, 1494 bool _IsEnum = is_enum<_Tp>::value> 1495 class __make_unsigned_selector; 1496 1497 template<typename _Tp> 1498 class __make_unsigned_selector<_Tp, true, false> 1499 { 1500 typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt; 1501 typedef typename __unsignedt::__type __unsigned_type; 1502 typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; 1503 1504 public: 1505 typedef typename __cv_unsigned::__type __type; 1506 }; 1507 1508 template<typename _Tp> 1509 class __make_unsigned_selector<_Tp, false, true> 1510 { 1511 // With -fshort-enums, an enum may be as small as a char. 1512 typedef unsigned char __smallest; 1513 static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); 1514 static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); 1515 static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); 1516 typedef conditional<__b2, unsigned int, unsigned long> __cond2; 1517 typedef typename __cond2::type __cond2_type; 1518 typedef conditional<__b1, unsigned short, __cond2_type> __cond1; 1519 typedef typename __cond1::type __cond1_type; 1520 1521 public: 1522 typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; 1523 }; 1524 1525 // Given an integral/enum type, return the corresponding unsigned 1526 // integer type. 1527 // Primary template. 1528 /// make_unsigned 1529 template<typename _Tp> 1530 struct make_unsigned 1531 { typedef typename __make_unsigned_selector<_Tp>::__type type; }; 1532 1533 // Integral, but don't define. 1534 template<> 1535 struct make_unsigned<bool>; 1536 1537 1538 // Utility for finding the signed versions of unsigned integral types. 1539 template<typename _Tp> 1540 struct __make_signed 1541 { typedef _Tp __type; }; 1542 1543 template<> 1544 struct __make_signed<char> 1545 { typedef signed char __type; }; 1546 1547 template<> 1548 struct __make_signed<unsigned char> 1549 { typedef signed char __type; }; 1550 1551 template<> 1552 struct __make_signed<unsigned short> 1553 { typedef signed short __type; }; 1554 1555 template<> 1556 struct __make_signed<unsigned int> 1557 { typedef signed int __type; }; 1558 1559 template<> 1560 struct __make_signed<unsigned long> 1561 { typedef signed long __type; }; 1562 1563 template<> 1564 struct __make_signed<unsigned long long> 1565 { typedef signed long long __type; }; 1566 1567 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128) 1568 template<> 1569 struct __make_signed<unsigned __int128> 1570 { typedef __int128 __type; }; 1571 #endif 1572 1573 // Select between integral and enum: not possible to be both. 1574 template<typename _Tp, 1575 bool _IsInt = is_integral<_Tp>::value, 1576 bool _IsEnum = is_enum<_Tp>::value> 1577 class __make_signed_selector; 1578 1579 template<typename _Tp> 1580 class __make_signed_selector<_Tp, true, false> 1581 { 1582 typedef __make_signed<typename remove_cv<_Tp>::type> __signedt; 1583 typedef typename __signedt::__type __signed_type; 1584 typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; 1585 1586 public: 1587 typedef typename __cv_signed::__type __type; 1588 }; 1589 1590 template<typename _Tp> 1591 class __make_signed_selector<_Tp, false, true> 1592 { 1593 // With -fshort-enums, an enum may be as small as a char. 1594 typedef signed char __smallest; 1595 static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); 1596 static const bool __b1 = sizeof(_Tp) <= sizeof(signed short); 1597 static const bool __b2 = sizeof(_Tp) <= sizeof(signed int); 1598 typedef conditional<__b2, signed int, signed long> __cond2; 1599 typedef typename __cond2::type __cond2_type; 1600 typedef conditional<__b1, signed short, __cond2_type> __cond1; 1601 typedef typename __cond1::type __cond1_type; 1602 1603 public: 1604 typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; 1605 }; 1606 1607 // Given an integral/enum type, return the corresponding signed 1608 // integer type. 1609 // Primary template. 1610 /// make_signed 1611 template<typename _Tp> 1612 struct make_signed 1613 { typedef typename __make_signed_selector<_Tp>::__type type; }; 1614 1615 // Integral, but don't define. 1616 template<> 1617 struct make_signed<bool>; 1618 1619 1620 // Array modifications. 1621 1622 /// remove_extent 1623 template<typename _Tp> 1624 struct remove_extent 1625 { typedef _Tp type; }; 1626 1627 template<typename _Tp, std::size_t _Size> 1628 struct remove_extent<_Tp[_Size]> 1629 { typedef _Tp type; }; 1630 1631 template<typename _Tp> 1632 struct remove_extent<_Tp[]> 1633 { typedef _Tp type; }; 1634 1635 /// remove_all_extents 1636 template<typename _Tp> 1637 struct remove_all_extents 1638 { typedef _Tp type; }; 1639 1640 template<typename _Tp, std::size_t _Size> 1641 struct remove_all_extents<_Tp[_Size]> 1642 { typedef typename remove_all_extents<_Tp>::type type; }; 1643 1644 template<typename _Tp> 1645 struct remove_all_extents<_Tp[]> 1646 { typedef typename remove_all_extents<_Tp>::type type; }; 1647 1648 1649 // Pointer modifications. 1650 1651 template<typename _Tp, typename> 1652 struct __remove_pointer_helper 1653 { typedef _Tp type; }; 1654 1655 template<typename _Tp, typename _Up> 1656 struct __remove_pointer_helper<_Tp, _Up*> 1657 { typedef _Up type; }; 1658 1659 /// remove_pointer 1660 template<typename _Tp> 1661 struct remove_pointer 1662 : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> 1663 { }; 1664 1665 /// add_pointer 1666 template<typename _Tp> 1667 struct add_pointer 1668 { typedef typename remove_reference<_Tp>::type* type; }; 1669 1670 1671 template<std::size_t _Len> 1672 struct __aligned_storage_msa 1673 { 1674 union __type 1675 { 1676 unsigned char __data[_Len]; 1677 struct __attribute__((__aligned__)) { } __align; 1678 }; 1679 }; 1680 1681 /** 1682 * @brief Alignment type. 1683 * 1684 * The value of _Align is a default-alignment which shall be the 1685 * most stringent alignment requirement for any C++ object type 1686 * whose size is no greater than _Len (3.9). The member typedef 1687 * type shall be a POD type suitable for use as uninitialized 1688 * storage for any object whose size is at most _Len and whose 1689 * alignment is a divisor of _Align. 1690 */ 1691 template<std::size_t _Len, std::size_t _Align = 1692 __alignof__(typename __aligned_storage_msa<_Len>::__type)> 1693 struct aligned_storage 1694 { 1695 union type 1696 { 1697 unsigned char __data[_Len]; 1698 struct __attribute__((__aligned__((_Align)))) { } __align; 1699 }; 1700 }; 1701 1702 1703 // Decay trait for arrays and functions, used for perfect forwarding 1704 // in make_pair, make_tuple, etc. 1705 template<typename _Up, 1706 bool _IsArray = is_array<_Up>::value, 1707 bool _IsFunction = is_function<_Up>::value> 1708 struct __decay_selector; 1709 1710 // NB: DR 705. 1711 template<typename _Up> 1712 struct __decay_selector<_Up, false, false> 1713 { typedef typename remove_cv<_Up>::type __type; }; 1714 1715 template<typename _Up> 1716 struct __decay_selector<_Up, true, false> 1717 { typedef typename remove_extent<_Up>::type* __type; }; 1718 1719 template<typename _Up> 1720 struct __decay_selector<_Up, false, true> 1721 { typedef typename add_pointer<_Up>::type __type; }; 1722 1723 /// decay 1724 template<typename _Tp> 1725 class decay 1726 { 1727 typedef typename remove_reference<_Tp>::type __remove_type; 1728 1729 public: 1730 typedef typename __decay_selector<__remove_type>::__type type; 1731 }; 1732 1733 template<typename _Tp> 1734 class reference_wrapper; 1735 1736 // Helper which adds a reference to a type when given a reference_wrapper 1737 template<typename _Tp> 1738 struct __strip_reference_wrapper 1739 { 1740 typedef _Tp __type; 1741 }; 1742 1743 template<typename _Tp> 1744 struct __strip_reference_wrapper<reference_wrapper<_Tp> > 1745 { 1746 typedef _Tp& __type; 1747 }; 1748 1749 template<typename _Tp> 1750 struct __strip_reference_wrapper<const reference_wrapper<_Tp> > 1751 { 1752 typedef _Tp& __type; 1753 }; 1754 1755 template<typename _Tp> 1756 struct __decay_and_strip 1757 { 1758 typedef typename __strip_reference_wrapper< 1759 typename decay<_Tp>::type>::__type __type; 1760 }; 1761 1762 1763 // Primary template. 1764 /// Define a member typedef @c type only if a boolean constant is true. 1765 template<bool, typename _Tp = void> 1766 struct enable_if 1767 { }; 1768 1769 // Partial specialization for true. 1770 template<typename _Tp> 1771 struct enable_if<true, _Tp> 1772 { typedef _Tp type; }; 1773 1774 template<typename... _Cond> 1775 using _Require = typename enable_if<__and_<_Cond...>::value>::type; 1776 1777 // Primary template. 1778 /// Define a member typedef @c type to one of two argument types. 1779 template<bool _Cond, typename _Iftrue, typename _Iffalse> 1780 struct conditional 1781 { typedef _Iftrue type; }; 1782 1783 // Partial specialization for false. 1784 template<typename _Iftrue, typename _Iffalse> 1785 struct conditional<false, _Iftrue, _Iffalse> 1786 { typedef _Iffalse type; }; 1787 1788 /// common_type 1789 template<typename... _Tp> 1790 struct common_type; 1791 1792 // Sfinae-friendly common_type implementation: 1793 1794 struct __do_common_type_impl 1795 { 1796 template<typename _Tp, typename _Up> 1797 static __success_type<typename decay<decltype 1798 (true ? std::declval<_Tp>() 1799 : std::declval<_Up>())>::type> _S_test(int); 1800 1801 template<typename, typename> 1802 static __failure_type _S_test(...); 1803 }; 1804 1805 template<typename _Tp, typename _Up> 1806 struct __common_type_impl 1807 : private __do_common_type_impl 1808 { 1809 typedef typename decay<decltype(_S_test<_Tp, _Up>(0))>::type type; 1810 }; 1811 1812 struct __do_member_type_wrapper 1813 { 1814 template<typename _Tp> 1815 static __success_type<typename _Tp::type> _S_test(int); 1816 1817 template<typename> 1818 static __failure_type _S_test(...); 1819 }; 1820 1821 template<typename _Tp> 1822 struct __member_type_wrapper 1823 : private __do_member_type_wrapper 1824 { 1825 typedef decltype(_S_test<_Tp>(0)) type; 1826 }; 1827 1828 template<typename _CTp, typename... _Args> 1829 struct __expanded_common_type_wrapper 1830 { 1831 typedef common_type<typename _CTp::type, _Args...> type; 1832 }; 1833 1834 template<typename... _Args> 1835 struct __expanded_common_type_wrapper<__failure_type, _Args...> 1836 { typedef __failure_type type; }; 1837 1838 template<typename _Tp> 1839 struct common_type<_Tp> 1840 { typedef typename decay<_Tp>::type type; }; 1841 1842 template<typename _Tp, typename _Up> 1843 struct common_type<_Tp, _Up> 1844 : public __common_type_impl<_Tp, _Up>::type 1845 { }; 1846 1847 template<typename _Tp, typename _Up, typename... _Vp> 1848 struct common_type<_Tp, _Up, _Vp...> 1849 : public __expanded_common_type_wrapper<typename __member_type_wrapper< 1850 common_type<_Tp, _Up>>::type, _Vp...>::type 1851 { }; 1852 1853 /// The underlying type of an enum. 1854 template<typename _Tp> 1855 struct underlying_type 1856 { 1857 typedef __underlying_type(_Tp) type; 1858 }; 1859 1860 template<typename _Tp> 1861 struct __declval_protector 1862 { 1863 static const bool __stop = false; 1864 static typename add_rvalue_reference<_Tp>::type __delegate(); 1865 }; 1866 1867 template<typename _Tp> 1868 inline typename add_rvalue_reference<_Tp>::type 1869 declval() noexcept 1870 { 1871 static_assert(__declval_protector<_Tp>::__stop, 1872 "declval() must not be used!"); 1873 return __declval_protector<_Tp>::__delegate(); 1874 } 1875 1876 /// result_of 1877 template<typename _Signature> 1878 class result_of; 1879 1880 // Sfinae-friendly result_of implementation: 1881 1882 // [func.require] paragraph 1 bullet 1: 1883 struct __result_of_memfun_ref_impl 1884 { 1885 template<typename _Fp, typename _Tp1, typename... _Args> 1886 static __success_type<decltype( 1887 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...) 1888 )> _S_test(int); 1889 1890 template<typename...> 1891 static __failure_type _S_test(...); 1892 }; 1893 1894 template<typename _MemPtr, typename _Arg, typename... _Args> 1895 struct __result_of_memfun_ref 1896 : private __result_of_memfun_ref_impl 1897 { 1898 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 1899 }; 1900 1901 // [func.require] paragraph 1 bullet 2: 1902 struct __result_of_memfun_deref_impl 1903 { 1904 template<typename _Fp, typename _Tp1, typename... _Args> 1905 static __success_type<decltype( 1906 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...) 1907 )> _S_test(int); 1908 1909 template<typename...> 1910 static __failure_type _S_test(...); 1911 }; 1912 1913 template<typename _MemPtr, typename _Arg, typename... _Args> 1914 struct __result_of_memfun_deref 1915 : private __result_of_memfun_deref_impl 1916 { 1917 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 1918 }; 1919 1920 // [func.require] paragraph 1 bullet 3: 1921 struct __result_of_memobj_ref_impl 1922 { 1923 template<typename _Fp, typename _Tp1> 1924 static __success_type<decltype( 1925 std::declval<_Tp1>().*std::declval<_Fp>() 1926 )> _S_test(int); 1927 1928 template<typename, typename> 1929 static __failure_type _S_test(...); 1930 }; 1931 1932 template<typename _MemPtr, typename _Arg> 1933 struct __result_of_memobj_ref 1934 : private __result_of_memobj_ref_impl 1935 { 1936 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 1937 }; 1938 1939 // [func.require] paragraph 1 bullet 4: 1940 struct __result_of_memobj_deref_impl 1941 { 1942 template<typename _Fp, typename _Tp1> 1943 static __success_type<decltype( 1944 (*std::declval<_Tp1>()).*std::declval<_Fp>() 1945 )> _S_test(int); 1946 1947 template<typename, typename> 1948 static __failure_type _S_test(...); 1949 }; 1950 1951 template<typename _MemPtr, typename _Arg> 1952 struct __result_of_memobj_deref 1953 : private __result_of_memobj_deref_impl 1954 { 1955 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 1956 }; 1957 1958 template<typename _MemPtr, typename _Arg> 1959 struct __result_of_memobj; 1960 1961 template<typename _Res, typename _Class, typename _Arg> 1962 struct __result_of_memobj<_Res _Class::*, _Arg> 1963 { 1964 typedef typename remove_cv<typename remove_reference< 1965 _Arg>::type>::type _Argval; 1966 typedef _Res _Class::* _MemPtr; 1967 typedef typename conditional<__or_<is_same<_Argval, _Class>, 1968 is_base_of<_Class, _Argval>>::value, 1969 __result_of_memobj_ref<_MemPtr, _Arg>, 1970 __result_of_memobj_deref<_MemPtr, _Arg> 1971 >::type::type type; 1972 }; 1973 1974 template<typename _MemPtr, typename _Arg, typename... _Args> 1975 struct __result_of_memfun; 1976 1977 template<typename _Res, typename _Class, typename _Arg, typename... _Args> 1978 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> 1979 { 1980 typedef typename remove_cv<typename remove_reference< 1981 _Arg>::type>::type _Argval; 1982 typedef _Res _Class::* _MemPtr; 1983 typedef typename conditional<__or_<is_same<_Argval, _Class>, 1984 is_base_of<_Class, _Argval>>::value, 1985 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, 1986 __result_of_memfun_deref<_MemPtr, _Arg, _Args...> 1987 >::type::type type; 1988 }; 1989 1990 template<bool, bool, typename _Functor, typename... _ArgTypes> 1991 struct __result_of_impl 1992 { 1993 typedef __failure_type type; 1994 }; 1995 1996 template<typename _MemPtr, typename _Arg> 1997 struct __result_of_impl<true, false, _MemPtr, _Arg> 1998 : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg> 1999 { }; 2000 2001 template<typename _MemPtr, typename _Arg, typename... _Args> 2002 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...> 2003 : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...> 2004 { }; 2005 2006 // [func.require] paragraph 1 bullet 5: 2007 struct __result_of_other_impl 2008 { 2009 template<typename _Fn, typename... _Args> 2010 static __success_type<decltype( 2011 std::declval<_Fn>()(std::declval<_Args>()...) 2012 )> _S_test(int); 2013 2014 template<typename...> 2015 static __failure_type _S_test(...); 2016 }; 2017 2018 template<typename _Functor, typename... _ArgTypes> 2019 struct __result_of_impl<false, false, _Functor, _ArgTypes...> 2020 : private __result_of_other_impl 2021 { 2022 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; 2023 }; 2024 2025 template<typename _Functor, typename... _ArgTypes> 2026 struct result_of<_Functor(_ArgTypes...)> 2027 : public __result_of_impl< 2028 is_member_object_pointer< 2029 typename remove_reference<_Functor>::type 2030 >::value, 2031 is_member_function_pointer< 2032 typename remove_reference<_Functor>::type 2033 >::value, 2034 _Functor, _ArgTypes... 2035 >::type 2036 { }; 2037 2038 /// @} group metaprogramming 2039 2040 /** 2041 * Use SFINAE to determine if the type _Tp has a publicly-accessible 2042 * member type _NTYPE. 2043 */ 2044 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \ 2045 template<typename _Tp> \ 2046 class __has_##_NTYPE##_helper \ 2047 : __sfinae_types \ 2048 { \ 2049 template<typename _Up> \ 2050 struct _Wrap_type \ 2051 { }; \ 2052 \ 2053 template<typename _Up> \ 2054 static __one __test(_Wrap_type<typename _Up::_NTYPE>*); \ 2055 \ 2056 template<typename _Up> \ 2057 static __two __test(...); \ 2058 \ 2059 public: \ 2060 static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; \ 2061 }; \ 2062 \ 2063 template<typename _Tp> \ 2064 struct __has_##_NTYPE \ 2065 : integral_constant<bool, __has_##_NTYPE##_helper \ 2066 <typename remove_cv<_Tp>::type>::value> \ 2067 { }; 2068 2069 _GLIBCXX_END_NAMESPACE_VERSION 2070 } // namespace std 2071 2072 #endif // C++11 2073 2074 #endif // _GLIBCXX_TYPE_TRAITS 2075