Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/ext/throw_allocator.h
$ cat -n /usr/include/c++/13/ext/throw_allocator.h 1 // -*- C++ -*- 2 3 // Copyright (C) 2005-2023 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 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 499 /** 500 * @brief Base class for random probability control and throw. 501 */ 502 struct random_condition : public condition_base 503 { 504 // Scope-level adjustor objects: set probability for throw at the 505 // beginning of a scope block, and restores to previous 506 // probability when object is destroyed on exiting the block. 507 struct adjustor_base 508 { 509 private: 510 const double _M_orig; 511 512 public: 513 adjustor_base() : _M_orig(probability()) { } 514 515 virtual ~adjustor_base() 516 { set_probability(_M_orig); } 517 }; 518 519 /// Group condition. 520 struct group_adjustor : public adjustor_base 521 { 522 group_adjustor(size_t size) 523 { set_probability(1 - std::pow(double(1 - probability()), 524 double(0.5 / (size + 1)))); 525 } 526 }; 527 528 /// Never enter the condition. 529 struct never_adjustor : public adjustor_base 530 { 531 never_adjustor() { set_probability(0); } 532 }; 533 534 /// Always enter the condition. 535 struct always_adjustor : public adjustor_base 536 { 537 always_adjustor() { set_probability(1); } 538 }; 539 540 random_condition() 541 { 542 probability(); 543 engine(); 544 } 545 546 static void 547 set_probability(double __p) 548 { probability() = __p; } 549 550 static void 551 throw_conditionally() 552 { 553 if (generate() < probability()) 554 __throw_forced_error(); 555 } 556 557 void 558 seed(unsigned long __s) 559 { engine().seed(__s); } 560 561 private: 562 #if __cplusplus >= 201103L 563 typedef std::uniform_real_distribution<double> distribution_type; 564 typedef std::mt19937 engine_type; 565 #else 566 typedef std::tr1::uniform_real<double> distribution_type; 567 typedef std::tr1::mt19937 engine_type; 568 #endif 569 570 static double 571 generate() 572 { 573 #if __cplusplus >= 201103L 574 const distribution_type distribution(0, 1); 575 static auto generator = std::bind(distribution, engine()); 576 #else 577 // Use variate_generator to get normalized results. 578 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t; 579 distribution_type distribution(0, 1); 580 static gen_t generator(engine(), distribution); 581 #endif 582 583 #if ! __has_builtin(__builtin_sprintf) 584 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf; 585 #endif 586 587 double random = generator(); 588 if (random < distribution.min() || random > distribution.max()) 589 { 590 std::string __s("random_condition::generate"); 591 __s += "\n"; 592 __s += "random number generated is: "; 593 char buf[40]; 594 __builtin_sprintf(buf, "%f", random); 595 __s += buf; 596 std::__throw_out_of_range(__s.c_str()); 597 } 598 599 return random; 600 } 601 602 static double& 603 probability() 604 { 605 static double _S_p; 606 return _S_p; 607 } 608 609 static engine_type& 610 engine() 611 { 612 static engine_type _S_e; 613 return _S_e; 614 } 615 }; 616 #endif // _GLIBCXX_USE_C99_STDINT_TR1 617 618 /** 619 * @brief Class with exception generation control. Intended to be 620 * used as a value_type in templatized code. 621 * 622 * Note: Destructor not allowed to throw. 623 */ 624 template<typename _Cond> 625 struct throw_value_base : public _Cond 626 { 627 typedef _Cond condition_type; 628 629 using condition_type::throw_conditionally; 630 631 std::size_t _M_i; 632 633 #ifndef _GLIBCXX_IS_AGGREGATE 634 throw_value_base() : _M_i(0) 635 { throw_conditionally(); } 636 637 throw_value_base(const throw_value_base& __v) : _M_i(__v._M_i) 638 { throw_conditionally(); } 639 640 #if __cplusplus >= 201103L 641 // Shall not throw. 642 throw_value_base(throw_value_base&&) = default; 643 #endif 644 645 explicit throw_value_base(const std::size_t __i) : _M_i(__i) 646 { throw_conditionally(); } 647 #endif 648 649 throw_value_base& 650 operator=(const throw_value_base& __v) 651 { 652 throw_conditionally(); 653 _M_i = __v._M_i; 654 return *this; 655 } 656 657 #if __cplusplus >= 201103L 658 // Shall not throw. 659 throw_value_base& 660 operator=(throw_value_base&&) = default; 661 #endif 662 663 throw_value_base& 664 operator++() 665 { 666 throw_conditionally(); 667 ++_M_i; 668 return *this; 669 } 670 }; 671 672 template<typename _Cond> 673 inline void 674 swap(throw_value_base<_Cond>& __a, throw_value_base<_Cond>& __b) 675 { 676 typedef throw_value_base<_Cond> throw_value; 677 throw_value::throw_conditionally(); 678 throw_value orig(__a); 679 __a = __b; 680 __b = orig; 681 } 682 683 // General instantiable types requirements. 684 template<typename _Cond> 685 inline bool 686 operator==(const throw_value_base<_Cond>& __a, 687 const throw_value_base<_Cond>& __b) 688 { 689 typedef throw_value_base<_Cond> throw_value; 690 throw_value::throw_conditionally(); 691 bool __ret = __a._M_i == __b._M_i; 692 return __ret; 693 } 694 695 template<typename _Cond> 696 inline bool 697 operator<(const throw_value_base<_Cond>& __a, 698 const throw_value_base<_Cond>& __b) 699 { 700 typedef throw_value_base<_Cond> throw_value; 701 throw_value::throw_conditionally(); 702 bool __ret = __a._M_i < __b._M_i; 703 return __ret; 704 } 705 706 // Numeric algorithms instantiable types requirements. 707 template<typename _Cond> 708 inline throw_value_base<_Cond> 709 operator+(const throw_value_base<_Cond>& __a, 710 const throw_value_base<_Cond>& __b) 711 { 712 typedef throw_value_base<_Cond> throw_value; 713 throw_value::throw_conditionally(); 714 throw_value __ret(__a._M_i + __b._M_i); 715 return __ret; 716 } 717 718 template<typename _Cond> 719 inline throw_value_base<_Cond> 720 operator-(const throw_value_base<_Cond>& __a, 721 const throw_value_base<_Cond>& __b) 722 { 723 typedef throw_value_base<_Cond> throw_value; 724 throw_value::throw_conditionally(); 725 throw_value __ret(__a._M_i - __b._M_i); 726 return __ret; 727 } 728 729 template<typename _Cond> 730 inline throw_value_base<_Cond> 731 operator*(const throw_value_base<_Cond>& __a, 732 const throw_value_base<_Cond>& __b) 733 { 734 typedef throw_value_base<_Cond> throw_value; 735 throw_value::throw_conditionally(); 736 throw_value __ret(__a._M_i * __b._M_i); 737 return __ret; 738 } 739 740 741 /// Type throwing via limit condition. 742 struct throw_value_limit : public throw_value_base<limit_condition> 743 { 744 typedef throw_value_base<limit_condition> base_type; 745 746 #ifndef _GLIBCXX_IS_AGGREGATE 747 throw_value_limit() { } 748 749 throw_value_limit(const throw_value_limit& __other) 750 : base_type(__other._M_i) { } 751 752 #if __cplusplus >= 201103L 753 throw_value_limit(throw_value_limit&&) = default; 754 #endif 755 756 explicit throw_value_limit(const std::size_t __i) : base_type(__i) { } 757 #endif 758 759 throw_value_limit& 760 operator=(const throw_value_limit& __other) 761 { 762 base_type::operator=(__other); 763 return *this; 764 } 765 766 #if __cplusplus >= 201103L 767 throw_value_limit& 768 operator=(throw_value_limit&&) = default; 769 #endif 770 }; 771 772 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 773 /// Type throwing via random condition. 774 struct throw_value_random : public throw_value_base<random_condition> 775 { 776 typedef throw_value_base<random_condition> base_type; 777 778 #ifndef _GLIBCXX_IS_AGGREGATE 779 throw_value_random() { } 780 781 throw_value_random(const throw_value_random& __other) 782 : base_type(__other._M_i) { } 783 784 #if __cplusplus >= 201103L 785 throw_value_random(throw_value_random&&) = default; 786 #endif 787 788 explicit throw_value_random(const std::size_t __i) : base_type(__i) { } 789 #endif 790 791 throw_value_random& 792 operator=(const throw_value_random& __other) 793 { 794 base_type::operator=(__other); 795 return *this; 796 } 797 798 #if __cplusplus >= 201103L 799 throw_value_random& 800 operator=(throw_value_random&&) = default; 801 #endif 802 }; 803 #endif // _GLIBCXX_USE_C99_STDINT_TR1 804 805 /** 806 * @brief Allocator class with logging and exception generation control. 807 * Intended to be used as an allocator_type in templatized code. 808 * @ingroup allocators 809 * 810 * Note: Deallocate not allowed to throw. 811 */ 812 template<typename _Tp, typename _Cond> 813 class throw_allocator_base 814 : public annotate_base, public _Cond 815 { 816 public: 817 typedef std::size_t size_type; 818 typedef std::ptrdiff_t difference_type; 819 typedef _Tp value_type; 820 typedef value_type* pointer; 821 typedef const value_type* const_pointer; 822 typedef value_type& reference; 823 typedef const value_type& const_reference; 824 825 #if __cplusplus >= 201103L 826 // _GLIBCXX_RESOLVE_LIB_DEFECTS 827 // 2103. std::allocator propagate_on_container_move_assignment 828 typedef std::true_type propagate_on_container_move_assignment; 829 #endif 830 831 private: 832 typedef _Cond condition_type; 833 834 std::allocator<value_type> _M_allocator; 835 836 typedef __gnu_cxx::__alloc_traits<std::allocator<value_type> > traits; 837 838 using condition_type::throw_conditionally; 839 840 public: 841 size_type 842 max_size() const _GLIBCXX_USE_NOEXCEPT 843 { return traits::max_size(_M_allocator); } 844 845 pointer 846 address(reference __x) const _GLIBCXX_NOEXCEPT 847 { return std::__addressof(__x); } 848 849 const_pointer 850 address(const_reference __x) const _GLIBCXX_NOEXCEPT 851 { return std::__addressof(__x); } 852 853 _GLIBCXX_NODISCARD pointer 854 allocate(size_type __n, const void* __hint = 0) 855 { 856 if (__n > this->max_size()) 857 std::__throw_bad_alloc(); 858 859 throw_conditionally(); 860 pointer const a = traits::allocate(_M_allocator, __n, __hint); 861 insert(a, sizeof(value_type) * __n); 862 return a; 863 } 864 865 #if __cplusplus >= 201103L 866 template<typename _Up, typename... _Args> 867 void 868 construct(_Up* __p, _Args&&... __args) 869 { 870 traits::construct(_M_allocator, __p, std::forward<_Args>(__args)...); 871 insert_construct(__p); 872 } 873 874 template<typename _Up> 875 void 876 destroy(_Up* __p) 877 { 878 erase_construct(__p); 879 traits::destroy(_M_allocator, __p); 880 } 881 #else 882 void 883 construct(pointer __p, const value_type& __val) 884 { return _M_allocator.construct(__p, __val); } 885 886 void 887 destroy(pointer __p) 888 { _M_allocator.destroy(__p); } 889 #endif 890 891 void 892 deallocate(pointer __p, size_type __n) 893 { 894 erase(__p, sizeof(value_type) * __n); 895 _M_allocator.deallocate(__p, __n); 896 } 897 898 void 899 check_allocated(pointer __p, size_type __n) 900 { 901 size_type __t = sizeof(value_type) * __n; 902 annotate_base::check_allocated(__p, __t); 903 } 904 905 void 906 check(size_type __n) 907 { annotate_base::check(__n); } 908 }; 909 910 template<typename _Tp, typename _Cond> 911 inline bool 912 operator==(const throw_allocator_base<_Tp, _Cond>&, 913 const throw_allocator_base<_Tp, _Cond>&) 914 { return true; } 915 916 #if __cpp_impl_three_way_comparison < 201907L 917 template<typename _Tp, typename _Cond> 918 inline bool 919 operator!=(const throw_allocator_base<_Tp, _Cond>&, 920 const throw_allocator_base<_Tp, _Cond>&) 921 { return false; } 922 #endif 923 924 /// Allocator throwing via limit condition. 925 template<typename _Tp> 926 struct throw_allocator_limit 927 : public throw_allocator_base<_Tp, limit_condition> 928 { 929 template<typename _Tp1> 930 struct rebind 931 { typedef throw_allocator_limit<_Tp1> other; }; 932 933 throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } 934 935 throw_allocator_limit(const throw_allocator_limit&) 936 _GLIBCXX_USE_NOEXCEPT { } 937 938 template<typename _Tp1> 939 throw_allocator_limit(const throw_allocator_limit<_Tp1>&) 940 _GLIBCXX_USE_NOEXCEPT { } 941 942 ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } 943 944 #if __cplusplus >= 201103L 945 throw_allocator_limit& 946 operator=(const throw_allocator_limit&) = default; 947 #endif 948 }; 949 950 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 951 /// Allocator throwing via random condition. 952 template<typename _Tp> 953 struct throw_allocator_random 954 : public throw_allocator_base<_Tp, random_condition> 955 { 956 template<typename _Tp1> 957 struct rebind 958 { typedef throw_allocator_random<_Tp1> other; }; 959 960 throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } 961 962 throw_allocator_random(const throw_allocator_random&) 963 _GLIBCXX_USE_NOEXCEPT { } 964 965 template<typename _Tp1> 966 throw_allocator_random(const throw_allocator_random<_Tp1>&) 967 _GLIBCXX_USE_NOEXCEPT { } 968 969 ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } 970 971 #if __cplusplus >= 201103L 972 throw_allocator_random& 973 operator=(const throw_allocator_random&) = default; 974 #endif 975 }; 976 #endif // _GLIBCXX_USE_C99_STDINT_TR1 977 978 _GLIBCXX_END_NAMESPACE_VERSION 979 } // namespace 980 981 #if __cplusplus >= 201103L 982 983 # include <bits/functional_hash.h> 984 985 namespace std _GLIBCXX_VISIBILITY(default) 986 { 987 #pragma GCC diagnostic push 988 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 989 990 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_limit. 991 template<> 992 struct hash<__gnu_cxx::throw_value_limit> 993 : public std::unary_function<__gnu_cxx::throw_value_limit, size_t> 994 { 995 size_t 996 operator()(const __gnu_cxx::throw_value_limit& __val) const 997 { 998 __gnu_cxx::throw_value_limit::throw_conditionally(); 999 std::hash<std::size_t> __h; 1000 size_t __result = __h(__val._M_i); 1001 return __result; 1002 } 1003 }; 1004 1005 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 1006 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_random. 1007 template<> 1008 struct hash<__gnu_cxx::throw_value_random> 1009 : public std::unary_function<__gnu_cxx::throw_value_random, size_t> 1010 { 1011 size_t 1012 operator()(const __gnu_cxx::throw_value_random& __val) const 1013 { 1014 __gnu_cxx::throw_value_random::throw_conditionally(); 1015 std::hash<std::size_t> __h; 1016 size_t __result = __h(__val._M_i); 1017 return __result; 1018 } 1019 }; 1020 #endif 1021 1022 #pragma GCC diagnostic pop 1023 } // end namespace std 1024 #endif 1025 1026 #endif
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
