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 305 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 317 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 318 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 322 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 315 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 313 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 309 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 310 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 314 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 312 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 316 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 311 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 140 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 147 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 156 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 134 of file hashTable_tpl.h.

                            :
      alloc_bucket__{allocator} {}

Member Function Documentation

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 228 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 242 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 100 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 165 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;
  }

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;
    }
  }

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 282 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 109 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 273 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 287 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 193 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 179 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 207 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 265 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 256 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 221 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 517 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 518 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 520 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 522 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 519 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 521 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 1217 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 1235 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 1253 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 1273 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 543 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 534 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 537 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 540 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