| 
| template<class _InputIterator >  | 
|   | hash_map (_InputIterator __f, _InputIterator __l) | 
|   | 
| template<class _InputIterator >  | 
|   | hash_map (_InputIterator __f, _InputIterator __l, size_type __n) | 
|   | 
| template<class _InputIterator >  | 
|   | hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf) | 
|   | 
| template<class _InputIterator >  | 
|   | hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type()) | 
|   | 
|   | hash_map (size_type __n) | 
|   | 
|   | hash_map (size_type __n, const hasher &__hf) | 
|   | 
|   | hash_map (size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type()) | 
|   | 
| iterator  | begin () | 
|   | 
| const_iterator  | begin () const | 
|   | 
| size_type  | bucket_count () const | 
|   | 
| void  | clear () | 
|   | 
| size_type  | count (const key_type &__key) const | 
|   | 
| size_type  | elems_in_bucket (size_type __n) const | 
|   | 
| bool  | empty () const | 
|   | 
| iterator  | end () | 
|   | 
| const_iterator  | end () const | 
|   | 
| pair< iterator, iterator >  | equal_range (const key_type &__key) | 
|   | 
| pair< const_iterator, const_iterator >  | equal_range (const key_type &__key) const | 
|   | 
| size_type  | erase (const key_type &__key) | 
|   | 
| void  | erase (iterator __f, iterator __l) | 
|   | 
| void  | erase (iterator __it) | 
|   | 
| iterator  | find (const key_type &__key) | 
|   | 
| const_iterator  | find (const key_type &__key) const | 
|   | 
| allocator_type  | get_allocator () const | 
|   | 
| hasher  | hash_funct () const | 
|   | 
| template<class _InputIterator >  | 
| void  | insert (_InputIterator __f, _InputIterator __l) | 
|   | 
| pair< iterator, bool >  | insert (const value_type &__obj) | 
|   | 
| pair< iterator, bool >  | insert_noresize (const value_type &__obj) | 
|   | 
| key_equal  | key_eq () const | 
|   | 
| size_type  | max_bucket_count () const | 
|   | 
| size_type  | max_size () const | 
|   | 
| _Tp &  | operator[] (const key_type &__key) | 
|   | 
| void  | resize (size_type __hint) | 
|   | 
| size_type  | size () const | 
|   | 
| void  | swap (hash_map &__hs) | 
|   | 
 | 
| 
template<class _K1 , class _T1 , class _HF , class _EqK , class _Al >  | 
| bool  | operator== (const hash_map< _K1, _T1, _HF, _EqK, _Al > &, const hash_map< _K1, _T1, _HF, _EqK, _Al > &) | 
|   | 
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp>>
class __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
This is an SGI extension.
- Todo:
 - Needs documentation! See http://gcc.gnu.org/onlinedocs/libstdc++/manual/documentation_style.html 
 
Definition at line 83 of file hash_map.
 
◆ allocator_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::allocator_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::allocator_type | 
        
      
 
 
◆ const_iterator
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::const_iterator __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_iterator | 
        
      
 
 
◆ const_pointer
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::const_pointer __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_pointer | 
        
      
 
 
◆ const_reference
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::const_reference __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_reference | 
        
      
 
 
◆ data_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ difference_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::difference_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::difference_type | 
        
      
 
 
◆ hasher
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ iterator
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ key_equal
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ key_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ mapped_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ pointer
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ reference
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ size_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
 
 
◆ value_type
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
      
        
          | typedef _Ht::value_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::value_type | 
        
      
 
 
◆ hash_map() [1/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ hash_map() [2/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ hash_map() [3/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          size_type  | 
          __n,  | 
         
        
           | 
           | 
          const hasher &  | 
          __hf  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_map() [4/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          size_type  | 
          __n,  | 
         
        
           | 
           | 
          const hasher &  | 
          __hf,  | 
         
        
           | 
           | 
          const key_equal &  | 
          __eql,  | 
         
        
           | 
           | 
          const allocator_type &  | 
          __a = allocator_type()  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_map() [5/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
template<class _InputIterator > 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          _InputIterator  | 
          __f,  | 
         
        
           | 
           | 
          _InputIterator  | 
          __l  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_map() [6/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
template<class _InputIterator > 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          _InputIterator  | 
          __f,  | 
         
        
           | 
           | 
          _InputIterator  | 
          __l,  | 
         
        
           | 
           | 
          size_type  | 
          __n  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_map() [7/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
template<class _InputIterator > 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          _InputIterator  | 
          __f,  | 
         
        
           | 
           | 
          _InputIterator  | 
          __l,  | 
         
        
           | 
           | 
          size_type  | 
          __n,  | 
         
        
           | 
           | 
          const hasher &  | 
          __hf  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_map() [8/8]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
template<class _InputIterator > 
  
  
      
        
          | __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_map  | 
          ( | 
          _InputIterator  | 
          __f,  | 
         
        
           | 
           | 
          _InputIterator  | 
          __l,  | 
         
        
           | 
           | 
          size_type  | 
          __n,  | 
         
        
           | 
           | 
          const hasher &  | 
          __hf,  | 
         
        
           | 
           | 
          const key_equal &  | 
          __eql,  | 
         
        
           | 
           | 
          const allocator_type &  | 
          __a = allocator_type()  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ begin() [1/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ begin() [2/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ bucket_count()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ clear()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ count()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | size_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::count  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ elems_in_bucket()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | size_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::elems_in_bucket  | 
          ( | 
          size_type  | 
          __n | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ empty()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ end() [1/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ end() [2/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ equal_range() [1/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | pair< iterator, iterator > __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::equal_range  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ equal_range() [2/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | pair< const_iterator, const_iterator > __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::equal_range  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ erase() [1/3]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | size_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::erase  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ erase() [2/3]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | void __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::erase  | 
          ( | 
          iterator  | 
          __f,  | 
         
        
           | 
           | 
          iterator  | 
          __l  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ erase() [3/3]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ find() [1/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | iterator __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::find  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ find() [2/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | const_iterator __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::find  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ get_allocator()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | allocator_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::get_allocator  | 
          ( | 
           | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ hash_funct()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ insert() [1/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
template<class _InputIterator > 
  
  
      
        
          | void __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert  | 
          ( | 
          _InputIterator  | 
          __f,  | 
         
        
           | 
           | 
          _InputIterator  | 
          __l  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ insert() [2/2]
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | pair< iterator, bool > __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert  | 
          ( | 
          const value_type &  | 
          __obj | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ insert_noresize()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | pair< iterator, bool > __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert_noresize  | 
          ( | 
          const value_type &  | 
          __obj | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ key_eq()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ max_bucket_count()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | size_type __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::max_bucket_count  | 
          ( | 
           | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
 
◆ max_size()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ operator[]()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
  
  
      
        
          | _Tp & __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::operator[]  | 
          ( | 
          const key_type &  | 
          __key | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ resize()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ size()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
◆ swap()
template<class _Key , class _Tp , class _HashFn  = hash<_Key>, class _EqualKey  = equal_to<_Key>, class _Alloc  = allocator<_Tp>> 
 
 
The documentation for this class was generated from the following file: