libstdc++-v3/include/tr1/hashtable

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