Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/c++/15/ext/throw_allocator.h
1 // -*- C++ -*- 2 3 // Copyright (C) 2005-2025 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 terms 7 // of the GNU General Public License as published by the Free Software 8 // Foundation; either version 3, or (at your option) any later 9 // version. 10 11 // This library is distributed in the hope that it will be useful, but 12 // WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 // 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 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. 26 27 // Permission to use, copy, modify, sell, and distribute this software 28 // is hereby granted without fee, provided that the above copyright 29 // notice appears in all copies, and that both that copyright notice 30 // and this permission notice appear in supporting documentation. None 31 // of the above authors, nor IBM Haifa Research Laboratories, make any 32 // representation about the suitability of this software for any 33 // purpose. It is provided "as is" without express or implied 34 // warranty. 35 36 /** @file ext/throw_allocator.h 37 * This file is a GNU extension to the Standard C++ Library. 38 * 39 * Contains two exception-generating types (throw_value, throw_allocator) 40 * intended to be used as value and allocator types while testing 41 * exception safety in templatized containers and algorithms. The 42 * allocator has additional log and debug features. The exception 43 * generated is of type forced_exception_error. 44 */ 45 46 #ifndef _THROW_ALLOCATOR_H 47 #define _THROW_ALLOCATOR_H 1 48 49 #include <bits/requires_hosted.h> // GNU extensions are currently omitted 50 51 #include <cmath> 52 #include <ctime> 53 #include <map> 54 #include <string> 55 #include <ostream> 56 #include <stdexcept> 57 #include <utility> 58 #include <bits/functexcept.h> 59 #include <bits/move.h> 60 #if __cplusplus >= 201103L 61 # include <functional> 62 # include <random> 63 #else 64 # include <tr1/functional> 65 # include <tr1/random> 66 #endif 67 #include <ext/alloc_traits.h> 68 69 #if !__has_builtin(__builtin_sprintf) 70 # include <cstdio> 71 #endif 72 73 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 74 { 75 _GLIBCXX_BEGIN_NAMESPACE_VERSION 76 77 /** 78 * @brief Thrown by utilities for testing exception safety. 79 * @ingroup exceptions 80 */ 81 struct forced_error : public std::exception 82 { }; 83 84 // Substitute for forced_error object when -fno-exceptions. 85 inline void 86 __throw_forced_error() 87 { _GLIBCXX_THROW_OR_ABORT(forced_error()); } 88 89 /** 90 * @brief Base class for checking address and label information 91 * about allocations. Create a std::map between the allocated 92 * address (void*) and a datum for annotations, which are a pair of 93 * numbers corresponding to label and allocated size. 94 */ 95 struct annotate_base 96 { 97 private: 98 typedef std::pair<size_t, size_t> data_type; 99 typedef std::map<void*, data_type> map_alloc_type; 100 typedef map_alloc_type::value_type entry_type; 101 typedef map_alloc_type::const_iterator const_iterator; 102 typedef map_alloc_type::const_reference const_reference; 103 #if __cplusplus >= 201103L 104 typedef std::map<void*, size_t> map_construct_type; 105 #endif 106 107 public: 108 annotate_base() 109 { 110 label(); 111 map_alloc(); 112 } 113 114 static void 115 set_label(size_t l) 116 { label() = l; } 117 118 static size_t 119 get_label() 120 { return label(); } 121 122 void 123 insert(void* p, size_t size) 124 { 125 entry_type entry = make_entry(p, size); 126 if (!p) 127 { 128 std::string error("annotate_base::insert null insert!\n"); 129 log_to_string(error, entry); 130 std::__throw_logic_error(error.c_str()); 131 } 132 133 std::pair<map_alloc_type::iterator, bool> inserted 134 = map_alloc().insert(entry); 135 if (!inserted.second) 136 { 137 std::string error("annotate_base::insert double insert!\n"); 138 log_to_string(error, entry); 139 log_to_string(error, *inserted.first); 140 std::__throw_logic_error(error.c_str()); 141 } 142 } 143 144 void 145 erase(void* p, size_t size) 146 { map_alloc().erase(check_allocated(p, size)); } 147 148 #if __cplusplus >= 201103L 149 void 150 insert_construct(void* p) 151 { 152 if (!p) 153 { 154 std::string error("annotate_base::insert_construct null!\n"); 155 std::__throw_logic_error(error.c_str()); 156 } 157 158 auto inserted = map_construct().insert(std::make_pair(p, get_label())); 159 if (!inserted.second) 160 { 161 std::string error("annotate_base::insert_construct double insert!\n"); 162 log_to_string(error, std::make_pair(p, get_label())); 163 log_to_string(error, *inserted.first); 164 std::__throw_logic_error(error.c_str()); 165 } 166 } 167 168 void 169 erase_construct(void* p) 170 { map_construct().erase(check_constructed(p)); } 171 #endif 172 173 // See if a particular address and allocation size has been saved. 174 inline map_alloc_type::iterator 175 check_allocated(void* p, size_t size) 176 { 177 map_alloc_type::iterator found = map_alloc().find(p); 178 if (found == map_alloc().end()) 179 { 180 std::string error("annotate_base::check_allocated by value " 181 "null erase!\n"); 182 log_to_string(error, make_entry(p, size)); 183 std::__throw_logic_error(error.c_str()); 184 } 185 186 if (found->second.second != size) 187 { 188 std::string error("annotate_base::check_allocated by value " 189 "wrong-size erase!\n"); 190 log_to_string(error, make_entry(p, size)); 191 log_to_string(error, *found); 192 std::__throw_logic_error(error.c_str()); 193 } 194 195 return found; 196 } 197 198 // See if a given label has been allocated. 199 inline void 200 check(size_t label) 201 { 202 std::string found; 203 { 204 const_iterator beg = map_alloc().begin(); 205 const_iterator end = map_alloc().end(); 206 while (beg != end) 207 { 208 if (beg->second.first == label) 209 log_to_string(found, *beg); 210 ++beg; 211 } 212 } 213 214 #if __cplusplus >= 201103L 215 { 216 auto beg = map_construct().begin(); 217 auto end = map_construct().end(); 218 while (beg != end) 219 { 220 if (beg->second == label) 221 log_to_string(found, *beg); 222 ++beg; 223 } 224 } 225 #endif 226 227 if (!found.empty()) 228 { 229 std::string error("annotate_base::check by label\n"); 230 error += found; 231 std::__throw_logic_error(error.c_str()); 232 } 233 } 234 235 // See if there is anything left allocated or constructed. 236 inline static void 237 check() 238 { 239 std::string found; 240 { 241 const_iterator beg = map_alloc().begin(); 242 const_iterator end = map_alloc().end(); 243 while (beg != end) 244 { 245 log_to_string(found, *beg); 246 ++beg; 247 } 248 } 249 250 #if __cplusplus >= 201103L 251 { 252 auto beg = map_construct().begin(); 253 auto end = map_construct().end(); 254 while (beg != end) 255 { 256 log_to_string(found, *beg); 257 ++beg; 258 } 259 } 260 #endif 261 262 if (!found.empty()) 263 { 264 std::string error("annotate_base::check \n"); 265 error += found; 266 std::__throw_logic_error(error.c_str()); 267 } 268 } 269 270 #if __cplusplus >= 201103L 271 inline map_construct_type::iterator 272 check_constructed(void* p) 273 { 274 auto found = map_construct().find(p); 275 if (found == map_construct().end()) 276 { 277 std::string error("annotate_base::check_constructed not " 278 "constructed!\n"); 279 log_to_string(error, std::make_pair(p, get_label())); 280 std::__throw_logic_error(error.c_str()); 281 } 282 283 return found; 284 } 285 286 inline void 287 check_constructed(size_t label) 288 { 289 auto beg = map_construct().begin(); 290 auto end = map_construct().end(); 291 std::string found; 292 while (beg != end) 293 { 294 if (beg->second == label) 295 log_to_string(found, *beg); 296 ++beg; 297 } 298 299 if (!found.empty()) 300 { 301 std::string error("annotate_base::check_constructed by label\n"); 302 error += found; 303 std::__throw_logic_error(error.c_str()); 304 } 305 } 306 #endif 307 308 private: 309 friend std::ostream& 310 operator<<(std::ostream&, const annotate_base&); 311 312 entry_type 313 make_entry(void* p, size_t size) 314 { return std::make_pair(p, data_type(get_label(), size)); } 315 316 static void 317 log_to_string(std::string& s, const_reference ref) 318 { 319 #if ! __has_builtin(__builtin_sprintf) 320 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf; 321 #endif 322 323 char buf[40]; 324 const char tab('\t'); 325 s += "label: "; 326 unsigned long l = static_cast<unsigned long>(ref.second.first); 327 __builtin_sprintf(buf, "%lu", l); 328 s += buf; 329 s += tab; 330 s += "size: "; 331 l = static_cast<unsigned long>(ref.second.second); 332 __builtin_sprintf(buf, "%lu", l); 333 s += buf; 334 s += tab; 335 s += "address: "; 336 __builtin_sprintf(buf, "%p", ref.first); 337 s += buf; 338 s += '\n'; 339 } 340 341 #if __cplusplus >= 201103L 342 static void 343 log_to_string(std::string& s, const std::pair<const void*, size_t>& ref) 344 { 345 #if ! __has_builtin(__builtin_sprintf) 346 auto __builtin_sprintf = &std::sprintf; 347 #endif 348 349 char buf[40]; 350 const char tab('\t'); 351 s += "label: "; 352 unsigned long l = static_cast<unsigned long>(ref.second); 353 __builtin_sprintf(buf, "%lu", l); 354 s += buf; 355 s += tab; 356 s += "address: "; 357 __builtin_sprintf(buf, "%p", ref.first); 358 s += buf; 359 s += '\n'; 360 } 361 #endif 362 363 static size_t& 364 label() 365 { 366 static size_t _S_label(std::numeric_limits<size_t>::max()); 367 return _S_label; 368 } 369 370 static map_alloc_type& 371 map_alloc() 372 { 373 static map_alloc_type _S_map; 374 return _S_map; 375 } 376 377 #if __cplusplus >= 201103L 378 static map_construct_type& 379 map_construct() 380 { 381 static map_construct_type _S_map; 382 return _S_map; 383 } 384 #endif 385 }; 386 387 inline std::ostream& 388 operator<<(std::ostream& os, const annotate_base& __b) 389 { 390 std::string error; 391 typedef annotate_base base_type; 392 { 393 base_type::const_iterator beg = __b.map_alloc().begin(); 394 base_type::const_iterator end = __b.map_alloc().end(); 395 for (; beg != end; ++beg) 396 __b.log_to_string(error, *beg); 397 } 398 #if __cplusplus >= 201103L 399 { 400 auto beg = __b.map_construct().begin(); 401 auto end = __b.map_construct().end(); 402 for (; beg != end; ++beg) 403 __b.log_to_string(error, *beg); 404 } 405 #endif 406 return os << error; 407 } 408 409 410 /** 411 * @brief Base struct for condition policy. 412 * 413 * Requires a public member function with the signature 414 * void throw_conditionally() 415 */ 416 struct condition_base 417 { 418 #if __cplusplus >= 201103L 419 condition_base() = default; 420 condition_base(const condition_base&) = default; 421 condition_base& operator=(const condition_base&) = default; 422 #endif 423 virtual ~condition_base() { }; 424 }; 425 426 427 /** 428 * @brief Base class for incremental control and throw. 429 */ 430 struct limit_condition : public condition_base 431 { 432 // Scope-level adjustor objects: set limit for throw at the 433 // beginning of a scope block, and restores to previous limit when 434 // object is destroyed on exiting the block. 435 struct adjustor_base 436 { 437 private: 438 const size_t _M_orig; 439 440 public: 441 adjustor_base() : _M_orig(limit()) { } 442 443 virtual 444 ~adjustor_base() { set_limit(_M_orig); } 445 }; 446 447 /// Never enter the condition. 448 struct never_adjustor : public adjustor_base 449 { 450 never_adjustor() { set_limit(std::numeric_limits<size_t>::max()); } 451 }; 452 453 /// Always enter the condition. 454 struct always_adjustor : public adjustor_base 455 { 456 always_adjustor() { set_limit(count()); } 457 }; 458 459 /// Enter the nth condition. 460 struct limit_adjustor : public adjustor_base 461 { 462 limit_adjustor(const size_t __l) { set_limit(__l); } 463 }; 464 465 // Increment _S_count every time called. 466 // If _S_count matches the limit count, throw. 467 static void 468 throw_conditionally() 469 { 470 if (count() == limit()) 471 __throw_forced_error(); 472 ++count(); 473 } 474 475 static size_t& 476 count() 477 { 478 static size_t _S_count(0); 479 return _S_count; 480 } 481 482 static size_t& 483 limit() 484 { 485 static size_t _S_limit(std::numeric_limits<size_t>::max()); 486 return _S_limit; 487 } 488 489 // Zero the throw counter, set limit to argument. 490 static void 491 set_limit(const size_t __l) 492 { 493 limit() = __l; 494 count() = 0; 495 } 496 }; 497 498 /** 499 * @brief Base class for random probability control and throw. 500 */ 501 struct random_condition : public condition_base 502 { 503 // Scope-level adjustor objects: set probability for throw at the 504 // beginning of a scope block, and restores to previous 505 // probability when object is destroyed on exiting the block. 506 struct adjustor_base 507 { 508 private: 509 const double _M_orig; 510 511 public: 512 adjustor_base() : _M_orig(probability()) { } 513 514 virtual ~adjustor_base() 515 { set_probability(_M_orig); } 516 }; 517 518 /// Group condition. 519 struct group_adjustor : public adjustor_base 520 { 521 group_adjustor(size_t size) 522 { set_probability(1 - std::pow(double(1 - probability()), 523 double(0.5 / (size + 1)))); 524 } 525 }; 526 527 /// Never enter the condition. 528 struct never_adjustor : public adjustor_base 529 { 530 never_adjustor() { set_probability(0); } 531 }; 532 533 /// Always enter the condition. 534 struct always_adjustor : public adjustor_base 535 { 536 always_adjustor() { set_probability(1); } 537 }; 538 539 random_condition() 540 { 541 probability(); 542 engine(); 543 } 544 545 static void 546 set_probability(double __p) 547 { probability() = __p; } 548 549 static void 550 throw_conditionally() 551 { 552 if (generate() < probability()) 553 __throw_forced_error(); 554 } 555 556 void 557 seed(unsigned long __s) 558 { engine().seed(__s); } 559 560 private: 561 #if __cplusplus >= 201103L 562 typedef std::uniform_real_distribution<double> distribution_type; 563 typedef std::mt19937 engine_type; 564 #else 565 typedef std::tr1::uniform_real<double> distribution_type; 566 typedef std::tr1::mt19937 engine_type; 567 #endif 568 569 static double 570 generate() 571 { 572 #if __cplusplus >= 201103L 573 const distribution_type distribution(0, 1); 574 static auto generator = std::bind(distribution, engine()); 575 #else 576 // Use variate_generator to get normalized results. 577 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t; 578 distribution_type distribution(0, 1); 579 static gen_t generator(engine(), distribution); 580 #endif 581 582 #if ! __has_builtin(__builtin_sprintf) 583 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf; 584 #endif 585 586 double random = generator(); 587 if (random < distribution.min() || random > distribution.max()) 588 { 589 std::string __s("random_condition::generate"); 590 __s += "\n"; 591 __s += "random number generated is: "; 592 char buf[40]; 593 __builtin_sprintf(buf, "%f", random); 594 __s += buf; 595 std::__throw_out_of_range(__s.c_str()); 596 } 597 598 return random; 599 } 600 601 static double& 602 probability() 603 { 604 static double _S_p; 605 return _S_p; 606 } 607 608 static engine_type& 609 engine() 610 { 611 static engine_type _S_e; 612 return _S_e; 613 } 614 }; 615 616 /** 617 * @brief Class with exception generation control. Intended to be 618 * used as a value_type in templatized code. 619 * 620 * Note: Destructor not allowed to throw. 621 */ 622 template<typename _Cond> 623 struct throw_value_base : public _Cond 624 { 625 typedef _Cond condition_type; 626 627 using condition_type::throw_conditionally; 628 629 std::size_t _M_i; 630 631 #ifndef _GLIBCXX_IS_AGGREGATE 632 throw_value_base() : _M_i(0) 633 { throw_conditionally(); } 634 635 throw_value_base(const throw_value_base& __v) : _M_i(__v._M_i) 636 { throw_conditionally(); } 637 638 #if __cplusplus >= 201103L 639 // Shall not throw. 640 throw_value_base(throw_value_base&&) = default; 641 #endif 642 643 explicit throw_value_base(const std::size_t __i) : _M_i(__i) 644 { throw_conditionally(); } 645 #endif 646 647 throw_value_base& 648 operator=(const throw_value_base& __v) 649 { 650 throw_conditionally(); 651 _M_i = __v._M_i; 652 return *this; 653 } 654 655 #if __cplusplus >= 201103L 656 // Shall not throw. 657 throw_value_base& 658 operator=(throw_value_base&&) = default; 659 #endif 660 661 throw_value_base& 662 operator++() 663 { 664 throw_conditionally(); 665 ++_M_i; 666 return *this; 667 } 668 }; 669 670 template<typename _Cond> 671 inline void 672 swap(throw_value_base<_Cond>& __a, throw_value_base<_Cond>& __b) 673 { 674 typedef throw_value_base<_Cond> throw_value; 675 throw_value::throw_conditionally(); 676 throw_value orig(__a); 677 __a = __b; 678 __b = orig; 679 } 680 681 // General instantiable types requirements. 682 template<typename _Cond> 683 inline bool 684 operator==(const throw_value_base<_Cond>& __a, 685 const throw_value_base<_Cond>& __b) 686 { 687 typedef throw_value_base<_Cond> throw_value; 688 throw_value::throw_conditionally(); 689 bool __ret = __a._M_i == __b._M_i; 690 return __ret; 691 } 692 693 template<typename _Cond> 694 inline bool 695 operator<(const throw_value_base<_Cond>& __a, 696 const throw_value_base<_Cond>& __b) 697 { 698 typedef throw_value_base<_Cond> throw_value; 699 throw_value::throw_conditionally(); 700 bool __ret = __a._M_i < __b._M_i; 701 return __ret; 702 } 703 704 // Numeric algorithms instantiable types requirements. 705 template<typename _Cond> 706 inline throw_value_base<_Cond> 707 operator+(const throw_value_base<_Cond>& __a, 708 const throw_value_base<_Cond>& __b) 709 { 710 typedef throw_value_base<_Cond> throw_value; 711 throw_value::throw_conditionally(); 712 throw_value __ret(__a._M_i + __b._M_i); 713 return __ret; 714 } 715 716 template<typename _Cond> 717 inline throw_value_base<_Cond> 718 operator-(const throw_value_base<_Cond>& __a, 719 const throw_value_base<_Cond>& __b) 720 { 721 typedef throw_value_base<_Cond> throw_value; 722 throw_value::throw_conditionally(); 723 throw_value __ret(__a._M_i - __b._M_i); 724 return __ret; 725 } 726 727 template<typename _Cond> 728 inline throw_value_base<_Cond> 729 operator*(const throw_value_base<_Cond>& __a, 730 const throw_value_base<_Cond>& __b) 731 { 732 typedef throw_value_base<_Cond> throw_value; 733 throw_value::throw_conditionally(); 734 throw_value __ret(__a._M_i * __b._M_i); 735 return __ret; 736 } 737 738 739 /// Type throwing via limit condition. 740 struct throw_value_limit : public throw_value_base<limit_condition> 741 { 742 typedef throw_value_base<limit_condition> base_type; 743 744 #ifndef _GLIBCXX_IS_AGGREGATE 745 throw_value_limit() { } 746 747 throw_value_limit(const throw_value_limit& __other) 748 : base_type(__other._M_i) { } 749 750 #if __cplusplus >= 201103L 751 throw_value_limit(throw_value_limit&&) = default; 752 #endif 753 754 explicit throw_value_limit(const std::size_t __i) : base_type(__i) { } 755 #endif 756 757 throw_value_limit& 758 operator=(const throw_value_limit& __other) 759 { 760 base_type::operator=(__other); 761 return *this; 762 } 763 764 #if __cplusplus >= 201103L 765 throw_value_limit& 766 operator=(throw_value_limit&&) = default; 767 #endif 768 }; 769 770 /// Type throwing via random condition. 771 struct throw_value_random : public throw_value_base<random_condition> 772 { 773 typedef throw_value_base<random_condition> base_type; 774 775 #ifndef _GLIBCXX_IS_AGGREGATE 776 throw_value_random() { } 777 778 throw_value_random(const throw_value_random& __other) 779 : base_type(__other._M_i) { } 780 781 #if __cplusplus >= 201103L 782 throw_value_random(throw_value_random&&) = default; 783 #endif 784 785 explicit throw_value_random(const std::size_t __i) : base_type(__i) { } 786 #endif 787 788 throw_value_random& 789 operator=(const throw_value_random& __other) 790 { 791 base_type::operator=(__other); 792 return *this; 793 } 794 795 #if __cplusplus >= 201103L 796 throw_value_random& 797 operator=(throw_value_random&&) = default; 798 #endif 799 }; 800 801 /** 802 * @brief Allocator class with logging and exception generation control. 803 * Intended to be used as an allocator_type in templatized code. 804 * @ingroup allocators 805 * 806 * Note: Deallocate not allowed to throw. 807 */ 808 template<typename _Tp, typename _Cond> 809 class throw_allocator_base 810 : public annotate_base, public _Cond 811 { 812 public: 813 typedef std::size_t size_type; 814 typedef std::ptrdiff_t difference_type; 815 typedef _Tp value_type; 816 typedef value_type* pointer; 817 typedef const value_type* const_pointer; 818 typedef value_type& reference; 819 typedef const value_type& const_reference; 820 821 #if __cplusplus >= 201103L 822 // _GLIBCXX_RESOLVE_LIB_DEFECTS 823 // 2103. std::allocator propagate_on_container_move_assignment 824 typedef std::true_type propagate_on_container_move_assignment; 825 #endif 826 827 private: 828 typedef _Cond condition_type; 829 830 std::allocator<value_type> _M_allocator; 831 832 typedef __gnu_cxx::__alloc_traits<std::allocator<value_type> > traits; 833 834 using condition_type::throw_conditionally; 835 836 public: 837 size_type 838 max_size() const _GLIBCXX_USE_NOEXCEPT 839 { return traits::max_size(_M_allocator); } 840 841 pointer 842 address(reference __x) const _GLIBCXX_NOEXCEPT 843 { return std::__addressof(__x); } 844 845 const_pointer 846 address(const_reference __x) const _GLIBCXX_NOEXCEPT 847 { return std::__addressof(__x); } 848 849 _GLIBCXX_NODISCARD pointer 850 allocate(size_type __n, const void* __hint = 0) 851 { 852 if (__n > this->max_size()) 853 std::__throw_bad_alloc(); 854 855 throw_conditionally(); 856 pointer const a = traits::allocate(_M_allocator, __n, __hint); 857 insert(a, sizeof(value_type) * __n); 858 return a; 859 } 860 861 #if __cplusplus >= 201103L 862 template<typename _Up, typename... _Args> 863 void 864 construct(_Up* __p, _Args&&... __args) 865 { 866 traits::construct(_M_allocator, __p, std::forward<_Args>(__args)...); 867 insert_construct(__p); 868 } 869 870 template<typename _Up> 871 void 872 destroy(_Up* __p) 873 { 874 erase_construct(__p); 875 traits::destroy(_M_allocator, __p); 876 } 877 #else 878 void 879 construct(pointer __p, const value_type& __val) 880 { return _M_allocator.construct(__p, __val); } 881 882 void 883 destroy(pointer __p) 884 { _M_allocator.destroy(__p); } 885 #endif 886 887 void 888 deallocate(pointer __p, size_type __n) 889 { 890 erase(__p, sizeof(value_type) * __n); 891 _M_allocator.deallocate(__p, __n); 892 } 893 894 void 895 check_allocated(pointer __p, size_type __n) 896 { 897 size_type __t = sizeof(value_type) * __n; 898 annotate_base::check_allocated(__p, __t); 899 } 900 901 void 902 check(size_type __n) 903 { annotate_base::check(__n); } 904 }; 905 906 template<typename _Tp, typename _Cond> 907 inline bool 908 operator==(const throw_allocator_base<_Tp, _Cond>&, 909 const throw_allocator_base<_Tp, _Cond>&) 910 { return true; } 911 912 #if __cpp_impl_three_way_comparison < 201907L 913 template<typename _Tp, typename _Cond> 914 inline bool 915 operator!=(const throw_allocator_base<_Tp, _Cond>&, 916 const throw_allocator_base<_Tp, _Cond>&) 917 { return false; } 918 #endif 919 920 /// Allocator throwing via limit condition. 921 template<typename _Tp> 922 struct throw_allocator_limit 923 : public throw_allocator_base<_Tp, limit_condition> 924 { 925 template<typename _Tp1> 926 struct rebind 927 { typedef throw_allocator_limit<_Tp1> other; }; 928 929 throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } 930 931 throw_allocator_limit(const throw_allocator_limit&) 932 _GLIBCXX_USE_NOEXCEPT { } 933 934 template<typename _Tp1> 935 throw_allocator_limit(const throw_allocator_limit<_Tp1>&) 936 _GLIBCXX_USE_NOEXCEPT { } 937 938 ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } 939 940 #if __cplusplus >= 201103L 941 throw_allocator_limit& 942 operator=(const throw_allocator_limit&) = default; 943 #endif 944 }; 945 946 /// Allocator throwing via random condition. 947 template<typename _Tp> 948 struct throw_allocator_random 949 : public throw_allocator_base<_Tp, random_condition> 950 { 951 template<typename _Tp1> 952 struct rebind 953 { typedef throw_allocator_random<_Tp1> other; }; 954 955 throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } 956 957 throw_allocator_random(const throw_allocator_random&) 958 _GLIBCXX_USE_NOEXCEPT { } 959 960 template<typename _Tp1> 961 throw_allocator_random(const throw_allocator_random<_Tp1>&) 962 _GLIBCXX_USE_NOEXCEPT { } 963 964 ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } 965 966 #if __cplusplus >= 201103L 967 throw_allocator_random& 968 operator=(const throw_allocator_random&) = default; 969 #endif 970 }; 971 972 _GLIBCXX_END_NAMESPACE_VERSION 973 } // namespace 974 975 #if __cplusplus >= 201103L 976 977 # include <bits/functional_hash.h> 978 979 namespace std _GLIBCXX_VISIBILITY(default) 980 { 981 #pragma GCC diagnostic push 982 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 983 984 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_limit. 985 template<> 986 struct hash<__gnu_cxx::throw_value_limit> 987 : public std::unary_function<__gnu_cxx::throw_value_limit, size_t> 988 { 989 size_t 990 operator()(const __gnu_cxx::throw_value_limit& __val) const 991 { 992 __gnu_cxx::throw_value_limit::throw_conditionally(); 993 std::hash<std::size_t> __h; 994 size_t __result = __h(__val._M_i); 995 return __result; 996 } 997 }; 998 999 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_random. 1000 template<> 1001 struct hash<__gnu_cxx::throw_value_random> 1002 : public std::unary_function<__gnu_cxx::throw_value_random, size_t> 1003 { 1004 size_t 1005 operator()(const __gnu_cxx::throw_value_random& __val) const 1006 { 1007 __gnu_cxx::throw_value_random::throw_conditionally(); 1008 std::hash<std::size_t> __h; 1009 size_t __result = __h(__val._M_i); 1010 return __result; 1011 } 1012 }; 1013 1014 #pragma GCC diagnostic pop 1015 } // end namespace std 1016 #endif 1017 1018 #endif
