contrib/gcc-5.0/libstdc++-v3/include/tr1/hashtable.h

   1 // TR1 hashtable.h header -*- C++ -*-
   2
   3 // Copyright (C) 2007-2015 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 tr1/hashtable.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly.
  28  *  @headername{tr1/unordered_set, tr1/unordered_map}
  29  */
  30
  31 #ifndef _GLIBCXX_TR1_HASHTABLE_H
  32 #define _GLIBCXX_TR1_HASHTABLE_H 1
  33
  34 #pragma GCC system_header
  35
  36 #include <tr1/hashtable_policy.h>
  37
  38 namespace std _GLIBCXX_VISIBILITY(default)
  39 {
  40 namespace tr1
  41 {
  42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  43
  44   // Class template _Hashtable, class definition.
  45
  46   // Meaning of class template _Hashtable's template parameters
  47
  48   // _Key and _Value: arbitrary CopyConstructible types.
  49
  50   // _Allocator: an allocator type ([lib.allocator.requirements]) whose
  51   // value type is Value.  As a conforming extension, we allow for
  52   // value type != Value.
  53
  54   // _ExtractKey: function object that takes a object of type Value
  55   // and returns a value of type _Key.
  56
  57   // _Equal: function object that takes two objects of type k and returns
  58   // a bool-like value that is true if the two objects are considered equal.
  59
  60   // _H1: the hash function.  A unary function object with argument type
  61   // Key and result type size_t.  Return values should be distributed
  62   // over the entire range [0, numeric_limits<size_t>:::max()].
  63
  64   // _H2: the range-hashing function (in the terminology of Tavori and
  65   // Dreizin).  A binary function object whose argument types and result
  66   // type are all size_t.  Given arguments r and N, the return value is
  67   // in the range [0, N).
  68
  69   // _Hash: the ranged hash function (Tavori and Dreizin). A binary function
  70   // whose argument types are _Key and size_t and whose result type is
  71   // size_t.  Given arguments k and N, the return value is in the range
  72   // [0, N).  Default: hash(k, N) = h2(h1(k), N).  If _Hash is anything other
  73   // than the default, _H1 and _H2 are ignored.
  74
  75   // _RehashPolicy: Policy class with three members, all of which govern
  76   // the bucket count. _M_next_bkt(n) returns a bucket count no smaller
  77   // than n.  _M_bkt_for_elements(n) returns a bucket count appropriate
  78   // for an element count of n.  _M_need_rehash(n_bkt, n_elt, n_ins)
  79   // determines whether, if the current bucket count is n_bkt and the
  80   // current element count is n_elt, we need to increase the bucket
  81   // count.  If so, returns make_pair(true, n), where n is the new
  82   // bucket count.  If not, returns make_pair(false, <anything>).
  83
  84   // ??? Right now it is hard-wired that the number of buckets never
  85   // shrinks.  Should we allow _RehashPolicy to change that?
  86
  87   // __cache_hash_code: bool.  true if we store the value of the hash
  88   // function along with the value.  This is a time-space tradeoff.
  89   // Storing it may improve lookup speed by reducing the number of times
  90   // we need to call the Equal function.
  91
  92   // __constant_iterators: bool.  true if iterator and const_iterator are
  93   // both constant iterator types.  This is true for unordered_set and
  94   // unordered_multiset, false for unordered_map and unordered_multimap.
  95
  96   // __unique_keys: bool.  true if the return value of _Hashtable::count(k)
  97   // is always at most one, false if it may be an arbitrary number.  This
  98   // true for unordered_set and unordered_map, false for unordered_multiset
  99   // and unordered_multimap.
 100
 101   template<typename _Key, typename _Value, typename _Allocator,
 102            typename _ExtractKey, typename _Equal,
 103            typename _H1, typename _H2, typename _Hash,
 104            typename _RehashPolicy,
 105            bool __cache_hash_code,
 106            bool __constant_iterators,
 107            bool __unique_keys>
 108     class _Hashtable
 109     : public __detail::_Rehash_base<_RehashPolicy,
 110                                     _Hashtable<_Key, _Value, _Allocator,
 111                                                _ExtractKey,
 112                                                _Equal, _H1, _H2, _Hash,
 113                                                _RehashPolicy,
 114                                                __cache_hash_code,
 115                                                __constant_iterators,
 116                                                __unique_keys> >,
 117       public __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
 118                                        _H1, _H2, _Hash, __cache_hash_code>,
 119       public __detail::_Map_base<_Key, _Value, _ExtractKey, __unique_keys,
 120                                  _Hashtable<_Key, _Value, _Allocator,
 121                                             _ExtractKey,
 122                                             _Equal, _H1, _H2, _Hash,
 123                                             _RehashPolicy,
 124                                             __cache_hash_code,
 125                                             __constant_iterators,
 126                                             __unique_keys> >
 127     {
 128     public:
 129       typedef _Allocator                                  allocator_type;
 130       typedef _Value                                      value_type;
 131       typedef _Key                                        key_type;
 132       typedef _Equal                                      key_equal;
 133       // mapped_type, if present, comes from _Map_base.
 134       // hasher, if present, comes from _Hash_code_base.
 135       typedef typename _Allocator::difference_type        difference_type;
 136       typedef typename _Allocator::size_type              size_type;
 137       typedef typename _Allocator::pointer                pointer;
 138       typedef typename _Allocator::const_pointer          const_pointer;
 139       typedef typename _Allocator::reference              reference;
 140       typedef typename _Allocator::const_reference        const_reference;
 141
 142       typedef __detail::_Node_iterator<value_type, __constant_iterators,
 143                                        __cache_hash_code>
 144                                                           local_iterator;
 145       typedef __detail::_Node_const_iterator<value_type,
 146                                              __constant_iterators,
 147                                              __cache_hash_code>
 148                                                           const_local_iterator;
 149
 150       typedef __detail::_Hashtable_iterator<value_type, __constant_iterators,
 151                                             __cache_hash_code>
 152                                                           iterator;
 153       typedef __detail::_Hashtable_const_iterator<value_type,
 154                                                   __constant_iterators,
 155                                                   __cache_hash_code>
 156                                                           const_iterator;
 157
 158       template<typename _Key2, typename _Value2, typename _Ex2, bool __unique2,
 159                typename _Hashtable2>
 160         friend struct __detail::_Map_base;
 161
 162     private:
 163       typedef __detail::_Hash_node<_Value, __cache_hash_code> _Node;
 164       typedef typename _Allocator::template rebind<_Node>::other
 165                                                         _Node_allocator_type;
 166       typedef typename _Allocator::template rebind<_Node*>::other
 167                                                         _Bucket_allocator_type;
 168
 169       typedef typename _Allocator::template rebind<_Value>::other
 170                                                         _Value_allocator_type;
 171
 172       _Node_allocator_type   _M_node_allocator;
 173       _Node**                _M_buckets;
 174       size_type              _M_bucket_count;
 175       size_type              _M_element_count;
 176       _RehashPolicy          _M_rehash_policy;
 177
 178       _Node*
 179       _M_allocate_node(const value_type& __v);
 180
 181       void
 182       _M_deallocate_node(_Node* __n);
 183
 184       void
 185       _M_deallocate_nodes(_Node**, size_type);
 186
 187       _Node**
 188       _M_allocate_buckets(size_type __n);
 189
 190       void
 191       _M_deallocate_buckets(_Node**, size_type __n);
 192
 193     public:
 194       // Constructor, destructor, assignment, swap
 195       _Hashtable(size_type __bucket_hint,
 196                  const _H1&, const _H2&, const _Hash&,
 197                  const _Equal&, const _ExtractKey&,
 198                  const allocator_type&);
 199
 200       template<typename _InputIterator>
 201         _Hashtable(_InputIterator __first, _InputIterator __last,
 202                    size_type __bucket_hint,
 203                    const _H1&, const _H2&, const _Hash&,
 204                    const _Equal&, const _ExtractKey&,
 205                    const allocator_type&);
 206
 207       _Hashtable(const _Hashtable&);
 208
 209       _Hashtable&
 210       operator=(const _Hashtable&);
 211
 212       ~_Hashtable();
 213
 214       void swap(_Hashtable&);
 215
 216       // Basic container operations
 217       iterator
 218       begin()
 219       {
 220         iterator __i(_M_buckets);
 221         if (!__i._M_cur_node)
 222           __i._M_incr_bucket();
 223         return __i;
 224       }
 225
 226       const_iterator
 227       begin() const
 228       {
 229         const_iterator __i(_M_buckets);
 230         if (!__i._M_cur_node)
 231           __i._M_incr_bucket();
 232         return __i;
 233       }
 234
 235       iterator
 236       end()
 237       { return iterator(_M_buckets + _M_bucket_count); }
 238
 239       const_iterator
 240       end() const
 241       { return const_iterator(_M_buckets + _M_bucket_count); }
 242
 243       size_type
 244       size() const
 245       { return _M_element_count; }
 246
 247       bool
 248       empty() const
 249       { return size() == 0; }
 250
 251       allocator_type
 252       get_allocator() const
 253       { return allocator_type(_M_node_allocator); }
 254
 255       _Value_allocator_type
 256       _M_get_Value_allocator() const
 257       { return _Value_allocator_type(_M_node_allocator); }
 258
 259       size_type
 260       max_size() const
 261       { return _M_node_allocator.max_size(); }
 262
 263       // Observers
 264       key_equal
 265       key_eq() const
 266       { return this->_M_eq; }
 267
 268       // hash_function, if present, comes from _Hash_code_base.
 269
 270       // Bucket operations
 271       size_type
 272       bucket_count() const
 273       { return _M_bucket_count; }
 274
 275       size_type
 276       max_bucket_count() const
 277       { return max_size(); }
 278
 279       size_type
 280       bucket_size(size_type __n) const
 281       { return std::distance(begin(__n), end(__n)); }
 282
 283       size_type
 284       bucket(const key_type& __k) const
 285       {
 286         return this->_M_bucket_index(__k, this->_M_hash_code(__k),
 287                                      bucket_count());
 288       }
 289
 290       local_iterator
 291       begin(size_type __n)
 292       { return local_iterator(_M_buckets[__n]); }
 293
 294       local_iterator
 295       end(size_type)
 296       { return local_iterator(0); }
 297
 298       const_local_iterator
 299       begin(size_type __n) const
 300       { return const_local_iterator(_M_buckets[__n]); }
 301
 302       const_local_iterator
 303       end(size_type) const
 304       { return const_local_iterator(0); }
 305
 306       float
 307       load_factor() const
 308       {
 309         return static_cast<float>(size()) / static_cast<float>(bucket_count());
 310       }
 311
 312       // max_load_factor, if present, comes from _Rehash_base.
 313
 314       // Generalization of max_load_factor.  Extension, not found in TR1.  Only
 315       // useful if _RehashPolicy is something other than the default.
 316       const _RehashPolicy&
 317       __rehash_policy() const
 318       { return _M_rehash_policy; }
 319
 320       void
 321       __rehash_policy(const _RehashPolicy&);
 322
 323       // Lookup.
 324       iterator
 325       find(const key_type& __k);
 326
 327       const_iterator
 328       find(const key_type& __k) const;
 329
 330       size_type
 331       count(const key_type& __k) const;
 332
 333       std::pair<iterator, iterator>
 334       equal_range(const key_type& __k);
 335
 336       std::pair<const_iterator, const_iterator>
 337       equal_range(const key_type& __k) const;
 338
 339     private:                    // Find, insert and erase helper functions
 340       // ??? This dispatching is a workaround for the fact that we don't
 341       // have partial specialization of member templates; it would be
 342       // better to just specialize insert on __unique_keys.  There may be a
 343       // cleaner workaround.
 344       typedef typename __gnu_cxx::__conditional_type<__unique_keys,
 345                             std::pair<iterator, bool>, iterator>::__type
 346         _Insert_Return_Type;
 347
 348       typedef typename __gnu_cxx::__conditional_type<__unique_keys,
 349                                           std::_Select1st<_Insert_Return_Type>,
 350                                           std::_Identity<_Insert_Return_Type>
 351                                    >::__type
 352         _Insert_Conv_Type;
 353
 354       _Node*
 355       _M_find_node(_Node*, const key_type&,
 356                    typename _Hashtable::_Hash_code_type) const;
 357
 358       iterator
 359       _M_insert_bucket(const value_type&, size_type,
 360                        typename _Hashtable::_Hash_code_type);
 361
 362       std::pair<iterator, bool>
 363       _M_insert(const value_type&, std::tr1::true_type);
 364
 365       iterator
 366       _M_insert(const value_type&, std::tr1::false_type);
 367
 368       void
 369       _M_erase_node(_Node*, _Node**);
 370
 371     public:
 372       // Insert and erase
 373       _Insert_Return_Type
 374       insert(const value_type& __v)
 375       { return _M_insert(__v, std::tr1::integral_constant<bool,
 376                          __unique_keys>()); }
 377
 378       iterator
 379       insert(iterator, const value_type& __v)
 380       { return iterator(_Insert_Conv_Type()(this->insert(__v))); }
 381
 382       const_iterator
 383       insert(const_iterator, const value_type& __v)
 384       { return const_iterator(_Insert_Conv_Type()(this->insert(__v))); }
 385
 386       template<typename _InputIterator>
 387         void
 388         insert(_InputIterator __first, _InputIterator __last);
 389
 390       iterator
 391       erase(iterator);
 392
 393       const_iterator
 394       erase(const_iterator);
 395
 396       size_type
 397       erase(const key_type&);
 398
 399       iterator
 400       erase(iterator, iterator);
 401
 402       const_iterator
 403       erase(const_iterator, const_iterator);
 404
 405       void
 406       clear();
 407
 408       // Set number of buckets to be appropriate for container of n element.
 409       void rehash(size_type __n);
 410
 411     private:
 412       // Unconditionally change size of bucket array to n.
 413       void _M_rehash(size_type __n);
 414     };
 415
 416
 417   // Definitions of class template _Hashtable's out-of-line member functions.
 418   template<typename _Key, typename _Value,
 419            typename _Allocator, typename _ExtractKey, typename _Equal,
 420            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 421            bool __chc, bool __cit, bool __uk>
 422     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 423                         _H1, _H2, _Hash, _RehashPolicy,
 424                         __chc, __cit, __uk>::_Node*
 425     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 426                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 427     _M_allocate_node(const value_type& __v)
 428     {
 429       _Node* __n = _M_node_allocator.allocate(1);
 430       __try
 431         {
 432           _M_get_Value_allocator().construct(&__n->_M_v, __v);
 433           __n->_M_next = 0;
 434           return __n;
 435         }
 436       __catch(...)
 437         {
 438           _M_node_allocator.deallocate(__n, 1);
 439           __throw_exception_again;
 440         }
 441     }
 442
 443   template<typename _Key, typename _Value,
 444            typename _Allocator, typename _ExtractKey, typename _Equal,
 445            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 446            bool __chc, bool __cit, bool __uk>
 447     void
 448     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 449                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 450     _M_deallocate_node(_Node* __n)
 451     {
 452       _M_get_Value_allocator().destroy(&__n->_M_v);
 453       _M_node_allocator.deallocate(__n, 1);
 454     }
 455
 456   template<typename _Key, typename _Value,
 457            typename _Allocator, typename _ExtractKey, typename _Equal,
 458            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 459            bool __chc, bool __cit, bool __uk>
 460     void
 461     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 462                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 463     _M_deallocate_nodes(_Node** __array, size_type __n)
 464     {
 465       for (size_type __i = 0; __i < __n; ++__i)
 466         {
 467           _Node* __p = __array[__i];
 468           while (__p)
 469             {
 470               _Node* __tmp = __p;
 471               __p = __p->_M_next;
 472               _M_deallocate_node(__tmp);
 473             }
 474           __array[__i] = 0;
 475         }
 476     }
 477
 478   template<typename _Key, typename _Value,
 479            typename _Allocator, typename _ExtractKey, typename _Equal,
 480            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 481            bool __chc, bool __cit, bool __uk>
 482     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 483                         _H1, _H2, _Hash, _RehashPolicy,
 484                         __chc, __cit, __uk>::_Node**
 485     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 486                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 487     _M_allocate_buckets(size_type __n)
 488     {
 489       _Bucket_allocator_type __alloc(_M_node_allocator);
 490
 491       // We allocate one extra bucket to hold a sentinel, an arbitrary
 492       // non-null pointer.  Iterator increment relies on this.
 493       _Node** __p = __alloc.allocate(__n + 1);
 494       std::fill(__p, __p + __n, (_Node*) 0);
 495       __p[__n] = reinterpret_cast<_Node*>(0x1000);
 496       return __p;
 497     }
 498
 499   template<typename _Key, typename _Value,
 500            typename _Allocator, typename _ExtractKey, typename _Equal,
 501            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 502            bool __chc, bool __cit, bool __uk>
 503     void
 504     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 505                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 506     _M_deallocate_buckets(_Node** __p, size_type __n)
 507     {
 508       _Bucket_allocator_type __alloc(_M_node_allocator);
 509       __alloc.deallocate(__p, __n + 1);
 510     }
 511
 512   template<typename _Key, typename _Value,
 513            typename _Allocator, typename _ExtractKey, typename _Equal,
 514            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 515            bool __chc, bool __cit, bool __uk>
 516     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 517                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 518     _Hashtable(size_type __bucket_hint,
 519                const _H1& __h1, const _H2& __h2, const _Hash& __h,
 520                const _Equal& __eq, const _ExtractKey& __exk,
 521                const allocator_type& __a)
 522     : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
 523       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
 524                                 _H1, _H2, _Hash, __chc>(__exk, __eq,
 525                                                         __h1, __h2, __h),
 526       __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
 527       _M_node_allocator(__a),
 528       _M_bucket_count(0),
 529       _M_element_count(0),
 530       _M_rehash_policy()
 531     {
 532       _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint);
 533       _M_buckets = _M_allocate_buckets(_M_bucket_count);
 534     }
 535
 536   template<typename _Key, typename _Value,
 537            typename _Allocator, typename _ExtractKey, typename _Equal,
 538            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 539            bool __chc, bool __cit, bool __uk>
 540     template<typename _InputIterator>
 541       _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 542                  _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 543       _Hashtable(_InputIterator __f, _InputIterator __l,
 544                  size_type __bucket_hint,
 545                  const _H1& __h1, const _H2& __h2, const _Hash& __h,
 546                  const _Equal& __eq, const _ExtractKey& __exk,
 547                  const allocator_type& __a)
 548       : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
 549         __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
 550                                   _H1, _H2, _Hash, __chc>(__exk, __eq,
 551                                                           __h1, __h2, __h),
 552         __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
 553         _M_node_allocator(__a),
 554         _M_bucket_count(0),
 555         _M_element_count(0),
 556         _M_rehash_policy()
 557       {
 558         _M_bucket_count = std::max(_M_rehash_policy._M_next_bkt(__bucket_hint),
 559                                    _M_rehash_policy.
 560                                    _M_bkt_for_elements(__detail::
 561                                                        __distance_fw(__f,
 562                                                                      __l)));
 563         _M_buckets = _M_allocate_buckets(_M_bucket_count);
 564         __try
 565           {
 566             for (; __f != __l; ++__f)
 567               this->insert(*__f);
 568           }
 569         __catch(...)
 570           {
 571             clear();
 572             _M_deallocate_buckets(_M_buckets, _M_bucket_count);
 573             __throw_exception_again;
 574           }
 575       }
 576
 577   template<typename _Key, typename _Value,
 578            typename _Allocator, typename _ExtractKey, typename _Equal,
 579            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 580            bool __chc, bool __cit, bool __uk>
 581     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 582                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 583     _Hashtable(const _Hashtable& __ht)
 584     : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht),
 585       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
 586                                 _H1, _H2, _Hash, __chc>(__ht),
 587       __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht),
 588       _M_node_allocator(__ht._M_node_allocator),
 589       _M_bucket_count(__ht._M_bucket_count),
 590       _M_element_count(__ht._M_element_count),
 591       _M_rehash_policy(__ht._M_rehash_policy)
 592     {
 593       _M_buckets = _M_allocate_buckets(_M_bucket_count);
 594       __try
 595         {
 596           for (size_type __i = 0; __i < __ht._M_bucket_count; ++__i)
 597             {
 598               _Node* __n = __ht._M_buckets[__i];
 599               _Node** __tail = _M_buckets + __i;
 600               while (__n)
 601                 {
 602                   *__tail = _M_allocate_node(__n->_M_v);
 603                   this->_M_copy_code(*__tail, __n);
 604                   __tail = &((*__tail)->_M_next);
 605                   __n = __n->_M_next;
 606                 }
 607             }
 608         }
 609       __catch(...)
 610         {
 611           clear();
 612           _M_deallocate_buckets(_M_buckets, _M_bucket_count);
 613           __throw_exception_again;
 614         }
 615     }
 616
 617   template<typename _Key, typename _Value,
 618            typename _Allocator, typename _ExtractKey, typename _Equal,
 619            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 620            bool __chc, bool __cit, bool __uk>
 621     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 622                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>&
 623     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 624                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 625     operator=(const _Hashtable& __ht)
 626     {
 627       _Hashtable __tmp(__ht);
 628       this->swap(__tmp);
 629       return *this;
 630     }
 631
 632   template<typename _Key, typename _Value,
 633            typename _Allocator, typename _ExtractKey, typename _Equal,
 634            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 635            bool __chc, bool __cit, bool __uk>
 636     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 637                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 638     ~_Hashtable()
 639     {
 640       clear();
 641       _M_deallocate_buckets(_M_buckets, _M_bucket_count);
 642     }
 643
 644   template<typename _Key, typename _Value,
 645            typename _Allocator, typename _ExtractKey, typename _Equal,
 646            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 647            bool __chc, bool __cit, bool __uk>
 648     void
 649     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 650                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 651     swap(_Hashtable& __x)
 652     {
 653       // The only base class with member variables is hash_code_base.  We
 654       // define _Hash_code_base::_M_swap because different specializations
 655       // have different members.
 656       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
 657         _H1, _H2, _Hash, __chc>::_M_swap(__x);
 658
 659       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 660       // 431. Swapping containers with unequal allocators.
 661       std::__alloc_swap<_Node_allocator_type>::_S_do_it(_M_node_allocator,
 662                                                         __x._M_node_allocator);
 663
 664       std::swap(_M_rehash_policy, __x._M_rehash_policy);
 665       std::swap(_M_buckets, __x._M_buckets);
 666       std::swap(_M_bucket_count, __x._M_bucket_count);
 667       std::swap(_M_element_count, __x._M_element_count);
 668     }
 669
 670   template<typename _Key, typename _Value,
 671            typename _Allocator, typename _ExtractKey, typename _Equal,
 672            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 673            bool __chc, bool __cit, bool __uk>
 674     void
 675     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 676                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 677     __rehash_policy(const _RehashPolicy& __pol)
 678     {
 679       _M_rehash_policy = __pol;
 680       size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count);
 681       if (__n_bkt > _M_bucket_count)
 682         _M_rehash(__n_bkt);
 683     }
 684
 685   template<typename _Key, typename _Value,
 686            typename _Allocator, typename _ExtractKey, typename _Equal,
 687            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 688            bool __chc, bool __cit, bool __uk>
 689     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 690                         _H1, _H2, _Hash, _RehashPolicy,
 691                         __chc, __cit, __uk>::iterator
 692     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 693                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 694     find(const key_type& __k)
 695     {
 696       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 697       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 698       _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
 699       return __p ? iterator(__p, _M_buckets + __n) : this->end();
 700     }
 701
 702   template<typename _Key, typename _Value,
 703            typename _Allocator, typename _ExtractKey, typename _Equal,
 704            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 705            bool __chc, bool __cit, bool __uk>
 706     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 707                         _H1, _H2, _Hash, _RehashPolicy,
 708                         __chc, __cit, __uk>::const_iterator
 709     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 710                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 711     find(const key_type& __k) const
 712     {
 713       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 714       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 715       _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
 716       return __p ? const_iterator(__p, _M_buckets + __n) : this->end();
 717     }
 718
 719   template<typename _Key, typename _Value,
 720            typename _Allocator, typename _ExtractKey, typename _Equal,
 721            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 722            bool __chc, bool __cit, bool __uk>
 723     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 724                         _H1, _H2, _Hash, _RehashPolicy,
 725                         __chc, __cit, __uk>::size_type
 726     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 727                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 728     count(const key_type& __k) const
 729     {
 730       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 731       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 732       std::size_t __result = 0;
 733       for (_Node* __p = _M_buckets[__n]; __p; __p = __p->_M_next)
 734         if (this->_M_compare(__k, __code, __p))
 735           ++__result;
 736       return __result;
 737     }
 738
 739   template<typename _Key, typename _Value,
 740            typename _Allocator, typename _ExtractKey, typename _Equal,
 741            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 742            bool __chc, bool __cit, bool __uk>
 743     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
 744                                   _ExtractKey, _Equal, _H1,
 745                                   _H2, _Hash, _RehashPolicy,
 746                                   __chc, __cit, __uk>::iterator,
 747               typename _Hashtable<_Key, _Value, _Allocator,
 748                                   _ExtractKey, _Equal, _H1,
 749                                   _H2, _Hash, _RehashPolicy,
 750                                   __chc, __cit, __uk>::iterator>
 751     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 752                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 753     equal_range(const key_type& __k)
 754     {
 755       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 756       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 757       _Node** __head = _M_buckets + __n;
 758       _Node* __p = _M_find_node(*__head, __k, __code);
 759
 760       if (__p)
 761         {
 762           _Node* __p1 = __p->_M_next;
 763           for (; __p1; __p1 = __p1->_M_next)
 764             if (!this->_M_compare(__k, __code, __p1))
 765               break;
 766
 767           iterator __first(__p, __head);
 768           iterator __last(__p1, __head);
 769           if (!__p1)
 770             __last._M_incr_bucket();
 771           return std::make_pair(__first, __last);
 772         }
 773       else
 774         return std::make_pair(this->end(), this->end());
 775     }
 776
 777   template<typename _Key, typename _Value,
 778            typename _Allocator, typename _ExtractKey, typename _Equal,
 779            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 780            bool __chc, bool __cit, bool __uk>
 781     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
 782                                   _ExtractKey, _Equal, _H1,
 783                                   _H2, _Hash, _RehashPolicy,
 784                                   __chc, __cit, __uk>::const_iterator,
 785               typename _Hashtable<_Key, _Value, _Allocator,
 786                                   _ExtractKey, _Equal, _H1,
 787                                   _H2, _Hash, _RehashPolicy,
 788                                   __chc, __cit, __uk>::const_iterator>
 789     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 790                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 791     equal_range(const key_type& __k) const
 792     {
 793       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 794       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 795       _Node** __head = _M_buckets + __n;
 796       _Node* __p = _M_find_node(*__head, __k, __code);
 797
 798       if (__p)
 799         {
 800           _Node* __p1 = __p->_M_next;
 801           for (; __p1; __p1 = __p1->_M_next)
 802             if (!this->_M_compare(__k, __code, __p1))
 803               break;
 804
 805           const_iterator __first(__p, __head);
 806           const_iterator __last(__p1, __head);
 807           if (!__p1)
 808             __last._M_incr_bucket();
 809           return std::make_pair(__first, __last);
 810         }
 811       else
 812         return std::make_pair(this->end(), this->end());
 813     }
 814
 815   // Find the node whose key compares equal to k, beginning the search
 816   // at p (usually the head of a bucket).  Return zero if no node is found.
 817   template<typename _Key, typename _Value,
 818            typename _Allocator, typename _ExtractKey, typename _Equal,
 819            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 820            bool __chc, bool __cit, bool __uk>
 821     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey,
 822                         _Equal, _H1, _H2, _Hash, _RehashPolicy,
 823                         __chc, __cit, __uk>::_Node*
 824     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 825                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 826     _M_find_node(_Node* __p, const key_type& __k,
 827                 typename _Hashtable::_Hash_code_type __code) const
 828     {
 829       for (; __p; __p = __p->_M_next)
 830         if (this->_M_compare(__k, __code, __p))
 831           return __p;
 832       return 0;
 833     }
 834
 835   // Insert v in bucket n (assumes no element with its key already present).
 836   template<typename _Key, typename _Value,
 837            typename _Allocator, typename _ExtractKey, typename _Equal,
 838            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 839            bool __chc, bool __cit, bool __uk>
 840     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 841                         _H1, _H2, _Hash, _RehashPolicy,
 842                         __chc, __cit, __uk>::iterator
 843     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 844                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 845     _M_insert_bucket(const value_type& __v, size_type __n,
 846                     typename _Hashtable::_Hash_code_type __code)
 847     {
 848       std::pair<bool, std::size_t> __do_rehash
 849         = _M_rehash_policy._M_need_rehash(_M_bucket_count,
 850                                           _M_element_count, 1);
 851
 852       // Allocate the new node before doing the rehash so that we don't
 853       // do a rehash if the allocation throws.
 854       _Node* __new_node = _M_allocate_node(__v);
 855
 856       __try
 857         {
 858           if (__do_rehash.first)
 859             {
 860               const key_type& __k = this->_M_extract(__v);
 861               __n = this->_M_bucket_index(__k, __code, __do_rehash.second);
 862               _M_rehash(__do_rehash.second);
 863             }
 864
 865           __new_node->_M_next = _M_buckets[__n];
 866           this->_M_store_code(__new_node, __code);
 867           _M_buckets[__n] = __new_node;
 868           ++_M_element_count;
 869           return iterator(__new_node, _M_buckets + __n);
 870         }
 871       __catch(...)
 872         {
 873           _M_deallocate_node(__new_node);
 874           __throw_exception_again;
 875         }
 876     }
 877
 878   // Insert v if no element with its key is already present.
 879   template<typename _Key, typename _Value,
 880            typename _Allocator, typename _ExtractKey, typename _Equal,
 881            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 882            bool __chc, bool __cit, bool __uk>
 883     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
 884                                   _ExtractKey, _Equal, _H1,
 885                                   _H2, _Hash, _RehashPolicy,
 886                                   __chc, __cit, __uk>::iterator, bool>
 887     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 888                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 889   _M_insert(const value_type& __v, std::tr1::true_type)
 890     {
 891       const key_type& __k = this->_M_extract(__v);
 892       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 893       size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 894
 895       if (_Node* __p = _M_find_node(_M_buckets[__n], __k, __code))
 896         return std::make_pair(iterator(__p, _M_buckets + __n), false);
 897       return std::make_pair(_M_insert_bucket(__v, __n, __code), true);
 898     }
 899
 900   // Insert v unconditionally.
 901   template<typename _Key, typename _Value,
 902            typename _Allocator, typename _ExtractKey, typename _Equal,
 903            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 904            bool __chc, bool __cit, bool __uk>
 905     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 906                         _H1, _H2, _Hash, _RehashPolicy,
 907                         __chc, __cit, __uk>::iterator
 908     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 909                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 910     _M_insert(const value_type& __v, std::tr1::false_type)
 911     {
 912       std::pair<bool, std::size_t> __do_rehash
 913         = _M_rehash_policy._M_need_rehash(_M_bucket_count,
 914                                           _M_element_count, 1);
 915       if (__do_rehash.first)
 916         _M_rehash(__do_rehash.second);
 917
 918       const key_type& __k = this->_M_extract(__v);
 919       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
 920       size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
 921
 922       // First find the node, avoid leaking new_node if compare throws.
 923       _Node* __prev = _M_find_node(_M_buckets[__n], __k, __code);
 924       _Node* __new_node = _M_allocate_node(__v);
 925
 926       if (__prev)
 927         {
 928           __new_node->_M_next = __prev->_M_next;
 929           __prev->_M_next = __new_node;
 930         }
 931       else
 932         {
 933           __new_node->_M_next = _M_buckets[__n];
 934           _M_buckets[__n] = __new_node;
 935         }
 936       this->_M_store_code(__new_node, __code);
 937
 938       ++_M_element_count;
 939       return iterator(__new_node, _M_buckets + __n);
 940     }
 941
 942   // For erase(iterator) and erase(const_iterator).
 943   template<typename _Key, typename _Value,
 944            typename _Allocator, typename _ExtractKey, typename _Equal,
 945            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 946            bool __chc, bool __cit, bool __uk>
 947     void
 948     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 949                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 950     _M_erase_node(_Node* __p, _Node** __b)
 951     {
 952       _Node* __cur = *__b;
 953       if (__cur == __p)
 954         *__b = __cur->_M_next;
 955       else
 956         {
 957           _Node* __next = __cur->_M_next;
 958           while (__next != __p)
 959             {
 960               __cur = __next;
 961               __next = __cur->_M_next;
 962             }
 963           __cur->_M_next = __next->_M_next;
 964         }
 965
 966       _M_deallocate_node(__p);
 967       --_M_element_count;
 968     }
 969
 970   template<typename _Key, typename _Value,
 971            typename _Allocator, typename _ExtractKey, typename _Equal,
 972            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 973            bool __chc, bool __cit, bool __uk>
 974     template<typename _InputIterator>
 975       void
 976       _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 977                  _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
 978       insert(_InputIterator __first, _InputIterator __last)
 979       {
 980         size_type __n_elt = __detail::__distance_fw(__first, __last);
 981         std::pair<bool, std::size_t> __do_rehash
 982           = _M_rehash_policy._M_need_rehash(_M_bucket_count,
 983                                             _M_element_count, __n_elt);
 984         if (__do_rehash.first)
 985           _M_rehash(__do_rehash.second);
 986
 987         for (; __first != __last; ++__first)
 988           this->insert(*__first);
 989       }
 990
 991   template<typename _Key, typename _Value,
 992            typename _Allocator, typename _ExtractKey, typename _Equal,
 993            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
 994            bool __chc, bool __cit, bool __uk>
 995     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 996                         _H1, _H2, _Hash, _RehashPolicy,
 997                         __chc, __cit, __uk>::iterator
 998     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
 999                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1000     erase(iterator __it)
