Back to index

salome-med  6.5.0
Public Types | Public Member Functions | Private Types | Private Attributes | Friends
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc > Class Template Reference

#include <InterpKernelHashMap.hxx>

Inheritance diagram for INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >:
Inheritance graph
[legend]
Collaboration diagram for INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >:
Collaboration graph
[legend]

List of all members.

Public Types

typedef _Ht::key_type key_type
typedef _Tp data_type
typedef _Tp mapped_type
typedef _Ht::value_type value_type
typedef _Ht::hasher hasher
typedef _Ht::key_equal key_equal
typedef _Ht::size_type size_type
typedef _Ht::difference_type difference_type
typedef _Ht::pointer pointer
typedef _Ht::const_pointer const_pointer
typedef _Ht::reference reference
typedef _Ht::const_reference const_reference
typedef _Ht::iterator iterator
typedef _Ht::const_iterator const_iterator
typedef _Ht::allocator_type allocator_type

Public Member Functions

hasher hash_funct () const
key_equal key_eq () const
allocator_type get_allocator () const
 HashMap ()
 HashMap (size_type __n)
 HashMap (size_type __n, const hasher &__hf)
 HashMap (size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type())
template<class _InputIterator >
 HashMap (_InputIterator __f, _InputIterator __l)
template<class _InputIterator >
 HashMap (_InputIterator __f, _InputIterator __l, size_type __n)
template<class _InputIterator >
 HashMap (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf)
template<class _InputIterator >
 HashMap (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type())
size_type size () const
size_type max_size () const
bool empty () const
void swap (HashMap &__hs)
iterator begin ()
iterator end ()
const_iterator begin () const
const_iterator end () const
std::pair< iterator, bool > insert (const value_type &__obj)
template<class _InputIterator >
void insert (_InputIterator __f, _InputIterator __l)
std::pair< iterator, bool > insert_noresize (const value_type &__obj)
iterator find (const key_type &__key)
const_iterator find (const key_type &__key) const
_Tp & operator[] (const key_type &__key)
size_type count (const key_type &__key) const
std::pair< iterator, iteratorequal_range (const key_type &__key)
std::pair< const_iterator,
const_iterator
equal_range (const key_type &__key) const
size_type erase (const key_type &__key)
void erase (iterator __it)
void erase (iterator __f, iterator __l)
void clear ()
void resize (size_type __hint)
size_type bucket_count () const
size_type max_bucket_count () const
size_type elems_in_bucket (size_type __n) const

Private Types

typedef hashtable< std::pair
< const _Key, _Tp >, _Key,
_HashFn, STLEXT::Select1st
< std::pair< const _Key, _Tp >
>, _EqualKey, _Alloc > 
_Ht

Private Attributes

_Ht _M_ht

Friends

template<class _K1 , class _T1 , class _HF , class _EqK , class _Al >
bool operator== (const HashMap< _K1, _T1, _HF, _EqK, _Al > &, const HashMap< _K1, _T1, _HF, _EqK, _Al > &)

Detailed Description

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
class INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >

Definition at line 58 of file InterpKernelHashMap.hxx.


Member Typedef Documentation

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef hashtable<std::pair<const _Key, _Tp>,_Key, _HashFn, STLEXT::Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc> INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::_Ht [private]

Definition at line 63 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::allocator_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::allocator_type

Definition at line 85 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::const_iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_iterator

Definition at line 83 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::const_pointer INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_pointer

Definition at line 78 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::const_reference INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::const_reference

Definition at line 80 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Tp INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::data_type

Definition at line 69 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::difference_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::difference_type

Definition at line 76 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::hasher INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hasher

Definition at line 72 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::iterator

Definition at line 82 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::key_equal INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::key_equal

Definition at line 73 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::key_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::key_type

Definition at line 68 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Tp INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::mapped_type

Definition at line 70 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::pointer INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::pointer

Definition at line 77 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::reference INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::reference

Definition at line 79 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::size_type

Definition at line 75 of file InterpKernelHashMap.hxx.

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
typedef _Ht::value_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::value_type

Definition at line 71 of file InterpKernelHashMap.hxx.


Constructor & Destructor Documentation

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( ) [inline]

Definition at line 93 of file InterpKernelHashMap.hxx.

: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( size_type  __n) [inline, explicit]

Definition at line 95 of file InterpKernelHashMap.hxx.

: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( size_type  __n,
const hasher __hf 
) [inline]

Definition at line 97 of file InterpKernelHashMap.hxx.

: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( size_type  __n,
const hasher __hf,
const key_equal __eql,
const allocator_type __a = allocator_type() 
) [inline]

Definition at line 99 of file InterpKernelHashMap.hxx.

                                                          : _M_ht(__n, __hf, __eql, __a) {}
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _InputIterator >
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( _InputIterator  __f,
_InputIterator  __l 
) [inline]

Definition at line 103 of file InterpKernelHashMap.hxx.

                                                    : _M_ht(100, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _InputIterator >
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( _InputIterator  __f,
_InputIterator  __l,
size_type  __n 
) [inline]

Definition at line 107 of file InterpKernelHashMap.hxx.

                                                                   : _M_ht(__n, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _InputIterator >
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( _InputIterator  __f,
_InputIterator  __l,
size_type  __n,
const hasher __hf 
) [inline]

Definition at line 111 of file InterpKernelHashMap.hxx.

      : _M_ht(__n, __hf, key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _InputIterator >
INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::HashMap ( _InputIterator  __f,
_InputIterator  __l,
size_type  __n,
const hasher __hf,
const key_equal __eql,
const allocator_type __a = allocator_type() 
) [inline]

Definition at line 116 of file InterpKernelHashMap.hxx.

                                                          : _M_ht(__n, __hf, __eql, __a)
    { _M_ht.insert_unique(__f, __l); }

Member Function Documentation

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::begin ( ) [inline]

Definition at line 133 of file InterpKernelHashMap.hxx.

{ return _M_ht.begin(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
const_iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::begin ( ) const [inline]

Definition at line 137 of file InterpKernelHashMap.hxx.

{ return _M_ht.begin(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::bucket_count ( ) const [inline]

Definition at line 171 of file InterpKernelHashMap.hxx.

{ return _M_ht.bucket_count(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::clear ( ) [inline]

Definition at line 167 of file InterpKernelHashMap.hxx.

{ _M_ht.clear(); }

Here is the caller graph for this function:

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::count ( const key_type __key) const [inline]

Definition at line 155 of file InterpKernelHashMap.hxx.

{ return _M_ht.count(__key); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::elems_in_bucket ( size_type  __n) const [inline]

Definition at line 175 of file InterpKernelHashMap.hxx.

{ return _M_ht.elems_in_bucket(__n); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
bool INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::empty ( ) const [inline]

Definition at line 125 of file InterpKernelHashMap.hxx.

{ return _M_ht.empty(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::end ( ) [inline]

Definition at line 135 of file InterpKernelHashMap.hxx.

{ return _M_ht.end(); }

Here is the caller graph for this function:

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
const_iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::end ( ) const [inline]

Definition at line 139 of file InterpKernelHashMap.hxx.

{ return _M_ht.end(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
std::pair<iterator, iterator> INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::equal_range ( const key_type __key) [inline]

Definition at line 157 of file InterpKernelHashMap.hxx.

{ return _M_ht.equal_range(__key); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
std::pair<const_iterator, const_iterator> INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::equal_range ( const key_type __key) const [inline]

Definition at line 159 of file InterpKernelHashMap.hxx.

{ return _M_ht.equal_range(__key); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::erase ( const key_type __key) [inline]

Definition at line 161 of file InterpKernelHashMap.hxx.

{ return _M_ht.erase(__key); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::erase ( iterator  __it) [inline]

Definition at line 163 of file InterpKernelHashMap.hxx.

{ _M_ht.erase(__it); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::erase ( iterator  __f,
iterator  __l 
) [inline]

Definition at line 165 of file InterpKernelHashMap.hxx.

{ _M_ht.erase(__f, __l); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::find ( const key_type __key) [inline]

Definition at line 149 of file InterpKernelHashMap.hxx.

{ return _M_ht.find(__key); }

Here is the caller graph for this function:

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
const_iterator INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::find ( const key_type __key) const [inline]

Definition at line 151 of file InterpKernelHashMap.hxx.

{ return _M_ht.find(__key); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
allocator_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::get_allocator ( ) const [inline]

Definition at line 91 of file InterpKernelHashMap.hxx.

{ return _M_ht.get_allocator(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
hasher INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::hash_funct ( ) const [inline]

Definition at line 87 of file InterpKernelHashMap.hxx.

{ return _M_ht.hash_funct(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
std::pair<iterator, bool> INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert ( const value_type __obj) [inline]

Definition at line 141 of file InterpKernelHashMap.hxx.

{ return _M_ht.insert_unique(__obj); }

Here is the caller graph for this function:

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _InputIterator >
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert ( _InputIterator  __f,
_InputIterator  __l 
) [inline]

Definition at line 144 of file InterpKernelHashMap.hxx.

{ _M_ht.insert_unique(__f, __l); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
std::pair<iterator, bool> INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::insert_noresize ( const value_type __obj) [inline]

Definition at line 147 of file InterpKernelHashMap.hxx.

{ return _M_ht.insert_unique_noresize(__obj); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
key_equal INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::key_eq ( ) const [inline]

Definition at line 89 of file InterpKernelHashMap.hxx.

{ return _M_ht.key_eq(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::max_bucket_count ( ) const [inline]

Definition at line 173 of file InterpKernelHashMap.hxx.

{ return _M_ht.max_bucket_count(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::max_size ( ) const [inline]

Definition at line 123 of file InterpKernelHashMap.hxx.

{ return _M_ht.max_size(); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
_Tp& INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::operator[] ( const key_type __key) [inline]

Definition at line 153 of file InterpKernelHashMap.hxx.

{ return _M_ht.find_or_insert(value_type(__key, _Tp())).second; }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::resize ( size_type  __hint) [inline]

Definition at line 169 of file InterpKernelHashMap.hxx.

{ _M_ht.resize(__hint); }
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
size_type INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::size ( ) const [inline]

Definition at line 121 of file InterpKernelHashMap.hxx.

{ return _M_ht.size(); }

Here is the caller graph for this function:

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
void INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::swap ( HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc > &  __hs) [inline]

Definition at line 127 of file InterpKernelHashMap.hxx.

{ _M_ht.swap(__hs._M_ht); }

Here is the caller graph for this function:


Friends And Related Function Documentation

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
template<class _K1 , class _T1 , class _HF , class _EqK , class _Al >
bool operator== ( const HashMap< _K1, _T1, _HF, _EqK, _Al > &  ,
const HashMap< _K1, _T1, _HF, _EqK, _Al > &   
) [friend]

Member Data Documentation

template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<_Tp>>
_Ht INTERP_KERNEL::HashMap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >::_M_ht [private]

Definition at line 65 of file InterpKernelHashMap.hxx.


The documentation for this class was generated from the following file: