gum::HashTableList< Key, Val, Alloc > Class Template Reference

A chained list used by gum::HashTable. More...

#include <agrum/tools/core/hashTable.h>

Public Member Functions
template<typename Key, typename Val, typename Alloc>
INLINE	HashTableList (typename HashTableList< Key, Val, Alloc >::BucketAllocator *allocator) noexcept
template<typename OtherAlloc >
INLINE HashTableList< Key, Val, Alloc > &	operator= (const HashTableList< Key, Val, OtherAlloc > &from)
Constructors / Destructors
	HashTableList (BucketAllocator *allocator=nullptr) noexcept
	Basic constructor that creates an empty list. More...
	HashTableList (const HashTableList< Key, Val, Alloc > &from)
	Copy constructor. More...
	HashTableList (HashTableList< Key, Val, Alloc > &&from) noexcept
	Move constructor. More...
	~HashTableList ()
	Class destructor. More...
Operators
HashTableList< Key, Val, Alloc > &	operator= (const HashTableList< Key, Val, Alloc > &from)
	Assignment operator. More...
template<typename OtherAlloc >
HashTableList< Key, Val, Alloc > &	operator= (const HashTableList< Key, Val, OtherAlloc > &from)
	Generalized assignment operator. More...
HashTableList< Key, Val, Alloc > &	operator= (HashTableList< Key, Val, Alloc > &&from) noexcept
	Move operator. More...
Accessors / Modifiers
value_type &	at (Size i)
	Function at returns the ith element in the current chained list. More...
const value_type &	at (Size i) const
	Function at returns the ith element in the current chained list. More...
mapped_type &	operator[] (const key_type &key)
	Returns the value corresponding to a given key. More...
const mapped_type &	operator[] (const key_type &key) const
	Returns the value corresponding to a given key. More...
bool	exists (const key_type &key) const
	Returns true if a value with the given key exists. More...
void	insert (Bucket *new_elt) noexcept
	Inserts a new element in the chained list. More...
void	erase (Bucket *ptr)
	Removes an element from this chained list. More...
void	clear ()
	Removes all the elements of this chained list. More...
bool	empty () const noexcept
	Returns true if this chained list is empty. More...
Bucket *	bucket (const Key &key) const
	A method to get the bucket corresponding to a given key. More...
void	setAllocator (BucketAllocator &alloc)
	Sets a new allocator. More...

Public Types
using	BucketAllocator = typename Alloc::template rebind< Bucket >::other
	The Bucket allocator. More...
using	key_type = Key
	types for STL compliance More...
using	mapped_type = Val
	types for STL compliance More...
using	value_type = std::pair< const Key, Val >
	types for STL compliance More...
using	reference = value_type &
	types for STL compliance More...
using	const_reference = const value_type &
	types for STL compliance More...
using	pointer = value_type *
	types for STL compliance More...
using	const_pointer = const value_type *
	types for STL compliance More...
using	size_type = Size
	types for STL compliance More...
using	allocator_type = Alloc
	types for STL compliance More...
using	Bucket = HashTableBucket< Key, Val >
	types for STL compliance More...

Friends
template<typename K , typename V , typename A >
class	HashTableList
	Friend for faster access. More...
class	HashTable< Key, Val, Alloc >
	Friend for faster access. More...
class	HashTableIterator< Key, Val >
	Friend for faster access. More...
class	HashTableConstIterator< Key, Val >
	Friend for faster access. More...
class	HashTableIteratorSafe< Key, Val >
	Friend for faster access. More...
class	HashTableConstIteratorSafe< Key, Val >
	Friend for faster access. More...
std::ostream &	operator<< (std::ostream &, const HashTableList< Key, Val, Alloc > &)
	Prints the content of a gum::HashTableList in the stream. More...
std::ostream &	operator<< (std::ostream &, const HashTableList< Key *, Val, Alloc > &)
	Prints the content of a gum::HashTableList with pointers key in the stream. More...
std::ostream &	operator<< (std::ostream &, const HashTable< Key, Val, Alloc > &)
	Prints the content of a gum::HashTable in the stream. More...
std::ostream &	operator<< (std::ostream &, const HashTable< Key *, Val, Alloc > &)
	Prints the content of a gum::HashTable with pointers key in the stream. More...

Detailed Description

template<typename Key, typename Val, typename Alloc>
class gum::HashTableList< Key, Val, Alloc >

A chained list used by gum::HashTable.

Template Parameters

Key	The type for keys in a gum::HashTable.
Val	The type for values in a gum::HashTable.
Alloc	The gum::HashTable allocator.

Definition at line 301 of file hashTable.h.

Member Typedef Documentation

allocator_type

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::allocator_type = Alloc

types for STL compliance

Definition at line 313 of file hashTable.h.

Bucket

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::Bucket = HashTableBucket< Key, Val >

types for STL compliance

Definition at line 314 of file hashTable.h.

BucketAllocator

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::BucketAllocator = typename Alloc::template rebind< Bucket >::other

The Bucket allocator.

Definition at line 318 of file hashTable.h.

const_pointer

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::const_pointer = const value_type*

types for STL compliance

Definition at line 311 of file hashTable.h.

const_reference

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::const_reference = const value_type&

types for STL compliance

Definition at line 309 of file hashTable.h.

key_type

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::key_type = Key

types for STL compliance

Definition at line 305 of file hashTable.h.

mapped_type

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::mapped_type = Val

types for STL compliance

Definition at line 306 of file hashTable.h.

pointer

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::pointer = value_type*

types for STL compliance

Definition at line 310 of file hashTable.h.

reference

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::reference = value_type&

types for STL compliance

Definition at line 308 of file hashTable.h.

size_type

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::size_type = Size

types for STL compliance

Definition at line 312 of file hashTable.h.

value_type

template<typename Key, typename Val, typename Alloc>

using gum::HashTableList< Key, Val, Alloc >::value_type = std::pair< const Key, Val >

types for STL compliance

Definition at line 307 of file hashTable.h.

Constructor & Destructor Documentation

HashTableList() [1/4]

template<typename Key, typename Val, typename Alloc>

gum::HashTableList< Key, Val, Alloc >::HashTableList ( BucketAllocator *  allocator = nullptr )

noexcept

Basic constructor that creates an empty list.

This is what is used basically by gum::HashTable.

Warning

If the allocator is not passed in argument, do not forget to use method setAllocator after the creation.

Parameters

allocator

The gum::HashTableBucket allocator.

HashTableList() [2/4]

template<typename Key, typename Val, typename Alloc>

INLINE gum::HashTableList< Key, Val, Alloc >::HashTableList

(

const HashTableList< Key, Val, Alloc > &

from

)

Copy constructor.

The new list and that which is copied do not share elements: the new list contains new instances of the keys and values stored in the copied list. Of course, if these values are pointers, the new values point toward the same elements.

Warning

Both from and this will share the same allocator.

Parameters

from	The gum::HashTableList to copy.

Definition at line 136 of file hashTable_tpl.h.

                                                                                                 :
      _alloc_bucket_{from._alloc_bucket_} {
    _copy_(from);
  }

HashTableList() [3/4]

template<typename Key, typename Val, typename Alloc>

INLINE gum::HashTableList< Key, Val, Alloc >::HashTableList ( HashTableList< Key, Val, Alloc > &&  from )

noexcept

Move constructor.

Parameters

from	The gum::HashTableList to move.

Definition at line 142 of file hashTable_tpl.h.

                                                       :
      _deb_list_{from._deb_list_},
      _end_list_{from._end_list_}, _nb_elements_{from._nb_elements_}, _alloc_bucket_{
                                                                         from._alloc_bucket_} {
    from._deb_list_ = nullptr;
  }

~HashTableList()

template<typename Key , typename Val , typename Alloc >

INLINE gum::HashTableList< Key, Val, Alloc >::~HashTableList

(

)

Class destructor.

Definition at line 151 of file hashTable_tpl.h.

                                                          {
    for (Bucket *next_ptr, *ptr = _deb_list_; ptr != nullptr; ptr = next_ptr) {
      next_ptr = ptr->next;
      _alloc_bucket_->destroy(ptr);
      _alloc_bucket_->deallocate(ptr, 1);
    }
  }

HashTableList() [4/4]

template<typename Key, typename Val, typename Alloc>

template<typename Key, typename Val, typename Alloc>

INLINE gum::HashTableList< Key, Val, Alloc >::HashTableList ( typename HashTableList< Key, Val, Alloc >::BucketAllocator *  allocator )

noexcept

Definition at line 130 of file hashTable_tpl.h.

                                                                                   :
      _alloc_bucket_{allocator} {}

Member Function Documentation

_copy_()

template<typename Key, typename Val, typename Alloc >

template<typename OtherAlloc >

