Back to index

salome-med  6.5.0
Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends
INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > Class Template Reference

#include <InterpKernelHashTable.hxx>

Inheritance diagram for INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >:
Inheritance graph
[legend]
Collaboration diagram for INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >:
Collaboration graph
[legend]

List of all members.

Public Types

typedef _Key key_type
typedef _Val value_type
typedef _HashFcn hasher
typedef _EqualKey key_equal
typedef std::size_t size_type
typedef std::ptrdiff_t difference_type
typedef value_typepointer
typedef const value_typeconst_pointer
typedef value_typereference
typedef const value_typeconst_reference
typedef _Alloc::template
rebind< value_type >::other 
allocator_type
typedef _Hashtable_iterator
< _Val, _Key, _HashFcn,
_ExtractKey, _EqualKey, _Alloc > 
iterator
typedef
_Hashtable_const_iterator
< _Val, _Key, _HashFcn,
_ExtractKey, _EqualKey, _Alloc > 
const_iterator

Public Member Functions

hasher hash_funct () const
key_equal key_eq () const
allocator_type get_allocator () const
 hashtable (size_type __n, const _HashFcn &__hf, const _EqualKey &__eql, const _ExtractKey &__ext, const allocator_type &__a=allocator_type())
 hashtable (size_type __n, const _HashFcn &__hf, const _EqualKey &__eql, const allocator_type &__a=allocator_type())
 hashtable (const hashtable &__ht)
hashtableoperator= (const hashtable &__ht)
 ~hashtable ()
size_type size () const
size_type max_size () const
bool empty () const
void swap (hashtable &__ht)
iterator begin ()
iterator end ()
const_iterator begin () const
const_iterator end () const
size_type bucket_count () const
size_type max_bucket_count () const
size_type elems_in_bucket (size_type __bucket) const
std::pair< iterator, bool > insert_unique (const value_type &__obj)
iterator insert_equal (const value_type &__obj)
std::pair< iterator, bool > insert_unique_noresize (const value_type &__obj)
iterator insert_equal_noresize (const value_type &__obj)
template<class _InputIterator >
void insert_unique (_InputIterator __f, _InputIterator __l)
template<class _InputIterator >
void insert_equal (_InputIterator __f, _InputIterator __l)
template<class _InputIterator >
void insert_unique (_InputIterator __f, _InputIterator __l, std::input_iterator_tag)
template<class _InputIterator >
void insert_equal (_InputIterator __f, _InputIterator __l, std::input_iterator_tag)
template<class _ForwardIterator >
void insert_unique (_ForwardIterator __f, _ForwardIterator __l, std::forward_iterator_tag)
template<class _ForwardIterator >
void insert_equal (_ForwardIterator __f, _ForwardIterator __l, std::forward_iterator_tag)
reference find_or_insert (const value_type &__obj)
iterator find (const key_type &__key)
const_iterator find (const key_type &__key) const
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 (const iterator &__it)
void erase (iterator __first, iterator __last)
void erase (const const_iterator &__it)
void erase (const_iterator __first, const_iterator __last)
void resize (size_type __num_elements_hint)
void clear ()

Private Types

typedef _Hashtable_node< _Val > _Node
typedef _Alloc::template
rebind< _Node >::other 
_Node_Alloc
typedef _Alloc::template
rebind< _Node * >::other 
_Nodeptr_Alloc
typedef std::vector< _Node
*, _Nodeptr_Alloc
_Vector_type

Private Member Functions

_Node_M_get_node ()
void _M_put_node (_Node *__p)
size_type _M_next_size (size_type __n) const
void _M_initialize_buckets (size_type __n)
size_type _M_bkt_num_key (const key_type &__key) const
size_type _M_bkt_num (const value_type &__obj) const
size_type _M_bkt_num_key (const key_type &__key, std::size_t __n) const
size_type _M_bkt_num (const value_type &__obj, std::size_t __n) const
_Node_M_new_node (const value_type &__obj)
void _M_delete_node (_Node *__n)
void _M_erase_bucket (const size_type __n, _Node *__first, _Node *__last)
void _M_erase_bucket (const size_type __n, _Node *__last)
void _M_copy_from (const hashtable &__ht)

