libstdc++-v3/include/ext/throw_allocator.h

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