void gum::HashTableList< Key, Val, Alloc >::_copy_ ( const HashTableList< Key, Val, OtherAlloc > &  from )

private

A function used to perform copies of HashTableLists.

This code is shared by the copy constructor and the copy operator. If it cannot perform the necessary allocations, no memory leak occurs and the list is set to the empty list.

Parameters

from	The gum::HashTableList to copy.

Template Parameters

OtherAlloc

The other gum::HashTableList allocator.

Definition at line 44 of file hashTable_tpl.h.

                                                                                                 {
    Bucket *ptr, *old_ptr{nullptr}, *new_elt{nullptr};
    // set the defaults
    _deb_list_ = nullptr;

    // copy from's list
    try {
      for (ptr = from._deb_list_; ptr != nullptr; ptr = ptr->next) {
        // copy the current from's bucket (may throw an exception either because
        // new cannot allocate the bucket or because the copy constructor of Val
        // throws an exception)
        new_elt = _alloc_bucket_->allocate(1);

        try {
          _alloc_bucket_->construct(new_elt, *ptr);
        } catch (...) {
          _alloc_bucket_->deallocate(new_elt, 1);
          throw;
        }

        // rechain properly the new list
        new_elt->prev = old_ptr;

        if (old_ptr != nullptr)
          old_ptr->next = new_elt;
        else
          _deb_list_ = new_elt;

        old_ptr = new_elt;
      }

      if (old_ptr != nullptr) old_ptr->next = nullptr;

      // update the number of elements stored into the list and the end of the
      // list
      _nb_elements_ = from._nb_elements_;
      _end_list_    = new_elt;
    } catch (...) {
      // problem: we could not allocate an element in the list => we delete
      // the elements created so far and we throw an exception
      for (; _deb_list_ != nullptr; _deb_list_ = new_elt) {
        new_elt = _deb_list_->next;
        _alloc_bucket_->destroy(_deb_list_);
        _alloc_bucket_->deallocate(_deb_list_, 1);
      }

      _nb_elements_ = 0;
      _end_list_    = nullptr;

      throw;
    }
  }

at() [1/2]

template<typename Key , typename Val , typename Alloc >

INLINE HashTableList< Key, Val, Alloc >::value_type & gum::HashTableList< Key, Val, Alloc >::at

(

Size

i

)

Function at returns the ith element in the current chained list.

The first element has index 0.

Parameters

i	The index to look up.

Returns

Returns the value at index i.

Exceptions

NotFound

Raised if the list has fewer than i elements.

Definition at line 219 of file hashTable_tpl.h.

                                                {
    if (i >= _nb_elements_) { GUM_ERROR(NotFound, "not enough elements in the chained list") }

    Bucket* ptr;

    for (ptr = _deb_list_; i; --i, ptr = ptr->next) {}

    return ptr->elt();
  }

at() [2/2]

template<typename Key , typename Val , typename Alloc >

INLINE const HashTableList< Key, Val, Alloc >::value_type & gum::HashTableList< Key, Val, Alloc >::at

(

Size

i

)

const

Function at returns the ith element in the current chained list.

The first element has index 0.

Parameters

i	The index to look up.

Returns

Returns the value at index i.

Exceptions

NotFound

Raised if the list has fewer than i elements.

Definition at line 231 of file hashTable_tpl.h.

                                                      {
    if (i >= _nb_elements_) { GUM_ERROR(NotFound, "not enough elements in the chained list") }

    Bucket* ptr;

    for (ptr = _deb_list_; i; --i, ptr = ptr->next) {}

    return ptr->elt();
  }

bucket()

template<typename Key, typename Val , typename Alloc >

INLINE HashTableBucket< Key, Val > * gum::HashTableList< Key, Val, Alloc >::bucket

(

const Key &

key

)

const

A method to get the bucket corresponding to a given key.

This enables efficient removals of buckets.

Parameters

key	The key of the bucket to return.

Returns

Returns the buckket matching key.

Definition at line 99 of file hashTable_tpl.h.

                                                                      {
    for (Bucket* ptr = _deb_list_; ptr != nullptr; ptr = ptr->next)
      if (ptr->key() == key) return ptr;

    return nullptr;
  }

clear()

template<typename Key , typename Val , typename Alloc >

INLINE void gum::HashTableList< Key, Val, Alloc >::clear

(

)

Removes all the elements of this chained list.

Definition at line 160 of file hashTable_tpl.h.

                                                      {
    for (Bucket *next_ptr, *ptr = _deb_list_; ptr != nullptr; ptr = next_ptr) {
      next_ptr = ptr->next;
      _alloc_bucket_->destroy(ptr);
      _alloc_bucket_->deallocate(ptr, 1);
    }

    _nb_elements_ = Size(0);
    _deb_list_    = nullptr;
    _end_list_    = nullptr;
  }

empty()

template<typename Key , typename Val , typename Alloc >

INLINE bool gum::HashTableList< Key, Val, Alloc >::empty ( ) const

noexcept

Returns true if this chained list is empty.

Returns

Returns true if this chained list is empty.

Definition at line 269 of file hashTable_tpl.h.

                                                                     {
    return (_nb_elements_ == Size(0));
  }

erase()

template<typename Key , typename Val , typename Alloc >

INLINE void gum::HashTableList< Key, Val, Alloc >::erase

(

Bucket *

ptr

)

Removes an element from this chained list.

Parameters

ptr	The element to remove.

Definition at line 107 of file hashTable_tpl.h.

                                                                                      {
    // check that the pointer is not nullptr
    if (ptr == nullptr) { GUM_ERROR(NullElement, "trying to erase a nullptr bucket") }

    // relink properly the doubly chained list
    if (ptr->prev != nullptr)
      ptr->prev->next = ptr->next;
    else
      _deb_list_ = ptr->next;

    if (ptr->next != nullptr)
      ptr->next->prev = ptr->prev;
    else
      _end_list_ = ptr->prev;

    // remove the current element from the list
    _alloc_bucket_->destroy(ptr);
    _alloc_bucket_->deallocate(ptr, 1);

    --_nb_elements_;
  }

exists()

template<typename Key , typename Val , typename Alloc >

INLINE bool gum::HashTableList< Key, Val, Alloc >::exists

(

const key_type &

key

)

const

Returns true if a value with the given key exists.

Checks whether there exists an element with a given key in the list.

Parameters

key	The key to test for existence.

Returns

Returns true if a value with the given key exists.

Definition at line 260 of file hashTable_tpl.h.

                                                                           {
    for (Bucket* ptr = _deb_list_; ptr != nullptr; ptr = ptr->next) {
      if (ptr->key() == key) { return true; }
    }

    return false;
  }

insert()

template<typename Key , typename Val , typename Alloc >

INLINE void gum::HashTableList< Key, Val, Alloc >::insert ( Bucket *  new_elt )

noexcept

Inserts a new element in the chained list.

The element is inserted at the beginning of the list.

Parameters

new_elt

The element to add in the gum::HashTableList.

Definition at line 275 of file hashTable_tpl.h.

                                                                                           {
    // place the bucket at the beginning of the list
    new_elt->prev = nullptr;
    new_elt->next = _deb_list_;

    if (_deb_list_ != nullptr)
      _deb_list_->prev = new_elt;
    else
      _end_list_ = new_elt;

    _deb_list_ = new_elt;

    ++_nb_elements_;
  }

operator=() [1/4]

template<typename Key, typename Val, typename Alloc>

template<typename OtherAlloc >

INLINE HashTableList< Key, Val, Alloc >& gum::HashTableList< Key, Val, Alloc >::operator=

(

const HashTableList< Key, Val, OtherAlloc > &

from

)

Definition at line 186 of file hashTable_tpl.h.

                                                        {
    // avoid self assignment
    if (this != reinterpret_cast< const HashTableList< Key, Val, Alloc >* >(&from)) {
      clear();
      _copy_(from);
    }

    return *this;
  }

operator=() [2/4]

template<typename Key, typename Val, typename Alloc>

INLINE HashTableList< Key, Val, Alloc > & gum::HashTableList< Key, Val, Alloc >::operator=

(

const HashTableList< Key, Val, Alloc > &

from

)

Assignment operator.

The new list and that which is copied do not share elements: the new list contains new instances of the keys and values stored in the copied list. Of course, if these values are pointers, the new values point toward the same elements.

If some allocation problem occurs or if copying the Val elements cannot be performed properly, exceptions may be raised. In this case, the function guarantees that no memory leak occurs and that the list is kept in a coherent state (that of an empty list).

Warning

operator= does not change the current allocator of *this

Parameters

from	The gum::HashTableList to copy.

Returns

Returns this gum::HashTableList.

Definition at line 174 of file hashTable_tpl.h.

                                                                                             {
    // avoid self assignment
    if (this != &from) {
      clear();
      _copy_(from);
    }

    return *this;
  }

operator=() [3/4]

template<typename Key, typename Val, typename Alloc>

template<typename OtherAlloc >

HashTableList< Key, Val, Alloc >& gum::HashTableList< Key, Val, Alloc >::operator=

(

const HashTableList< Key, Val, OtherAlloc > &

from

)

Generalized assignment operator.

The new list and that which is copied do not share elements: the new list contains new instances of the keys and values stored in the copied list. Of course, if these values are pointers, the new values point toward the same elements.

If some allocation problem occurs or if copying the Val elements cannot be performed properly, exceptions may be raised. In this case, the function guarantees that no memory leak occurs and that the list is kept in a coherent state (that of an empty list).

Warning

operator= does not change the current allocator of *this

Parameters

from	The gum::HashTableList to copy.

Returns

Returns this gum::HashTableList.

operator=() [4/4]

template<typename Key, typename Val, typename Alloc>

INLINE HashTableList< Key, Val, Alloc > & gum::HashTableList< Key, Val, Alloc >::operator= ( HashTableList< Key, Val, Alloc > &&  from )

noexcept

Move operator.

Warning

operator= does not change the current allocator of *this

Parameters

from	The gum::HashTableList to copy.

Returns

Returns this gum::HashTableList.

Definition at line 199 of file hashTable_tpl.h.

                                                                                                 {
    // avoid self assignment
    if (this != &from) {
      _deb_list_      = from._deb_list_;
      _end_list_      = from._end_list_;
      _nb_elements_   = from._nb_elements_;
      from._deb_list_ = nullptr;
    }

    return *this;
  }

operator[]() [1/2]

template<typename Key , typename Val , typename Alloc >

INLINE HashTableList< Key, Val, Alloc >::mapped_type & gum::HashTableList< Key, Val, Alloc >::operator[]

(

const key_type &

key

)

Returns the value corresponding to a given key.

Parameters

key	The key for which a value is returned.

Returns

Returns the value corresponding to a given key.

Exceptions

NotFound

is raised if the element cannot be found

Definition at line 252 of file hashTable_tpl.h.

                                                                {
    for (Bucket* ptr = _deb_list_; ptr != nullptr; ptr = ptr->next)
      if (ptr->key() == key) return ptr->val();

    GUM_ERROR(NotFound, "No element with the key <" << key << ">")
  }

operator[]() [2/2]

template<typename Key , typename Val , typename Alloc >

INLINE const HashTableList< Key, Val, Alloc >::mapped_type & gum::HashTableList< Key, Val, Alloc >::operator[]

(

const key_type &

key

)

const

Returns the value corresponding to a given key.

Parameters

key	The key for which a value is returned.

Returns

Returns the value corresponding to a given key.

Exceptions

NotFound

is raised if the element cannot be found

Definition at line 243 of file hashTable_tpl.h.

                                                                      {
    for (Bucket* ptr = _deb_list_; ptr != nullptr; ptr = ptr->next)
      if (ptr->key() == key) return ptr->val();

    GUM_ERROR(NotFound, "No element with the key <" << key << ">")
  }

setAllocator()

template<typename Key, typename Val, typename Alloc>

INLINE void gum::HashTableList< Key, Val, Alloc >::setAllocator

(

BucketAllocator &

alloc

)

Sets a new allocator.

Parameters

alloc

The new allocator.

Definition at line 212 of file hashTable_tpl.h.

                                                                      {
    _alloc_bucket_ = &alloc;
  }

Friends And Related Function Documentation

HashTableList

template<typename Key, typename Val, typename Alloc>

template<typename K , typename V , typename A >

friend class HashTableList

friend

Friend for faster access.

Definition at line 510 of file hashTable.h.

HashTable< Key, Val, Alloc >

template<typename Key, typename Val, typename Alloc>

friend class HashTable< Key, Val, Alloc >

friend

Friend for faster access.

Definition at line 511 of file hashTable.h.

HashTableConstIterator< Key, Val >

template<typename Key, typename Val, typename Alloc>

friend class HashTableConstIterator< Key, Val >

friend

Friend for faster access.

Definition at line 513 of file hashTable.h.

HashTableConstIteratorSafe< Key, Val >

template<typename Key, typename Val, typename Alloc>

friend class HashTableConstIteratorSafe< Key, Val >

friend

Friend for faster access.

Definition at line 515 of file hashTable.h.

HashTableIterator< Key, Val >

template<typename Key, typename Val, typename Alloc>

friend class HashTableIterator< Key, Val >

friend

Friend for faster access.

Definition at line 512 of file hashTable.h.

HashTableIteratorSafe< Key, Val >

template<typename Key, typename Val, typename Alloc>

friend class HashTableIteratorSafe< Key, Val >

friend

Friend for faster access.

Definition at line 514 of file hashTable.h.

operator<< [1/4]

template<typename Key, typename Val, typename Alloc>

std::ostream& operator<< ( std::ostream &  s, const HashTableList< Key, Val, Alloc > &  list  )

friend

Prints the content of a gum::HashTableList in the stream.

Definition at line 1167 of file hashTable_tpl.h.

                                                                                           {
    bool deja = false;
    stream << "[";

    for (HashTableBucket< Key, Val >* ptr = list._deb_list_; ptr;
         ptr = ptr->list.next, deja = true) {
      if (deja) stream << " , ";

      stream << ptr->key() << "=>" << ptr->val();
    }

    stream << "]";

    return stream;
  }

operator<< [2/4]

template<typename Key, typename Val, typename Alloc>

std::ostream& operator<< ( std::ostream &  s, const HashTableList< Key *, Val, Alloc > &  list  )

friend

Prints the content of a gum::HashTableList with pointers key in the stream.

Definition at line 1184 of file hashTable_tpl.h.

                                                                                            {
    bool deja = false;
    stream << "[";

    for (HashTableBucket< Key, Val >* ptr = list._deb_list_; ptr;
         ptr = ptr->list.next, deja = true) {
      if (deja) stream << " , ";

      stream << ptr->key() << "=>" << ptr->val();
    }

    stream << "]";

    return stream;
  }

operator<< [3/4]

template<typename Key, typename Val, typename Alloc>

std::ostream& operator<< ( std::ostream &  s, const HashTable< Key, Val, Alloc > &  table  )

friend

Prints the content of a gum::HashTable in the stream.

Definition at line 1201 of file hashTable_tpl.h.

                                                                                        {
    bool deja = false;
    stream << "{";

    for (Size i = Size(0); i < table._size_; ++i)
      for (auto ptr = table._nodes_[i]._deb_list_; ptr; ptr = ptr->next) {
        if (deja) stream << " , ";

        stream << ptr->key() << "=>" << ptr->val();

        deja = true;
      }

    stream << "}";

    return stream;
  }

operator<< [4/4]

template<typename Key, typename Val, typename Alloc>

std::ostream& operator<< ( std::ostream &  s, const HashTable< Key *, Val, Alloc > &  table  )

friend

Prints the content of a gum::HashTable with pointers key in the stream.

Definition at line 1220 of file hashTable_tpl.h.

                                                                                         {
    bool deja = false;
    stream << "{";

    for (Size i = Size(0); i < table._size_; ++i)
      for (auto ptr = table._nodes_[i]._deb_list_; ptr; ptr = ptr->next) {
        if (deja) stream << " , ";

        stream << ptr->key() << "=>" << ptr->val();

        deja = true;
      }

    stream << "}";

    return stream;
  }

Member Data Documentation

_alloc_bucket_

template<typename Key, typename Val, typename Alloc>

BucketAllocator* gum::HashTableList< Key, Val, Alloc >::_alloc_bucket_

mutableprivate

The allocator of the containing hashTable.

Definition at line 532 of file hashTable.h.

_deb_list_

template<typename Key, typename Val, typename Alloc>

HashTableBucket< Key, Val >* gum::HashTableList< Key, Val, Alloc >::_deb_list_ {nullptr}

private

A pointer on the first element of the chained list.

Definition at line 523 of file hashTable.h.

_end_list_

template<typename Key, typename Val, typename Alloc>

HashTableBucket< Key, Val >* gum::HashTableList< Key, Val, Alloc >::_end_list_ {nullptr}

private

A pointer on the last element of the chained list.

Definition at line 526 of file hashTable.h.

_nb_elements_

template<typename Key, typename Val, typename Alloc>

Size gum::HashTableList< Key, Val, Alloc >::_nb_elements_ {Size(0)}

private

The number of elements in the chained list.

Definition at line 529 of file hashTable.h.

---

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

• agrum/tools/core/hashTable.h
• agrum/tools/core/hashTable_tpl.h