Private Attributes

_Node_Alloc _M_node_allocator
hasher _M_hash
key_equal _M_equals
_ExtractKey _M_get_key
_Vector_type _M_buckets
size_type _M_num_elements

Friends

struct _Hashtable_iterator< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >
struct _Hashtable_const_iterator< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >
template<class _Vl , class _Ky , class _HF , class _Ex , class _Eq , class _Al >
bool operator== (const hashtable< _Vl, _Ky, _HF, _Ex, _Eq, _Al > &, const hashtable< _Vl, _Ky, _HF, _Ex, _Eq, _Al > &)

Detailed Description

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
class INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >

Definition at line 219 of file InterpKernelHashTable.hxx.


Member Typedef Documentation

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Hashtable_node<_Val> INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_Node [private]

Definition at line 239 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Alloc::template rebind<_Node>::other INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_Node_Alloc [private]

Definition at line 246 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Alloc::template rebind<_Node*>::other INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_Nodeptr_Alloc [private]

Definition at line 247 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef std::vector<_Node*, _Nodeptr_Alloc> INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_Vector_type [private]

Definition at line 248 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Alloc::template rebind<value_type>::other INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::allocator_type

Definition at line 242 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::const_iterator

Definition at line 269 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef const value_type* INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::const_pointer

Definition at line 230 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef const value_type& INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::const_reference

Definition at line 232 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef std::ptrdiff_t INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::difference_type

Definition at line 228 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _HashFcn INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::hasher

Definition at line 224 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::iterator

Definition at line 266 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _EqualKey INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::key_equal

Definition at line 225 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Key INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::key_type

Definition at line 222 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef value_type* INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::pointer

Definition at line 229 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef value_type& INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::reference

Definition at line 231 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef std::size_t INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::size_type

Definition at line 227 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
typedef _Val INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::value_type

Definition at line 223 of file InterpKernelHashTable.hxx.


Constructor & Destructor Documentation

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::hashtable ( size_type  __n,
const _HashFcn &  __hf,
const _EqualKey &  __eql,
const _ExtractKey &  __ext,
const allocator_type __a = allocator_type() 
) [inline]

Definition at line 277 of file InterpKernelHashTable.hxx.

        :
    hashtable(size_type __n, const _HashFcn& __hf,
              const _EqualKey& __eql, const _ExtractKey& __ext,
              const allocator_type& __a = allocator_type())
      : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql),
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::hashtable ( size_type  __n,
const _HashFcn &  __hf,
const _EqualKey &  __eql,
const allocator_type __a = allocator_type() 
) [inline]

Definition at line 284 of file InterpKernelHashTable.hxx.

    { _M_initialize_buckets(__n); }

    hashtable(size_type __n, const _HashFcn& __hf,
              const _EqualKey& __eql,
              const allocator_type& __a = allocator_type())
      : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql),
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::hashtable ( const hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > &  __ht) [inline]
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::~hashtable ( ) [inline]

Definition at line 310 of file InterpKernelHashTable.hxx.

    { clear(); }

Member Function Documentation

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_bkt_num ( const value_type __obj) const [inline, private]

Definition at line 493 of file InterpKernelHashTable.hxx.

    { return _M_bkt_num_key(__key, _M_buckets.size()); }
    
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_bkt_num ( const value_type __obj,
std::size_t  __n 
) const [inline, private]

Definition at line 499 of file InterpKernelHashTable.hxx.

    { return _M_hash(__key) % __n; }
    
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_bkt_num_key ( const key_type __key) const [inline, private]

Definition at line 490 of file InterpKernelHashTable.hxx.

    { return _M_bkt_num_key(__key, _M_buckets.size()); }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_bkt_num_key ( const key_type __key,
std::size_t  __n 
) const [inline, private]

Definition at line 496 of file InterpKernelHashTable.hxx.

    { return _M_bkt_num_key(_M_get_key(__obj)); }
    
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::_M_copy_from ( const hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > &  __ht) [private]

