hashtable

Go to the documentation of this file.
00001 // Internal header for TR1 unordered_set and unordered_map -*- C++ -*-
00002 
00003 // Copyright (C) 2005, 2006 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 2, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // You should have received a copy of the GNU General Public License along
00017 // with this library; see the file COPYING.  If not, write to the Free
00018 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00019 // USA.
00020 
00021 // As a special exception, you may use this file as part of a free software
00022 // library without restriction.  Specifically, if other files instantiate
00023 // templates or use macros or inline functions from this file, or you compile
00024 // this file and link it with other files to produce an executable, this
00025 // file does not by itself cause the resulting executable to be covered by
00026 // the GNU General Public License.  This exception does not however
00027 // invalidate any other reasons why the executable file might be covered by
00028 // the GNU General Public License.
00029 
00030 /** @file tr1/hashtable
00031  *  This is a TR1 C++ Library header. 
00032  */
00033 
00034 // This header file defines std::tr1::hashtable, which is used to
00035 // implement std::tr1::unordered_set, std::tr1::unordered_map, 
00036 // std::tr1::unordered_multiset, and std::tr1::unordered_multimap.
00037 // hashtable has many template parameters, partly to accommodate
00038 // the differences between those four classes and partly to 
00039 // accommodate policy choices that go beyond what TR1 calls for.
00040 
00041 // Class template hashtable attempts to encapsulate all reasonable
00042 // variation among hash tables that use chaining.  It does not handle
00043 // open addressing.
00044 
00045 // References: 
00046 // M. Austern, "A Proposal to Add Hash Tables to the Standard
00047 //    Library (revision 4)," WG21 Document N1456=03-0039, 2003.
00048 // D. E. Knuth, The Art of Computer Programming, v. 3, Sorting and Searching.
00049 // A. Tavori and V. Dreizin, "Policy-Based Data Structures", 2004.
00050 // http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html
00051 
00052 #ifndef _TR1_HASHTABLE
00053 #define _TR1_HASHTABLE 1
00054 
00055 #include <utility>      // For std::pair
00056 #include <memory>
00057 #include <iterator>
00058 #include <cstddef>
00059 #include <cstdlib>
00060 #include <cmath>
00061 #include <bits/functexcept.h>
00062 #include <tr1/type_traits>  // For true_type and false_type
00063 #include <tr1/hashtable_policy.h>
00064 
00065 namespace std
00066 { 
00067 _GLIBCXX_BEGIN_NAMESPACE(tr1)
00068 
00069   // Class template _Hashtable, class definition.
00070   
00071   // Meaning of class template _Hashtable's template parameters
00072   
00073   // _Key and _Value: arbitrary CopyConstructible types.
00074   
00075   // _Allocator: an allocator type ([lib.allocator.requirements]) whose
00076   // value type is Value.  As a conforming extension, we allow for
00077   // value type != Value.
00078 
00079   // _ExtractKey: function object that takes a object of type Value
00080   // and returns a value of type _Key.
00081   
00082   // _Equal: function object that takes two objects of type k and returns
00083   // a bool-like value that is true if the two objects are considered equal.
00084   
00085   // _H1: the hash function.  A unary function object with argument type
00086   // Key and result type size_t.  Return values should be distributed
00087   // over the entire range [0, numeric_limits<size_t>:::max()].
00088   
00089   // _H2: the range-hashing function (in the terminology of Tavori and
00090   // Dreizin).  A binary function object whose argument types and result
00091   // type are all size_t.  Given arguments r and N, the return value is
00092   // in the range [0, N).
00093   
00094   // _Hash: the ranged hash function (Tavori and Dreizin). A binary function
00095   // whose argument types are _Key and size_t and whose result type is
00096   // size_t.  Given arguments k and N, the return value is in the range
00097   // [0, N).  Default: hash(k, N) = h2(h1(k), N).  If _Hash is anything other
00098   // than the default, _H1 and _H2 are ignored.
00099   
00100   // _RehashPolicy: Policy class with three members, all of which govern
00101   // the bucket count. _M_next_bkt(n) returns a bucket count no smaller
00102   // than n.  _M_bkt_for_elements(n) returns a bucket count appropriate
00103   // for an element count of n.  _M_need_rehash(n_bkt, n_elt, n_ins)
00104   // determines whether, if the current bucket count is n_bkt and the
00105   // current element count is n_elt, we need to increase the bucket
00106   // count.  If so, returns make_pair(true, n), where n is the new
00107   // bucket count.  If not, returns make_pair(false, <anything>).
00108   
00109   // ??? Right now it is hard-wired that the number of buckets never
00110   // shrinks.  Should we allow _RehashPolicy to change that?
00111   
00112   // __cache_hash_code: bool.  true if we store the value of the hash
00113   // function along with the value.  This is a time-space tradeoff.
00114   // Storing it may improve lookup speed by reducing the number of times
00115   // we need to call the Equal function.
00116   
00117   // __constant_iterators: bool.  true if iterator and const_iterator are
00118   // both constant iterator types.  This is true for unordered_set and
00119   // unordered_multiset, false for unordered_map and unordered_multimap.
00120   
00121   // __unique_keys: bool.  true if the return value of _Hashtable::count(k)
00122   // is always at most one, false if it may be an arbitrary number.  This
00123   // true for unordered_set and unordered_map, false for unordered_multiset
00124   // and unordered_multimap.
00125   
00126   template<typename _Key, typename _Value, typename _Allocator,
00127        typename _ExtractKey, typename _Equal,
00128        typename _H1, typename _H2, typename _Hash, 
00129        typename _RehashPolicy,
00130        bool __cache_hash_code,
00131        bool __constant_iterators,
00132        bool __unique_keys>
00133     class _Hashtable
00134     : public __detail::_Rehash_base<_RehashPolicy,
00135                     _Hashtable<_Key, _Value, _Allocator,
00136                            _ExtractKey,
00137                            _Equal, _H1, _H2, _Hash,
00138                            _RehashPolicy,
00139                            __cache_hash_code,
00140                            __constant_iterators,
00141                            __unique_keys> >,
00142       public __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
00143                        _H1, _H2, _Hash, __cache_hash_code>,
00144       public __detail::_Map_base<_Key, _Value, _ExtractKey, __unique_keys,
00145                  _Hashtable<_Key, _Value, _Allocator,
00146                         _ExtractKey,
00147                         _Equal, _H1, _H2, _Hash,
00148                         _RehashPolicy,
00149                         __cache_hash_code,
00150                         __constant_iterators,
00151                         __unique_keys> >
00152     {
00153     public:
00154       typedef _Allocator                                  allocator_type;
00155       typedef _Value                                      value_type;
00156       typedef _Key                                        key_type;
00157       typedef _Equal                                      key_equal;
00158       // mapped_type, if present, comes from _Map_base.
00159       // hasher, if present, comes from _Hash_code_base.
00160       typedef typename _Allocator::difference_type        difference_type;
00161       typedef typename _Allocator::size_type              size_type;
00162       typedef typename _Allocator::reference              reference;
00163       typedef typename _Allocator::const_reference        const_reference;
00164       
00165       typedef __detail::_Node_iterator<value_type, __constant_iterators,
00166                        __cache_hash_code>
00167                                                           local_iterator;
00168       typedef __detail::_Node_const_iterator<value_type,
00169                          __constant_iterators,
00170                          __cache_hash_code>
00171                                                           const_local_iterator;
00172 
00173       typedef __detail::_Hashtable_iterator<value_type, __constant_iterators,
00174                         __cache_hash_code>
00175                                                           iterator;
00176       typedef __detail::_Hashtable_const_iterator<value_type,
00177                           __constant_iterators,
00178                           __cache_hash_code>
00179                                                           const_iterator;
00180 
00181       template<typename _Key2, typename _Pair, typename _Hashtable>
00182         friend struct __detail::_Map_base;
00183 
00184     private:
00185       typedef __detail::_Hash_node<_Value, __cache_hash_code> _Node;
00186       typedef typename _Allocator::template rebind<_Node>::other
00187                                                         _Node_allocator_type;
00188       typedef typename _Allocator::template rebind<_Node*>::other
00189                                                         _Bucket_allocator_type;
00190 
00191       typedef typename _Allocator::template rebind<_Value>::other
00192                                                         _Value_allocator_type;
00193 
00194       _Node_allocator_type   _M_node_allocator;
00195       _Node**                _M_buckets;
00196       size_type              _M_bucket_count;
00197       size_type              _M_element_count;
00198       _RehashPolicy          _M_rehash_policy;
00199       
00200       _Node*
00201       _M_allocate_node(const value_type& __v);
00202   
00203       void
00204       _M_deallocate_node(_Node* __n);
00205   
00206       void
00207       _M_deallocate_nodes(_Node**, size_type);
00208 
00209       _Node**
00210       _M_allocate_buckets(size_type __n);
00211   
00212       void
00213       _M_deallocate_buckets(_Node**, size_type __n);
00214 
00215     public:             
00216       // Constructor, destructor, assignment, swap
00217       _Hashtable(size_type __bucket_hint,
00218          const _H1&, const _H2&, const _Hash&,
00219          const _Equal&, const _ExtractKey&,
00220          const allocator_type&);
00221   
00222       template<typename _InputIterator>
00223         _Hashtable(_InputIterator __first, _InputIterator __last,
00224            size_type __bucket_hint,
00225            const _H1&, const _H2&, const _Hash&, 
00226            const _Equal&, const _ExtractKey&,
00227            const allocator_type&);
00228   
00229       _Hashtable(const _Hashtable&);
00230       
00231       _Hashtable&
00232       operator=(const _Hashtable&);
00233   
00234       ~_Hashtable();
00235 
00236       void swap(_Hashtable&);
00237 
00238       // Basic container operations
00239       iterator
00240       begin()
00241       {
00242     iterator __i(_M_buckets);
00243     if (!__i._M_cur_node)
00244       __i._M_incr_bucket();
00245     return __i;
00246       }
00247 
00248       const_iterator
00249       begin() const
00250       {
00251     const_iterator __i(_M_buckets);
00252     if (!__i._M_cur_node)
00253       __i._M_incr_bucket();
00254     return __i;
00255       }
00256 
00257       iterator
00258       end()
00259       { return iterator(_M_buckets + _M_bucket_count); }
00260 
00261       const_iterator
00262       end() const
00263       { return const_iterator(_M_buckets + _M_bucket_count); }
00264 
00265       size_type
00266       size() const
00267       { return _M_element_count; }
00268   
00269       bool
00270       empty() const
00271       { return size() == 0; }
00272 
00273       allocator_type
00274       get_allocator() const
00275       { return allocator_type(_M_node_allocator); }
00276 
00277       _Value_allocator_type
00278       _M_get_Value_allocator() const
00279       { return _Value_allocator_type(_M_node_allocator); }
00280 
00281       size_type
00282       max_size() const
00283       { return _M_get_Value_allocator().max_size(); }
00284 
00285       // Observers
00286       key_equal
00287       key_eq() const
00288       { return this->_M_eq; }
00289 
00290       // hash_function, if present, comes from _Hash_code_base.
00291 
00292       // Bucket operations
00293       size_type
00294       bucket_count() const
00295       { return _M_bucket_count; }
00296   
00297       size_type
00298       max_bucket_count() const
00299       { return max_size(); }
00300   
00301       size_type
00302       bucket_size(size_type __n) const
00303       { return std::distance(begin(__n), end(__n)); }
00304   
00305       size_type
00306       bucket(const key_type& __k) const
00307       { 
00308     return this->_M_bucket_index(__k, this->_M_hash_code(__k),
00309                      bucket_count());
00310       }
00311 
00312       local_iterator
00313       begin(size_type __n)
00314       { return local_iterator(_M_buckets[__n]); }
00315   
00316       local_iterator
00317       end(size_type)
00318       { return local_iterator(0); }
00319   
00320       const_local_iterator
00321       begin(size_type __n) const
00322       { return const_local_iterator(_M_buckets[__n]); }
00323   
00324       const_local_iterator
00325       end(size_type) const
00326       { return const_local_iterator(0); }
00327 
00328       float
00329       load_factor() const
00330       { 
00331     return static_cast<float>(size()) / static_cast<float>(bucket_count());
00332       }
00333 
00334       // max_load_factor, if present, comes from _Rehash_base.
00335 
00336       // Generalization of max_load_factor.  Extension, not found in TR1.  Only
00337       // useful if _RehashPolicy is something other than the default.
00338       const _RehashPolicy&
00339       __rehash_policy() const
00340       { return _M_rehash_policy; }
00341       
00342       void 
00343       __rehash_policy(const _RehashPolicy&);
00344 
00345       // Lookup.
00346       iterator
00347       find(const key_type& __k);
00348 
00349       const_iterator
00350       find(const key_type& __k) const;
00351 
00352       size_type
00353       count(const key_type& __k) const;
00354 
00355       std::pair<iterator, iterator>
00356       equal_range(const key_type& __k);
00357 
00358       std::pair<const_iterator, const_iterator>
00359       equal_range(const key_type& __k) const;
00360 
00361     private:            // Find, insert and erase helper functions
00362       // ??? This dispatching is a workaround for the fact that we don't
00363       // have partial specialization of member templates; it would be
00364       // better to just specialize insert on __unique_keys.  There may be a
00365       // cleaner workaround.
00366       typedef typename __gnu_cxx::__conditional_type<__unique_keys,
00367                     std::pair<iterator, bool>, iterator>::__type
00368         _Insert_Return_Type;
00369 
00370       typedef typename __gnu_cxx::__conditional_type<__unique_keys,
00371                       std::_Select1st<_Insert_Return_Type>,
00372                       std::_Identity<_Insert_Return_Type>
00373                                    >::__type
00374         _Insert_Conv_Type;
00375 
00376       _Node*
00377       _M_find_node(_Node*, const key_type&,
00378            typename _Hashtable::_Hash_code_type) const;
00379 
00380       iterator
00381       _M_insert_bucket(const value_type&, size_type,
00382                typename _Hashtable::_Hash_code_type);
00383 
00384       std::pair<iterator, bool>
00385       _M_insert(const value_type&, std::tr1::true_type);
00386 
00387       iterator
00388       _M_insert(const value_type&, std::tr1::false_type);
00389 
00390       void
00391       _M_erase_node(_Node*, _Node**);
00392 
00393     public:             
00394       // Insert and erase
00395       _Insert_Return_Type
00396       insert(const value_type& __v) 
00397       { return _M_insert(__v, std::tr1::integral_constant<bool,
00398              __unique_keys>()); }
00399 
00400       iterator
00401       insert(iterator, const value_type& __v)
00402       { return iterator(_Insert_Conv_Type()(this->insert(__v))); }
00403 
00404       const_iterator
00405       insert(const_iterator, const value_type& __v)
00406       { return const_iterator(_Insert_Conv_Type()(this->insert(__v))); }
00407 
00408       template<typename _InputIterator>
00409         void
00410         insert(_InputIterator __first, _InputIterator __last);
00411 
00412       iterator
00413       erase(iterator);
00414 
00415       const_iterator
00416       erase(const_iterator);
00417 
00418       size_type
00419       erase(const key_type&);
00420 
00421       iterator
00422       erase(iterator, iterator);
00423 
00424       const_iterator
00425       erase(const_iterator, const_iterator);
00426 
00427       void
00428       clear();
00429 
00430       // Set number of buckets to be appropriate for container of n element.
00431       void rehash(size_type __n);
00432       
00433     private:
00434       // Unconditionally change size of bucket array to n.
00435       void _M_rehash(size_type __n);
00436     };
00437 
00438 
00439   // Definitions of class template _Hashtable's out-of-line member functions.
00440   template<typename _Key, typename _Value, 
00441        typename _Allocator, typename _ExtractKey, typename _Equal,
00442        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00443        bool __chc, bool __cit, bool __uk>
00444     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00445             _H1, _H2, _Hash, _RehashPolicy,
00446             __chc, __cit, __uk>::_Node*
00447     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00448            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00449     _M_allocate_node(const value_type& __v)
00450     {
00451       _Node* __n = _M_node_allocator.allocate(1);
00452       try
00453     {
00454       _M_get_Value_allocator().construct(&__n->_M_v, __v);
00455       __n->_M_next = 0;
00456       return __n;
00457     }
00458       catch(...)
00459     {
00460       _M_node_allocator.deallocate(__n, 1);
00461       __throw_exception_again;
00462     }
00463     }
00464 
00465   template<typename _Key, typename _Value, 
00466        typename _Allocator, typename _ExtractKey, typename _Equal,
00467        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00468        bool __chc, bool __cit, bool __uk>
00469     void
00470     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00471            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00472     _M_deallocate_node(_Node* __n)
00473     {
00474       _M_get_Value_allocator().destroy(&__n->_M_v);
00475       _M_node_allocator.deallocate(__n, 1);
00476     }
00477 
00478   template<typename _Key, typename _Value, 
00479        typename _Allocator, typename _ExtractKey, typename _Equal,
00480        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00481        bool __chc, bool __cit, bool __uk>
00482     void
00483     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00484            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00485     _M_deallocate_nodes(_Node** __array, size_type __n)
00486     {
00487       for (size_type __i = 0; __i < __n; ++__i)
00488     {
00489       _Node* __p = __array[__i];
00490       while (__p)
00491         {
00492           _Node* __tmp = __p;
00493           __p = __p->_M_next;
00494           _M_deallocate_node(__tmp);
00495         }
00496       __array[__i] = 0;
00497     }
00498     }
00499 
00500   template<typename _Key, typename _Value, 
00501        typename _Allocator, typename _ExtractKey, typename _Equal,
00502        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00503        bool __chc, bool __cit, bool __uk>
00504     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00505             _H1, _H2, _Hash, _RehashPolicy,
00506             __chc, __cit, __uk>::_Node**
00507     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00508            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00509     _M_allocate_buckets(size_type __n)
00510     {
00511       _Bucket_allocator_type __alloc(_M_node_allocator);
00512 
00513       // We allocate one extra bucket to hold a sentinel, an arbitrary
00514       // non-null pointer.  Iterator increment relies on this.
00515       _Node** __p = __alloc.allocate(__n + 1);
00516       std::fill(__p, __p + __n, (_Node*) 0);
00517       __p[__n] = reinterpret_cast<_Node*>(0x1000);
00518       return __p;
00519     }
00520 
00521   template<typename _Key, typename _Value, 
00522        typename _Allocator, typename _ExtractKey, typename _Equal,
00523        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00524        bool __chc, bool __cit, bool __uk>
00525     void
00526     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00527            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00528     _M_deallocate_buckets(_Node** __p, size_type __n)
00529     {
00530       _Bucket_allocator_type __alloc(_M_node_allocator);
00531       __alloc.deallocate(__p, __n + 1);
00532     }
00533 
00534   template<typename _Key, typename _Value, 
00535        typename _Allocator, typename _ExtractKey, typename _Equal,
00536        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00537        bool __chc, bool __cit, bool __uk>
00538     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00539            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00540     _Hashtable(size_type __bucket_hint,
00541            const _H1& __h1, const _H2& __h2, const _Hash& __h,
00542            const _Equal& __eq, const _ExtractKey& __exk,
00543            const allocator_type& __a)
00544     : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
00545       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
00546                 _H1, _H2, _Hash, __chc>(__exk, __eq,
00547                             __h1, __h2, __h),
00548       __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
00549       _M_node_allocator(__a),
00550       _M_bucket_count(0),
00551       _M_element_count(0),
00552       _M_rehash_policy()
00553     {
00554       _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint);
00555       _M_buckets = _M_allocate_buckets(_M_bucket_count);
00556     }
00557 
00558   template<typename _Key, typename _Value, 
00559        typename _Allocator, typename _ExtractKey, typename _Equal,
00560        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00561        bool __chc, bool __cit, bool __uk>
00562     template<typename _InputIterator>
00563       _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00564          _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00565       _Hashtable(_InputIterator __f, _InputIterator __l,
00566          size_type __bucket_hint,
00567          const _H1& __h1, const _H2& __h2, const _Hash& __h,
00568          const _Equal& __eq, const _ExtractKey& __exk,
00569          const allocator_type& __a)
00570       : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
00571     __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
00572                   _H1, _H2, _Hash, __chc>(__exk, __eq,
00573                               __h1, __h2, __h),
00574     __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
00575     _M_node_allocator(__a),
00576     _M_bucket_count(0),
00577     _M_element_count(0),
00578     _M_rehash_policy()
00579       {
00580     _M_bucket_count = std::max(_M_rehash_policy._M_next_bkt(__bucket_hint),
00581                    _M_rehash_policy.
00582                    _M_bkt_for_elements(__detail::
00583                                __distance_fw(__f,
00584                                      __l)));
00585     _M_buckets = _M_allocate_buckets(_M_bucket_count);
00586     try
00587       {
00588         for (; __f != __l; ++__f)
00589           this->insert(*__f);
00590       }
00591     catch(...)
00592       {
00593         clear();
00594         _M_deallocate_buckets(_M_buckets, _M_bucket_count);
00595         __throw_exception_again;
00596       }
00597       }
00598   
00599   template<typename _Key, typename _Value, 
00600        typename _Allocator, typename _ExtractKey, typename _Equal,
00601        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00602        bool __chc, bool __cit, bool __uk>
00603     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00604            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00605     _Hashtable(const _Hashtable& __ht)
00606     : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht),
00607       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
00608                 _H1, _H2, _Hash, __chc>(__ht),
00609       __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht),
00610       _M_node_allocator(__ht._M_node_allocator),
00611       _M_bucket_count(__ht._M_bucket_count),
00612       _M_element_count(__ht._M_element_count),
00613       _M_rehash_policy(__ht._M_rehash_policy)
00614     {
00615       _M_buckets = _M_allocate_buckets(_M_bucket_count);
00616       try
00617     {
00618       for (size_type __i = 0; __i < __ht._M_bucket_count; ++__i)
00619         {
00620           _Node* __n = __ht._M_buckets[__i];
00621           _Node** __tail = _M_buckets + __i;
00622           while (__n)
00623         {
00624           *__tail = _M_allocate_node(__n->_M_v);
00625           this->_M_copy_code(*__tail, __n);
00626           __tail = &((*__tail)->_M_next);
00627           __n = __n->_M_next;
00628         }
00629         }
00630     }
00631       catch(...)
00632     {
00633       clear();
00634       _M_deallocate_buckets(_M_buckets, _M_bucket_count);
00635       __throw_exception_again;
00636     }
00637     }
00638 
00639   template<typename _Key, typename _Value, 
00640        typename _Allocator, typename _ExtractKey, typename _Equal,
00641        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00642        bool __chc, bool __cit, bool __uk>
00643     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00644            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>&
00645     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00646            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00647     operator=(const _Hashtable& __ht)
00648     {
00649       _Hashtable __tmp(__ht);
00650       this->swap(__tmp);
00651       return *this;
00652     }
00653 
00654   template<typename _Key, typename _Value, 
00655        typename _Allocator, typename _ExtractKey, typename _Equal,
00656        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00657        bool __chc, bool __cit, bool __uk>
00658     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00659            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00660     ~_Hashtable()
00661     {
00662       clear();
00663       _M_deallocate_buckets(_M_buckets, _M_bucket_count);
00664     }
00665 
00666   template<typename _Key, typename _Value, 
00667        typename _Allocator, typename _ExtractKey, typename _Equal,
00668        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00669        bool __chc, bool __cit, bool __uk>
00670     void
00671     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00672            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00673     swap(_Hashtable& __x)
00674     {
00675       // The only base class with member variables is hash_code_base.  We
00676       // define _Hash_code_base::_M_swap because different specializations
00677       // have different members.
00678       __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
00679     _H1, _H2, _Hash, __chc>::_M_swap(__x);
00680 
00681       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00682       // 431. Swapping containers with unequal allocators.
00683       std::__alloc_swap<_Node_allocator_type>::_S_do_it(_M_node_allocator,
00684                             __x._M_node_allocator);
00685 
00686       std::swap(_M_rehash_policy, __x._M_rehash_policy);
00687       std::swap(_M_buckets, __x._M_buckets);
00688       std::swap(_M_bucket_count, __x._M_bucket_count);
00689       std::swap(_M_element_count, __x._M_element_count);
00690     }
00691 
00692   template<typename _Key, typename _Value, 
00693        typename _Allocator, typename _ExtractKey, typename _Equal,
00694        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00695        bool __chc, bool __cit, bool __uk>
00696     void
00697     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00698            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00699     __rehash_policy(const _RehashPolicy& __pol)
00700     {
00701       _M_rehash_policy = __pol;
00702       size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count);
00703       if (__n_bkt > _M_bucket_count)
00704     _M_rehash(__n_bkt);
00705     }
00706 
00707   template<typename _Key, typename _Value, 
00708        typename _Allocator, typename _ExtractKey, typename _Equal,
00709        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00710        bool __chc, bool __cit, bool __uk>
00711     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00712             _H1, _H2, _Hash, _RehashPolicy,
00713             __chc, __cit, __uk>::iterator
00714     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00715            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00716     find(const key_type& __k)
00717     {
00718       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00719       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00720       _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
00721       return __p ? iterator(__p, _M_buckets + __n) : this->end();
00722     }
00723 
00724   template<typename _Key, typename _Value, 
00725        typename _Allocator, typename _ExtractKey, typename _Equal,
00726        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00727        bool __chc, bool __cit, bool __uk>
00728     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00729             _H1, _H2, _Hash, _RehashPolicy,
00730             __chc, __cit, __uk>::const_iterator
00731     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00732            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00733     find(const key_type& __k) const
00734     {
00735       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00736       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00737       _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
00738       return __p ? const_iterator(__p, _M_buckets + __n) : this->end();
00739     }
00740 
00741   template<typename _Key, typename _Value, 
00742        typename _Allocator, typename _ExtractKey, typename _Equal,
00743        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00744        bool __chc, bool __cit, bool __uk>
00745     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00746             _H1, _H2, _Hash, _RehashPolicy,
00747             __chc, __cit, __uk>::size_type
00748     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00749            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00750     count(const key_type& __k) const
00751     {
00752       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00753       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00754       std::size_t __result = 0;
00755       for (_Node* __p = _M_buckets[__n]; __p; __p = __p->_M_next)
00756     if (this->_M_compare(__k, __code, __p))
00757       ++__result;
00758       return __result;
00759     }
00760 
00761   template<typename _Key, typename _Value, 
00762        typename _Allocator, typename _ExtractKey, typename _Equal,
00763        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00764        bool __chc, bool __cit, bool __uk>
00765     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
00766                   _ExtractKey, _Equal, _H1,
00767                   _H2, _Hash, _RehashPolicy,
00768                   __chc, __cit, __uk>::iterator,
00769           typename _Hashtable<_Key, _Value, _Allocator,
00770                   _ExtractKey, _Equal, _H1,
00771                   _H2, _Hash, _RehashPolicy,
00772                   __chc, __cit, __uk>::iterator>
00773     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00774            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00775     equal_range(const key_type& __k)
00776     {
00777       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00778       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00779       _Node** __head = _M_buckets + __n;
00780       _Node* __p = _M_find_node(*__head, __k, __code);
00781       
00782       if (__p)
00783     {
00784       _Node* __p1 = __p->_M_next;
00785       for (; __p1; __p1 = __p1->_M_next)
00786         if (!this->_M_compare(__k, __code, __p1))
00787           break;
00788 
00789       iterator __first(__p, __head);
00790       iterator __last(__p1, __head);
00791       if (!__p1)
00792         __last._M_incr_bucket();
00793       return std::make_pair(__first, __last);
00794     }
00795       else
00796     return std::make_pair(this->end(), this->end());
00797     }
00798 
00799   template<typename _Key, typename _Value, 
00800        typename _Allocator, typename _ExtractKey, typename _Equal,
00801        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00802        bool __chc, bool __cit, bool __uk>
00803     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
00804                   _ExtractKey, _Equal, _H1,
00805                   _H2, _Hash, _RehashPolicy,
00806                   __chc, __cit, __uk>::const_iterator,
00807           typename _Hashtable<_Key, _Value, _Allocator,
00808                   _ExtractKey, _Equal, _H1,
00809                   _H2, _Hash, _RehashPolicy,
00810                   __chc, __cit, __uk>::const_iterator>
00811     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00812            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00813     equal_range(const key_type& __k) const
00814     {
00815       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00816       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00817       _Node** __head = _M_buckets + __n;
00818       _Node* __p = _M_find_node(*__head, __k, __code);
00819 
00820       if (__p)
00821     {
00822       _Node* __p1 = __p->_M_next;
00823       for (; __p1; __p1 = __p1->_M_next)
00824         if (!this->_M_compare(__k, __code, __p1))
00825           break;
00826 
00827       const_iterator __first(__p, __head);
00828       const_iterator __last(__p1, __head);
00829       if (!__p1)
00830         __last._M_incr_bucket();
00831       return std::make_pair(__first, __last);
00832     }
00833       else
00834     return std::make_pair(this->end(), this->end());
00835     }
00836 
00837   // Find the node whose key compares equal to k, beginning the search
00838   // at p (usually the head of a bucket).  Return nil if no node is found.
00839   template<typename _Key, typename _Value, 
00840        typename _Allocator, typename _ExtractKey, typename _Equal,
00841        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00842        bool __chc, bool __cit, bool __uk>
00843     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey,
00844             _Equal, _H1, _H2, _Hash, _RehashPolicy,
00845             __chc, __cit, __uk>::_Node* 
00846     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00847            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00848     _M_find_node(_Node* __p, const key_type& __k,
00849         typename _Hashtable::_Hash_code_type __code) const
00850     {
00851       for (; __p; __p = __p->_M_next)
00852     if (this->_M_compare(__k, __code, __p))
00853       return __p;
00854       return false;
00855     }
00856 
00857   // Insert v in bucket n (assumes no element with its key already present).
00858   template<typename _Key, typename _Value, 
00859        typename _Allocator, typename _ExtractKey, typename _Equal,
00860        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00861        bool __chc, bool __cit, bool __uk>
00862     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00863             _H1, _H2, _Hash, _RehashPolicy,
00864             __chc, __cit, __uk>::iterator
00865     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00866            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00867     _M_insert_bucket(const value_type& __v, size_type __n,
00868             typename _Hashtable::_Hash_code_type __code)
00869     {
00870       std::pair<bool, std::size_t> __do_rehash
00871     = _M_rehash_policy._M_need_rehash(_M_bucket_count,
00872                       _M_element_count, 1);
00873 
00874       // Allocate the new node before doing the rehash so that we don't
00875       // do a rehash if the allocation throws.
00876       _Node* __new_node = _M_allocate_node(__v);
00877 
00878       try
00879     {
00880       if (__do_rehash.first)
00881         {
00882           const key_type& __k = this->_M_extract(__v);
00883           __n = this->_M_bucket_index(__k, __code, __do_rehash.second);
00884           _M_rehash(__do_rehash.second);
00885         }
00886 
00887       __new_node->_M_next = _M_buckets[__n];
00888       this->_M_store_code(__new_node, __code);
00889       _M_buckets[__n] = __new_node;
00890       ++_M_element_count;
00891       return iterator(__new_node, _M_buckets + __n);
00892     }
00893       catch(...)
00894     {
00895       _M_deallocate_node(__new_node);
00896       __throw_exception_again;
00897     }
00898     }
00899 
00900   // Insert v if no element with its key is already present.
00901   template<typename _Key, typename _Value, 
00902        typename _Allocator, typename _ExtractKey, typename _Equal,
00903        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00904        bool __chc, bool __cit, bool __uk>
00905     std::pair<typename _Hashtable<_Key, _Value, _Allocator,
00906                   _ExtractKey, _Equal, _H1,
00907                   _H2, _Hash, _RehashPolicy,
00908                   __chc, __cit, __uk>::iterator, bool>
00909     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00910            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00911     _M_insert(const value_type& __v, std::tr1::true_type)
00912     {
00913       const key_type& __k = this->_M_extract(__v);
00914       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00915       size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00916 
00917       if (_Node* __p = _M_find_node(_M_buckets[__n], __k, __code))
00918     return std::make_pair(iterator(__p, _M_buckets + __n), false);
00919       return std::make_pair(_M_insert_bucket(__v, __n, __code), true);
00920     }
00921   
00922   // Insert v unconditionally.
00923   template<typename _Key, typename _Value, 
00924        typename _Allocator, typename _ExtractKey, typename _Equal,
00925        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00926        bool __chc, bool __cit, bool __uk>
00927     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00928             _H1, _H2, _Hash, _RehashPolicy,
00929             __chc, __cit, __uk>::iterator
00930     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00931            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00932     _M_insert(const value_type& __v, std::tr1::false_type)
00933     {
00934       std::pair<bool, std::size_t> __do_rehash
00935     = _M_rehash_policy._M_need_rehash(_M_bucket_count,
00936                       _M_element_count, 1);
00937       if (__do_rehash.first)
00938     _M_rehash(__do_rehash.second);
00939  
00940       const key_type& __k = this->_M_extract(__v);
00941       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
00942       size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
00943 
00944       // First find the node, avoid leaking new_node if compare throws.
00945       _Node* __prev = _M_find_node(_M_buckets[__n], __k, __code);
00946       _Node* __new_node = _M_allocate_node(__v);
00947 
00948       if (__prev)
00949     {
00950       __new_node->_M_next = __prev->_M_next;
00951       __prev->_M_next = __new_node;
00952     }
00953       else
00954     {
00955       __new_node->_M_next = _M_buckets[__n];
00956       _M_buckets[__n] = __new_node;
00957     }
00958       this->_M_store_code(__new_node, __code);
00959 
00960       ++_M_element_count;
00961       return iterator(__new_node, _M_buckets + __n);
00962     }
00963 
00964   // For erase(iterator) and erase(const_iterator).
00965   template<typename _Key, typename _Value, 
00966        typename _Allocator, typename _ExtractKey, typename _Equal,
00967        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00968        bool __chc, bool __cit, bool __uk>
00969     void
00970     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00971            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
00972     _M_erase_node(_Node* __p, _Node** __b)
00973     {
00974       _Node* __cur = *__b;
00975       if (__cur == __p)
00976     *__b = __cur->_M_next;
00977       else
00978     {
00979       _Node* __next = __cur->_M_next;
00980       while (__next != __p)
00981         {
00982           __cur = __next;
00983           __next = __cur->_M_next;
00984         }
00985       __cur->_M_next = __next->_M_next;
00986     }
00987 
00988       _M_deallocate_node(__p);
00989       --_M_element_count;
00990     }
00991 
00992   template<typename _Key, typename _Value, 
00993        typename _Allocator, typename _ExtractKey, typename _Equal,
00994        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
00995        bool __chc, bool __cit, bool __uk>
00996     template<typename _InputIterator>
00997       void 
00998       _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
00999          _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01000       insert(_InputIterator __first, _InputIterator __last)
01001       {
01002     size_type __n_elt = __detail::__distance_fw(__first, __last);
01003     std::pair<bool, std::size_t> __do_rehash
01004       = _M_rehash_policy._M_need_rehash(_M_bucket_count,
01005                         _M_element_count, __n_elt);
01006     if (__do_rehash.first)
01007       _M_rehash(__do_rehash.second);
01008 
01009     for (; __first != __last; ++__first)
01010       this->insert(*__first);
01011       }
01012 
01013   template<typename _Key, typename _Value, 
01014        typename _Allocator, typename _ExtractKey, typename _Equal,
01015        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01016        bool __chc, bool __cit, bool __uk>
01017     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01018             _H1, _H2, _Hash, _RehashPolicy,
01019             __chc, __cit, __uk>::iterator
01020     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01021            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01022     erase(iterator __it)
01023     {
01024       iterator __result = __it;
01025       ++__result;
01026       _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
01027       return __result;
01028     }
01029 
01030   template<typename _Key, typename _Value, 
01031        typename _Allocator, typename _ExtractKey, typename _Equal,
01032        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01033        bool __chc, bool __cit, bool __uk>
01034     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01035             _H1, _H2, _Hash, _RehashPolicy,
01036             __chc, __cit, __uk>::const_iterator
01037     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01038            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01039     erase(const_iterator __it)
01040     {
01041       const_iterator __result = __it;
01042       ++__result;
01043       _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
01044       return __result;
01045     }
01046 
01047   template<typename _Key, typename _Value, 
01048        typename _Allocator, typename _ExtractKey, typename _Equal,
01049        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01050        bool __chc, bool __cit, bool __uk>
01051     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01052             _H1, _H2, _Hash, _RehashPolicy,
01053             __chc, __cit, __uk>::size_type
01054     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01055            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01056     erase(const key_type& __k)
01057     {
01058       typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
01059       std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
01060       size_type __result = 0;
01061       
01062       _Node** __slot = _M_buckets + __n;
01063       while (*__slot && !this->_M_compare(__k, __code, *__slot))
01064     __slot = &((*__slot)->_M_next);
01065 
01066       while (*__slot && this->_M_compare(__k, __code, *__slot))
01067     {
01068       _Node* __p = *__slot;
01069       *__slot = __p->_M_next;
01070       _M_deallocate_node(__p);
01071       --_M_element_count;
01072       ++__result;
01073     }
01074 
01075       return __result;
01076     }
01077 
01078   // ??? This could be optimized by taking advantage of the bucket
01079   // structure, but it's not clear that it's worth doing.  It probably
01080   // wouldn't even be an optimization unless the load factor is large.
01081   template<typename _Key, typename _Value, 
01082        typename _Allocator, typename _ExtractKey, typename _Equal,
01083        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01084        bool __chc, bool __cit, bool __uk>
01085     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01086             _H1, _H2, _Hash, _RehashPolicy,
01087             __chc, __cit, __uk>::iterator
01088     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01089            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01090     erase(iterator __first, iterator __last)
01091     {
01092       while (__first != __last)
01093     __first = this->erase(__first);
01094       return __last;
01095     }
01096   
01097   template<typename _Key, typename _Value, 
01098        typename _Allocator, typename _ExtractKey, typename _Equal,
01099        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01100        bool __chc, bool __cit, bool __uk>
01101     typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01102             _H1, _H2, _Hash, _RehashPolicy,
01103             __chc, __cit, __uk>::const_iterator
01104     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01105            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01106     erase(const_iterator __first, const_iterator __last)
01107     {
01108       while (__first != __last)
01109     __first = this->erase(__first);
01110       return __last;
01111     }
01112 
01113   template<typename _Key, typename _Value, 
01114        typename _Allocator, typename _ExtractKey, typename _Equal,
01115        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01116        bool __chc, bool __cit, bool __uk>
01117     void
01118     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01119            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01120     clear()
01121     {
01122       _M_deallocate_nodes(_M_buckets, _M_bucket_count);
01123       _M_element_count = 0;
01124     }
01125  
01126   template<typename _Key, typename _Value, 
01127        typename _Allocator, typename _ExtractKey, typename _Equal,
01128        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01129        bool __chc, bool __cit, bool __uk>
01130     void
01131     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01132            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01133     rehash(size_type __n)
01134     {
01135       _M_rehash(std::max(_M_rehash_policy._M_next_bkt(__n),
01136              _M_rehash_policy._M_bkt_for_elements(_M_element_count
01137                                   + 1)));
01138     }
01139 
01140   template<typename _Key, typename _Value, 
01141        typename _Allocator, typename _ExtractKey, typename _Equal,
01142        typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
01143        bool __chc, bool __cit, bool __uk>
01144     void
01145     _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
01146            _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
01147     _M_rehash(size_type __n)
01148     {
01149       _Node** __new_array = _M_allocate_buckets(__n);
01150       try
01151     {
01152       for (size_type __i = 0; __i < _M_bucket_count; ++__i)
01153         while (_Node* __p = _M_buckets[__i])
01154           {
01155         std::size_t __new_index = this->_M_bucket_index(__p, __n);
01156         _M_buckets[__i] = __p->_M_next;
01157         __p->_M_next = __new_array[__new_index];
01158         __new_array[__new_index] = __p;
01159           }
01160       _M_deallocate_buckets(_M_buckets, _M_bucket_count);
01161       _M_bucket_count = __n;
01162       _M_buckets = __new_array;
01163     }
01164       catch(...)
01165     {
01166       // A failure here means that a hash function threw an exception.
01167       // We can't restore the previous state without calling the hash
01168       // function again, so the only sensible recovery is to delete
01169       // everything.
01170       _M_deallocate_nodes(__new_array, __n);
01171       _M_deallocate_buckets(__new_array, __n);
01172       _M_deallocate_nodes(_M_buckets, _M_bucket_count);
01173       _M_element_count = 0;
01174       __throw_exception_again;
01175     }
01176     }
01177 
01178 _GLIBCXX_END_NAMESPACE
01179 } // namespace std::tr1
01180 
01181 #endif // _TR1_HASHTABLE
01182 

Generated on Thu Nov 1 13:11:58 2007 for libstdc++ by  doxygen 1.5.1