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