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