1001     {
1002       iterator __result = __it;
1003       ++__result;
1004       _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
1005       return __result;
1006     }
1007
1008   template<typename _Key, typename _Value,
1009            typename _Allocator, typename _ExtractKey, typename _Equal,
1010            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1011            bool __chc, bool __cit, bool __uk>
1012     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1013                         _H1, _H2, _Hash, _RehashPolicy,
1014                         __chc, __cit, __uk>::const_iterator
1015     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1016                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1017     erase(const_iterator __it)
1018     {
1019       const_iterator __result = __it;
1020       ++__result;
1021       _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
1022       return __result;
1023     }
1024
1025   template<typename _Key, typename _Value,
1026            typename _Allocator, typename _ExtractKey, typename _Equal,
1027            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1028            bool __chc, bool __cit, bool __uk>
1029     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1030                         _H1, _H2, _Hash, _RehashPolicy,
1031                         __chc, __cit, __uk>::size_type
1032     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1033                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1034     erase(const key_type& __k)
1035     {
1036       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
1037       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
1038       size_type __result = 0;
1039
1040       _Node** __slot = _M_buckets + __n;
1041       while (*__slot && !this->_M_compare(__k, __code, *__slot))
1042         __slot = &((*__slot)->_M_next);
1043
1044       _Node** __saved_slot = 0;
1045       while (*__slot && this->_M_compare(__k, __code, *__slot))
1046         {
1047           // _GLIBCXX_RESOLVE_LIB_DEFECTS
1048           // 526. Is it undefined if a function in the standard changes
1049           // in parameters?
1050           if (&this->_M_extract((*__slot)->_M_v) != &__k)
1051             {
1052               _Node* __p = *__slot;
1053               *__slot = __p->_M_next;
1054               _M_deallocate_node(__p);
1055               --_M_element_count;
1056               ++__result;
1057             }
1058           else
1059             {
1060               __saved_slot = __slot;
1061               __slot = &((*__slot)->_M_next);
1062             }
1063         }
1064
1065       if (__saved_slot)
1066         {
1067           _Node* __p = *__saved_slot;
1068           *__saved_slot = __p->_M_next;
1069           _M_deallocate_node(__p);
1070           --_M_element_count;
1071           ++__result;
1072         }
1073
1074       return __result;
1075     }
1076
1077   // ??? This could be optimized by taking advantage of the bucket
1078   // structure, but it's not clear that it's worth doing.  It probably
1079   // wouldn't even be an optimization unless the load factor is large.
1080   template<typename _Key, typename _Value,
1081            typename _Allocator, typename _ExtractKey, typename _Equal,
1082            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1083            bool __chc, bool __cit, bool __uk>
1084     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1085                         _H1, _H2, _Hash, _RehashPolicy,
1086                         __chc, __cit, __uk>::iterator
1087     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1088                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1089     erase(iterator __first, iterator __last)
1090     {
1091       while (__first != __last)
1092         __first = this->erase(__first);
1093       return __last;
1094     }
1095
1096   template<typename _Key, typename _Value,
1097            typename _Allocator, typename _ExtractKey, typename _Equal,
1098            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1099            bool __chc, bool __cit, bool __uk>
1100     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1101                         _H1, _H2, _Hash, _RehashPolicy,
1102                         __chc, __cit, __uk>::const_iterator
1103     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1104                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1105     erase(const_iterator __first, const_iterator __last)
1106     {
1107       while (__first != __last)
1108         __first = this->erase(__first);
1109       return __last;
1110     }
1111
1112   template<typename _Key, typename _Value,
1113            typename _Allocator, typename _ExtractKey, typename _Equal,
1114            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1115            bool __chc, bool __cit, bool __uk>
1116     void
1117     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1118                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1119     clear()
1120     {
1121       _M_deallocate_nodes(_M_buckets, _M_bucket_count);
1122       _M_element_count = 0;
1123     }
1124
1125   template<typename _Key, typename _Value,
1126            typename _Allocator, typename _ExtractKey, typename _Equal,
1127            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1128            bool __chc, bool __cit, bool __uk>
1129     void
1130     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1131                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1132     rehash(size_type __n)
1133     {
1134       _M_rehash(std::max(_M_rehash_policy._M_next_bkt(__n),
1135                          _M_rehash_policy._M_bkt_for_elements(_M_element_count
1136                                                               + 1)));
1137     }
1138
1139   template<typename _Key, typename _Value,
1140            typename _Allocator, typename _ExtractKey, typename _Equal,
1141            typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
1142            bool __chc, bool __cit, bool __uk>
1143     void
1144     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
1145                _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
1146     _M_rehash(size_type __n)
1147     {
1148       _Node** __new_array = _M_allocate_buckets(__n);
1149       __try
1150         {
1151           for (size_type __i = 0; __i < _M_bucket_count; ++__i)
1152             while (_Node* __p = _M_buckets[__i])
1153               {
1154                 std::size_t __new_index = this->_M_bucket_index(__p, __n);
1155                 _M_buckets[__i] = __p->_M_next;
1156                 __p->_M_next = __new_array[__new_index];
1157                 __new_array[__new_index] = __p;
1158               }
1159           _M_deallocate_buckets(_M_buckets, _M_bucket_count);
1160           _M_bucket_count = __n;
1161           _M_buckets = __new_array;
1162         }
1163       __catch(...)
1164         {
1165           // A failure here means that a hash function threw an exception.
1166           // We can't restore the previous state without calling the hash
1167           // function again, so the only sensible recovery is to delete
1168           // everything.
1169           _M_deallocate_nodes(__new_array, __n);
1170           _M_deallocate_buckets(__new_array, __n);
1171           _M_deallocate_nodes(_M_buckets, _M_bucket_count);
1172           _M_element_count = 0;
1173           __throw_exception_again;
1174         }
1175     }
1176
1177 _GLIBCXX_END_NAMESPACE_VERSION
1178 } // namespace tr1
1179 } // namespace std
1180
1181 #endif // _GLIBCXX_TR1_HASHTABLE_H