Definition at line 963 of file InterpKernelHashTable.hxx.

  {
    _M_buckets.clear();
    _M_buckets.reserve(__ht._M_buckets.size());
    _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
    try
      {
        for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) {
          const _Node* __cur = __ht._M_buckets[__i];
          if (__cur)
            {
              _Node* __local_copy = _M_new_node(__cur->_M_val);
              _M_buckets[__i] = __local_copy;
              for (_Node* __next = __cur->_M_next;
                   __next;
                   __cur = __next, __next = __cur->_M_next)
                {
                  __local_copy->_M_next = _M_new_node(__next->_M_val);
                  __local_copy = __local_copy->_M_next;
                }
            }
        }
        _M_num_elements = __ht._M_num_elements;
      }
    catch(...)
      {
        clear();
        throw;
      }
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_delete_node ( _Node __n) [inline, private]

Definition at line 518 of file InterpKernelHashTable.hxx.

    {
      this->get_allocator().destroy(&__n->_M_val);
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::_M_erase_bucket ( const size_type  __n,
_Node __first,
_Node __last 
) [private]

Definition at line 909 of file InterpKernelHashTable.hxx.

  {
    _Node* __cur = _M_buckets[__n];
    if (__cur == __first)
      _M_erase_bucket(__n, __last);
    else
      {
        _Node* __next;
        for (__next = __cur->_M_next;
             __next != __first;
             __cur = __next, __next = __cur->_M_next)
          ;
        while (__next != __last)
          {
            __cur->_M_next = __next->_M_next;
            _M_delete_node(__next);
            __next = __cur->_M_next;
            --_M_num_elements;
          }
      }
  }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::_M_erase_bucket ( const size_type  __n,
_Node __last 
) [private]

Definition at line 932 of file InterpKernelHashTable.hxx.

  {
    _Node* __cur = _M_buckets[__n];
    while (__cur != __last)
      {
        _Node* __next = __cur->_M_next;
        _M_delete_node(__cur);
        __cur = __next;
        _M_buckets[__n] = __cur;
        --_M_num_elements;
      }
  }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
_Node* INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_get_node ( ) [inline, private]

Definition at line 252 of file InterpKernelHashTable.hxx.

{ return _M_node_allocator.allocate(1); }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_initialize_buckets ( size_type  __n) [inline, private]

Definition at line 482 of file InterpKernelHashTable.hxx.

                                                { return __stl_next_prime(__n); }

    void _M_initialize_buckets(size_type __n)
    {
      const size_type __n_buckets = _M_next_size(__n);
      _M_buckets.reserve(__n_buckets);
      _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
_Node* INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_new_node ( const value_type __obj) [inline, private]

Definition at line 502 of file InterpKernelHashTable.hxx.

    { return _M_bkt_num_key(_M_get_key(__obj), __n); }

    _Node* _M_new_node(const value_type& __obj)
    {
      _Node* __n = _M_get_node();
      __n->_M_next = 0;
      try
        {
          this->get_allocator().construct(&__n->_M_val, __obj);
          return __n;
        }
      catch(...)
        {
          _M_put_node(__n);
          throw;
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_next_size ( size_type  __n) const [inline, private]

Definition at line 480 of file InterpKernelHashTable.hxx.

:
    size_type _M_next_size(size_type __n) const { return __stl_next_prime(__n); }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_put_node ( _Node __p) [inline, private]

Definition at line 254 of file InterpKernelHashTable.hxx.

{ _M_node_allocator.deallocate(__p, 1); }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::begin ( ) [inline]

Definition at line 328 of file InterpKernelHashTable.hxx.

    {
      for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
        if (_M_buckets[__n])
          return iterator(_M_buckets[__n], this);

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
const_iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::begin ( ) const [inline]

Definition at line 338 of file InterpKernelHashTable.hxx.

                   { return iterator(0, this); }

    const_iterator begin() const 
    {
      for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
        if (_M_buckets[__n])
          return const_iterator(_M_buckets[__n], this);
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::bucket_count ( ) const [inline]

Definition at line 353 of file InterpKernelHashTable.hxx.

:
    size_type bucket_count() const { return _M_buckets.size(); }

Here is the caller graph for this function:

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::clear ( )

Definition at line 946 of file InterpKernelHashTable.hxx.

  {
    for (size_type __i = 0; __i < _M_buckets.size(); ++__i)
      {
        _Node* __cur = _M_buckets[__i];
        while (__cur != 0)
          {
            _Node* __next = __cur->_M_next;
            _M_delete_node(__cur);
            __cur = __next;
          }
        _M_buckets[__i] = 0;
      }
    _M_num_elements = 0;
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::count ( const key_type __key) const [inline]

Definition at line 450 of file InterpKernelHashTable.hxx.

    {
      const size_type __n = _M_bkt_num_key(__key);
      size_type __result = 0;
      for (const _Node* __cur = _M_buckets[__n]; __cur;
           __cur = __cur->_M_next)
        if (_M_equals(_M_get_key(__cur->_M_val), __key))
          ++__result;

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::elems_in_bucket ( size_type  __bucket) const [inline]

Definition at line 357 of file InterpKernelHashTable.hxx.

                                       { return __stl_prime_list[(int)_S_num_primes - 1]; }

    size_type elems_in_bucket(size_type __bucket) const 
    {
      size_type __result = 0;
      for (_Node* __n = _M_buckets[__bucket]; __n; __n = __n->_M_next)
        __result += 1;

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
bool INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::empty ( ) const [inline]

Definition at line 317 of file InterpKernelHashTable.hxx.

{ return size_type(-1); }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::end ( ) [inline]

Definition at line 336 of file InterpKernelHashTable.hxx.

{ return iterator(0, this); }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
const_iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::end ( ) const [inline]

Definition at line 346 of file InterpKernelHashTable.hxx.

{ return const_iterator(0, this); }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
std::pair< typename hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::iterator, typename hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::iterator > INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::equal_range ( const key_type __key)

Definition at line 704 of file InterpKernelHashTable.hxx.

  {
    typedef std::pair<iterator, iterator> _Pii;
    const size_type __n = _M_bkt_num_key(__key);
    
    for (_Node* __first = _M_buckets[__n]; __first;
         __first = __first->_M_next)
      if (_M_equals(_M_get_key(__first->_M_val), __key))
        {
          for (_Node* __cur = __first->_M_next; __cur;
               __cur = __cur->_M_next)
            if (!_M_equals(_M_get_key(__cur->_M_val), __key))
              return _Pii(iterator(__first, this), iterator(__cur, this));
          for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
            if (_M_buckets[__m])
              return _Pii(iterator(__first, this),
                          iterator(_M_buckets[__m], this));
          return _Pii(iterator(__first, this), end());
        }
    return _Pii(end(), end());
  }

Here is the caller graph for this function:

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
std::pair< typename hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::const_iterator, typename hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::const_iterator > INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::equal_range ( const key_type __key) const

Definition at line 729 of file InterpKernelHashTable.hxx.

  {
    typedef std::pair<const_iterator, const_iterator> _Pii;
    const size_type __n = _M_bkt_num_key(__key);
    
    for (const _Node* __first = _M_buckets[__n]; __first;
         __first = __first->_M_next)
      {
        if (_M_equals(_M_get_key(__first->_M_val), __key))
          {
            for (const _Node* __cur = __first->_M_next; __cur;
                 __cur = __cur->_M_next)
              if (!_M_equals(_M_get_key(__cur->_M_val), __key))
                return _Pii(const_iterator(__first, this),
                          const_iterator(__cur, this));
            for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
              if (_M_buckets[__m])
                return _Pii(const_iterator(__first, this),
                            const_iterator(_M_buckets[__m], this));
            return _Pii(const_iterator(__first, this), end());
          }
      }
    return _Pii(end(), end());
  }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::size_type INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::erase ( const key_type __key)

Definition at line 756 of file InterpKernelHashTable.hxx.

  {
    const size_type __n = _M_bkt_num_key(__key);
    _Node* __first = _M_buckets[__n];
    size_type __erased = 0;
    
    if (__first)
      {
        _Node* __cur = __first;
        _Node* __next = __cur->_M_next;
        while (__next)
          {
            if (_M_equals(_M_get_key(__next->_M_val), __key))
              {
                __cur->_M_next = __next->_M_next;
                _M_delete_node(__next);
                __next = __cur->_M_next;
                ++__erased;
                --_M_num_elements;
              }
            else
              {
                __cur = __next;
                __next = __cur->_M_next;
              }
          }
        if (_M_equals(_M_get_key(__first->_M_val), __key))
          {
            _M_buckets[__n] = __first->_M_next;
            _M_delete_node(__first);
            ++__erased;
            --_M_num_elements;
          }
      }
    return __erased;
  }

Here is the caller graph for this function:

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::erase ( const iterator __it)

Definition at line 794 of file InterpKernelHashTable.hxx.

  {
    _Node* __p = __it._M_cur;
    if (__p)
      {
        const size_type __n = _M_bkt_num(__p->_M_val);
        _Node* __cur = _M_buckets[__n]; 
        if (__cur == __p)
          {
            _M_buckets[__n] = __cur->_M_next;
            _M_delete_node(__cur);
            --_M_num_elements;
          }
        else
          {
            _Node* __next = __cur->_M_next;
            while (__next)
              {
                if (__next == __p)
                  {
                    __cur->_M_next = __next->_M_next;
                    _M_delete_node(__next);
                    --_M_num_elements;
                    break;
                  }
                else
                  {
                    __cur = __next;
                    __next = __cur->_M_next;
                  }
              }
          }
      }
  }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::erase ( iterator  __first,
iterator  __last 
)

Definition at line 830 of file InterpKernelHashTable.hxx.

  {
    size_type __f_bucket = __first._M_cur ? _M_bkt_num(__first._M_cur->_M_val) : _M_buckets.size();
    
    size_type __l_bucket = __last._M_cur ? _M_bkt_num(__last._M_cur->_M_val) : _M_buckets.size();
    
    if (__first._M_cur == __last._M_cur)
      return;
    else if (__f_bucket == __l_bucket)
      _M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur);
    else
      {
        _M_erase_bucket(__f_bucket, __first._M_cur, 0);
        for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n)
          _M_erase_bucket(__n, 0);
        if (__l_bucket != _M_buckets.size())
          _M_erase_bucket(__l_bucket, __last._M_cur);
      }
  }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::erase ( const const_iterator __it) [inline]

Definition at line 862 of file InterpKernelHashTable.hxx.

  { erase(iterator(const_cast<_Node*>(__it._M_cur), const_cast<hashtable*>(__it._M_ht))); }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::erase ( const_iterator  __first,
const_iterator  __last 
) [inline]

Definition at line 853 of file InterpKernelHashTable.hxx.

  {
    erase(iterator(const_cast<_Node*>(__first._M_cur),
                   const_cast<hashtable*>(__first._M_ht)),
          iterator(const_cast<_Node*>(__last._M_cur),
                   const_cast<hashtable*>(__last._M_ht)));
  }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::find ( const key_type __key) [inline]

Definition at line 428 of file InterpKernelHashTable.hxx.

    {
      size_type __n = _M_bkt_num_key(__key);
      _Node* __first;
      for (__first = _M_buckets[__n];
           __first && !_M_equals(_M_get_key(__first->_M_val), __key);
           __first = __first->_M_next)
        { }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
const_iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::find ( const key_type __key) const [inline]

Definition at line 439 of file InterpKernelHashTable.hxx.

    {
      size_type __n = _M_bkt_num_key(__key);
      const _Node* __first;
      for (__first = _M_buckets[__n];
           __first && !_M_equals(_M_get_key(__first->_M_val), __key);
           __first = __first->_M_next)
        { }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::reference INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::find_or_insert ( const value_type __obj)

Definition at line 683 of file InterpKernelHashTable.hxx.

  {
    resize(_M_num_elements + 1);

    size_type __n = _M_bkt_num(__obj);
    _Node* __first = _M_buckets[__n];
      
    for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
      if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
        return __cur->_M_val;
      
    _Node* __tmp = _M_new_node(__obj);
    __tmp->_M_next = __first;
    _M_buckets[__n] = __tmp;
    ++_M_num_elements;
    return __tmp->_M_val;
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
allocator_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::get_allocator ( ) const [inline]

Definition at line 243 of file InterpKernelHashTable.hxx.

{ return _M_node_allocator; }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
hasher INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::hash_funct ( ) const [inline]

Definition at line 234 of file InterpKernelHashTable.hxx.

{ return _M_hash; }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
iterator INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_equal ( const value_type __obj) [inline]

Definition at line 371 of file InterpKernelHashTable.hxx.

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _InputIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_equal ( _InputIterator  __f,
_InputIterator  __l 
) [inline]

Definition at line 386 of file InterpKernelHashTable.hxx.

    { insert_equal(__f, __l, __iterator_category(__f)); }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _InputIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_equal ( _InputIterator  __f,
_InputIterator  __l,
std::input_iterator_tag   
) [inline]

Definition at line 398 of file InterpKernelHashTable.hxx.

    {
      for ( ; __f != __l; ++__f)
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _ForwardIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_equal ( _ForwardIterator  __f,
_ForwardIterator  __l,
std::forward_iterator_tag   
) [inline]

Definition at line 417 of file InterpKernelHashTable.hxx.

    {
      size_type __n = std::distance(__f, __l);
      resize(_M_num_elements + __n);
      for ( ; __n > 0; --__n, ++__f)
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::iterator INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::insert_equal_noresize ( const value_type __obj)

Definition at line 658 of file InterpKernelHashTable.hxx.

  {
    const size_type __n = _M_bkt_num(__obj);
    _Node* __first = _M_buckets[__n];
      
    for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
      if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
        {
          _Node* __tmp = _M_new_node(__obj);
          __tmp->_M_next = __cur->_M_next;
          __cur->_M_next = __tmp;
          ++_M_num_elements;
          return iterator(__tmp, this);
        }

    _Node* __tmp = _M_new_node(__obj);
    __tmp->_M_next = __first;
    _M_buckets[__n] = __tmp;
    ++_M_num_elements;
    return iterator(__tmp, this);
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
std::pair<iterator, bool> INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_unique ( const value_type __obj) [inline]

Definition at line 365 of file InterpKernelHashTable.hxx.

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _InputIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_unique ( _InputIterator  __f,
_InputIterator  __l 
) [inline]

Definition at line 382 of file InterpKernelHashTable.hxx.

    { insert_unique(__f, __l, __iterator_category(__f)); }
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _InputIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_unique ( _InputIterator  __f,
_InputIterator  __l,
std::input_iterator_tag   
) [inline]

Definition at line 390 of file InterpKernelHashTable.hxx.

    {
      for ( ; __f != __l; ++__f)
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _ForwardIterator >
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::insert_unique ( _ForwardIterator  __f,
_ForwardIterator  __l,
std::forward_iterator_tag   
) [inline]

Definition at line 406 of file InterpKernelHashTable.hxx.

    {
      size_type __n = std::distance(__f, __l);
      resize(_M_num_elements + __n);
      for ( ; __n > 0; --__n, ++__f)
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
std::pair< typename hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::iterator, bool > INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::insert_unique_noresize ( const value_type __obj)

Definition at line 639 of file InterpKernelHashTable.hxx.

  {
    const size_type __n = _M_bkt_num(__obj);
    _Node* __first = _M_buckets[__n];
      
    for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
      if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
        return std::pair<iterator, bool>(iterator(__cur, this), false);
      
    _Node* __tmp = _M_new_node(__obj);
    __tmp->_M_next = __first;
    _M_buckets[__n] = __tmp;
    ++_M_num_elements;
    return std::pair<iterator, bool>(iterator(__tmp, this), true);
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
key_equal INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::key_eq ( ) const [inline]

Definition at line 236 of file InterpKernelHashTable.hxx.

{ return _M_equals; }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::max_bucket_count ( ) const [inline]

Definition at line 355 of file InterpKernelHashTable.hxx.

{ return _M_buckets.size(); }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::max_size ( ) const [inline]

Definition at line 315 of file InterpKernelHashTable.hxx.

{ return _M_num_elements; }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
hashtable& INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::operator= ( const hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > &  __ht) [inline]

Definition at line 297 of file InterpKernelHashTable.hxx.

    { _M_copy_from(__ht); }

    hashtable& operator= (const hashtable& __ht)
    {
      if (&__ht != this)
        {
          clear();
          _M_hash = __ht._M_hash;
          _M_equals = __ht._M_equals;
          _M_get_key = __ht._M_get_key;
          _M_copy_from(__ht);
        }
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
void INTERP_KERNEL::hashtable< _Val, _Key, _HF, _Ex, _Eq, _All >::resize ( size_type  __num_elements_hint)

Definition at line 866 of file InterpKernelHashTable.hxx.

  {
    const size_type __old_n = _M_buckets.size();
    if (__num_elements_hint > __old_n)
      {
        const size_type __n = _M_next_size(__num_elements_hint);
        if (__n > __old_n)
          {
            _Vector_type __tmp(__n, (_Node*)(0), _M_buckets.get_allocator());
            try
              {
                for (size_type __bucket = 0; __bucket < __old_n; ++__bucket)
                  {
                    _Node* __first = _M_buckets[__bucket];
                    while (__first)
                      {
                        size_type __new_bucket = _M_bkt_num(__first->_M_val,__n);
                        _M_buckets[__bucket] = __first->_M_next;
                        __first->_M_next = __tmp[__new_bucket];
                        __tmp[__new_bucket] = __first;
                        __first = _M_buckets[__bucket];
                      }
                  }
                _M_buckets.swap(__tmp);
              }
            catch(...)
              {
                for (size_type __bucket = 0; __bucket < __tmp.size();++__bucket)
                  {
                    while (__tmp[__bucket])
                      {
                        _Node* __next = __tmp[__bucket]->_M_next;
                        _M_delete_node(__tmp[__bucket]);
                        __tmp[__bucket] = __next;
                      }
                  }
                throw;
              }
          }
      }
  }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::size ( ) const [inline]

Definition at line 313 of file InterpKernelHashTable.hxx.

{ clear(); }

Here is the caller graph for this function:

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
void INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::swap ( hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > &  __ht) [inline]

Definition at line 319 of file InterpKernelHashTable.hxx.

                       { return size() == 0; }

    void swap(hashtable& __ht) 
    {
      std::swap(_M_hash, __ht._M_hash);
      std::swap(_M_equals, __ht._M_equals);
      std::swap(_M_get_key, __ht._M_get_key);
      _M_buckets.swap(__ht._M_buckets);

Here is the caller graph for this function:


Friends And Related Function Documentation

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
friend struct _Hashtable_const_iterator< _Val, _Key, _HashFcn, _ExtractKey,_EqualKey, _Alloc > [friend]

Definition at line 274 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
friend struct _Hashtable_iterator< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > [friend]

Definition at line 271 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
template<class _Vl , class _Ky , class _HF , class _Ex , class _Eq , class _Al >
bool operator== ( const hashtable< _Vl, _Ky, _HF, _Ex, _Eq, _Al > &  ,
const hashtable< _Vl, _Ky, _HF, _Ex, _Eq, _Al > &   
) [friend]

Member Data Documentation

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
_Vector_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_buckets [private]

Definition at line 260 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
key_equal INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_equals [private]

Definition at line 258 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
_ExtractKey INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_get_key [private]

Definition at line 259 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
hasher INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_hash [private]

Definition at line 257 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
_Node_Alloc INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_node_allocator [private]

Definition at line 250 of file InterpKernelHashTable.hxx.

template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc>
size_type INTERP_KERNEL::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >::_M_num_elements [private]

Definition at line 261 of file InterpKernelHashTable.hxx.


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