|  | 
| 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: