gum::HashTableIteratorSafe< Key, Val > Class Template Reference

Safe Iterators for hashtables. More...

#include <agrum/core/hashTable.h>

Inheritance diagram for gum::HashTableIteratorSafe< Key, Val >:

Collaboration diagram for gum::HashTableIteratorSafe< Key, Val >:

Public Member Functions
mapped_type &	val ()
	Returns the mapped value pointed to by the iterator. More...
template<typename Alloc >
INLINE	HashTableIteratorSafe (const HashTable< Key, Val, Alloc > &tab)
template<typename Alloc >
INLINE	HashTableIteratorSafe (const HashTable< Key, Val, Alloc > &tab, Size ind_elt)
Constructors / Destructors
	HashTableIteratorSafe ()
	Basic constructor: creates an iterator pointing to nothing. More...
template<typename Alloc >
	HashTableIteratorSafe (const HashTable< Key, Val, Alloc > &tab)
	Constructor for an iterator pointing to the first element of a hashtable. More...
template<typename Alloc >
	HashTableIteratorSafe (const HashTable< Key, Val, Alloc > &tab, Size ind_elt)
	Constructor for an iterator pointing to the nth element of a hashtable. More...
	HashTableIteratorSafe (const HashTableIteratorSafe< Key, Val > &from)
	Copy constructor. More...
	HashTableIteratorSafe (const HashTableIterator< Key, Val > &from)
	Copy constructor. More...
	HashTableIteratorSafe (HashTableIteratorSafe< Key, Val > &&from) noexcept
	Move constructor. More...
	~HashTableIteratorSafe () noexcept
	Class destructor. More...
Operators
HashTableIteratorSafe< Key, Val > &	operator= (const HashTableIteratorSafe< Key, Val > &from)
	Copy operator. More...
HashTableIteratorSafe< Key, Val > &	operator= (const HashTableIterator< Key, Val > &from)
	Copy operator. More...
HashTableIteratorSafe< Key, Val > &	operator= (HashTableIteratorSafe< Key, Val > &&from) noexcept
	Move operator. More...
HashTableIteratorSafe< Key, Val > &	operator++ () noexcept
	Makes the iterator point to the next element in the hash table. More...
HashTableIteratorSafe< Key, Val > &	operator+= (Size i) noexcept
	Makes the iterator point to i elements further in the hashtable. More...
HashTableIteratorSafe< Key, Val >	operator+ (Size i) const
	Returns a new iterator pointing to i elements further in the hashtable. More...
bool	operator!= (const HashTableIteratorSafe< Key, Val > &from) const noexcept
	Checks whether two iterators are pointing toward different elements. More...
bool	operator== (const HashTableIteratorSafe< Key, Val > &from) const noexcept
	Checks whether two iterators are pointing toward equal elements. More...
value_type &	operator* ()
	Returns the value pointed to by the iterator. More...
const value_type &	operator* () const
	Returns the value pointed to by the iterator. More...
Accessors / Modifiers
const key_type &	key () const
	Returns the key pointed to by the iterator. More...
const mapped_type &	val () const
	Returns the mapped value pointed to by the iterator. More...
void	clear () noexcept
	Makes the iterator point toward nothing (in particular, it is not related anymore to its current hash table). More...
Operators
bool	operator!= (const HashTableConstIteratorSafe< Key, Val > &from) const noexcept
	Checks whether two iterators are not equal. More...
bool	operator== (const HashTableConstIteratorSafe< Key, Val > &from) const noexcept
	Checks whether two iterators are equal. More...

Public Types
using	iterator_category = std::forward_iterator_tag
	Types for STL compliance. 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	difference_type = std::ptrdiff_t
	Types for STL compliance. More...

Protected Attributes
const HashTable< Key, Val > *	__table {nullptr}
	The hash table the iterator is pointing to. More...
Size	__index {Size(0)}
	the index of the chained list pointed to by the iterator in the array __nodes of the hash table. More...
HashTableBucket< Key, Val > *	__bucket {nullptr}
	The bucket in the chained list pointed to by the iterator. More...
HashTableBucket< Key, Val > *	__next_bucket {nullptr}
	the bucket we should start from when we decide to do a ++. More...

Protected Member Functions
HashTableBucket< Key, Val > *	__getBucket () const noexcept
	Returns the current iterator's bucket. More...
Size	__getIndex () const noexcept
	Returns the index in the hashtable's node vector pointed to by the iterator. More...
void	__removeFromSafeList () const
	Removes the iterator from its hashtable' safe iterators list. More...
void	__insertIntoSafeList () const
	Insert the iterator into the hashtable's list of safe iterators. More...

Detailed Description

template<typename Key, typename Val>
class gum::HashTableIteratorSafe< Key, Val >

Safe Iterators for hashtables.

HashTableIteratorSafe provides a safe way to parse HashTables. They are safe because they are kept informed by the hashtable they belong to of the elements deleted by the user. Hence, even if the user removes an element pointed to by a HashTableIteratorSafe, using the latter to access this element will never crash the application. Instead it will properly throw an UndefinedIteratorValue exception.

Developers may consider using HashTable<x,y>::iterator_safe instead of HashTableIteratorSafe<x,y>.

Usage example:

// creation of a hash table with 10 elements
HashTable<int,string> table;
for (int i = 0; i< 10; ++i)
  table.insert (i,"xxx" + string (i,'x'));

// parse the hash table
for (HashTable<int,string>::iterator_safe iter = table.beginSafe ();
       iter != table.endSafe (); ++iter) {
  // display the values
  cerr << "at " << iter.key() << " value = " << iter.val () << endl;
  HashTable<int,string>::value_type& elt = *iter;
  std::pair<const int, string>& xelt = *iter;
}

// check whether two iterators point toward the same element
HashTable<int,string>::iterator_safe iter1 = table1.beginSafe ();
HashTable<int,string>::iterator_safe iter2 = table1.endSafe ();
if (iter1 != iter) {
  cerr << "iter1 and iter2 point toward different elements";
}

// make iter1 point toward nothing
iter1.clear ();

Template Parameters

Key	The gum::HashTable key.
Val	The gum::HashTable Value.

Definition at line 2220 of file hashTable.h.

Member Typedef Documentation

const_pointer

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 2231 of file hashTable.h.

const_reference

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 2229 of file hashTable.h.

difference_type

template<typename Key, typename Val>

using gum::HashTableIteratorSafe< Key, Val >::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 2232 of file hashTable.h.

iterator_category

template<typename Key, typename Val>

using gum::HashTableIteratorSafe< Key, Val >::iterator_category = std::forward_iterator_tag

Types for STL compliance.

Definition at line 2224 of file hashTable.h.

key_type

template<typename Key, typename Val>

using gum::HashTableIteratorSafe< Key, Val >::key_type = Key

Types for STL compliance.

Definition at line 2225 of file hashTable.h.

mapped_type

template<typename Key, typename Val>

using gum::HashTableIteratorSafe< Key, Val >::mapped_type = Val

Types for STL compliance.

Definition at line 2226 of file hashTable.h.

pointer

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 2230 of file hashTable.h.

reference

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 2228 of file hashTable.h.

value_type

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 2227 of file hashTable.h.

Constructor & Destructor Documentation

HashTableIteratorSafe() [1/8]

template<typename Key , typename Val >

INLINE gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe

(

)

Basic constructor: creates an iterator pointing to nothing.

Definition at line 1749 of file hashTable_tpl.h.

                                                                  :
      HashTableConstIteratorSafe< Key, Val >() {
    GUM_CONSTRUCTOR(HashTableIteratorSafe);
  }

HashTableIteratorSafe() [2/8]

template<typename Key, typename Val>

template<typename Alloc >

gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe

(

const HashTable< Key, Val, Alloc > &

tab

)

Constructor for an iterator pointing to the first element of a hashtable.

Template Parameters

Alloc

The gum::HashTable allocator.

HashTableIteratorSafe() [3/8]

template<typename Key, typename Val>

template<typename Alloc >

gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe	(	const HashTable< Key, Val, Alloc > &	tab,
		Size	ind_elt
	)

Constructor for an iterator pointing to the nth element of a hashtable.

The method runs in time linear to ind_elt.

Parameters

tab	the hash table to which the so-called element belongs
ind_elt	the position of the element in the hash table (0 means the first element).

Template Parameters

Alloc

The gum::HashTable allocator.

Exceptions

UndefinedIteratorValue

Raised if the element cannot be found

HashTableIteratorSafe() [4/8]

template<typename Key, typename Val>

INLINE gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe

(

const HashTableIteratorSafe< Key, Val > &

from

)

Copy constructor.

Parameters

from	the gum::HashTableIteratorSafe to copy.

Returns

This gum::HashTableIteratorSafe.

Definition at line 1771 of file hashTable_tpl.h.

                                                    :
      HashTableConstIteratorSafe< Key, Val >(from) {
    GUM_CONS_CPY(HashTableIteratorSafe);
  }

HashTableIteratorSafe() [5/8]

template<typename Key, typename Val>

INLINE gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe ( const HashTableIterator< Key, Val > &  from )

explicit

Copy constructor.

Parameters

from	the gum::HashTableIterator to copy.

Returns

This gum::HashTableIteratorSafe.

Definition at line 1778 of file hashTable_tpl.h.

                                                :
      HashTableConstIteratorSafe< Key, Val >(from) {
    GUM_CONS_CPY(HashTableIteratorSafe);
  }

HashTableIteratorSafe() [6/8]

template<typename Key, typename Val>

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

noexcept

Move constructor.

Parameters

from	The gum::HashTableIteratorSafe to move.

Returns

Returns this gum::HashTableIteratorSafe.

Definition at line 1785 of file hashTable_tpl.h.

                                                        :
      HashTableConstIteratorSafe< Key, Val >(std::move(from)) {
    GUM_CONS_MOV(HashTableIteratorSafe);
  }

~HashTableIteratorSafe()

template<typename Key , typename Val >

INLINE gum::HashTableIteratorSafe< Key, Val >::~HashTableIteratorSafe ( )

noexcept

Class destructor.

Definition at line 1792 of file hashTable_tpl.h.

                                                                            {
    GUM_DESTRUCTOR(HashTableIteratorSafe);
  }

HashTableIteratorSafe() [7/8]

template<typename Key, typename Val>

template<typename Alloc >

INLINE gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe

(

const HashTable< Key, Val, Alloc > &

tab

)

Definition at line 1756 of file hashTable_tpl.h.

                                              :
      HashTableConstIteratorSafe< Key, Val >(tab) {
    GUM_CONSTRUCTOR(HashTableIteratorSafe);
  }

HashTableIteratorSafe() [8/8]

template<typename Key, typename Val>

template<typename Alloc >

INLINE gum::HashTableIteratorSafe< Key, Val >::HashTableIteratorSafe	(	const HashTable< Key, Val, Alloc > &	tab,
		Size	ind_elt
	)

Definition at line 1764 of file hashTable_tpl.h.

                                                            :
      HashTableConstIteratorSafe< Key, Val >(tab, ind_elt) {
    GUM_CONSTRUCTOR(HashTableIteratorSafe);
  }

Member Function Documentation

__getBucket()

template<typename Key , typename Val >

INLINE HashTableBucket< Key, Val > * gum::HashTableConstIteratorSafe< Key, Val >::__getBucket ( ) const

protectednoexceptinherited

Returns the current iterator's bucket.

Definition at line 1735 of file hashTable_tpl.h.

Referenced by gum::HashTable< Val, Size, IndexAllocator >::erase().

                                                                            {
    return __bucket;
  }

Here is the caller graph for this function:

__getIndex()

template<typename Key , typename Val >

INLINE Size gum::HashTableConstIteratorSafe< Key, Val >::__getIndex ( ) const

protectednoexceptinherited

Returns the index in the hashtable's node vector pointed to by the iterator.

Returns

Returns the index in the hashtable's node vector pointed to by the iterator.

Definition at line 1740 of file hashTable_tpl.h.

Referenced by gum::HashTable< Val, Size, IndexAllocator >::erase().

                                                                                {
    return __index;
  }

Here is the caller graph for this function:

__insertIntoSafeList()

template<typename Key , typename Val >

INLINE void gum::HashTableConstIteratorSafe< Key, Val >::__insertIntoSafeList ( ) const

protectedinherited

Insert the iterator into the hashtable's list of safe iterators.

Definition at line 1287 of file hashTable_tpl.h.

                                                                        {
    __table->__safe_iterators.push_back(
       const_cast< HashTableConstIteratorSafe< Key, Val >* >(this));
  }

__removeFromSafeList()

template<typename Key , typename Val >

INLINE void gum::HashTableConstIteratorSafe< Key, Val >::__removeFromSafeList ( ) const

protectedinherited

Removes the iterator from its hashtable' safe iterators list.

Definition at line 1294 of file hashTable_tpl.h.

                                                                        {
    if (__table == nullptr) return;

    // find where the iterator is
    std::vector< HashTableConstIteratorSafe< Key, Val >* >& iter_vect =
       __table->__safe_iterators;

    auto len = iter_vect.size();
    for (Size i = Size(0); i < len; ++i) {
      if (iter_vect[i] == this) {
        iter_vect.erase(iter_vect.begin() + i);
        break;
      }
    }
  }

clear()

template<typename Key , typename Val >

INLINE void gum::HashTableConstIteratorSafe< Key, Val >::clear ( )

noexceptinherited

Makes the iterator point toward nothing (in particular, it is not related anymore to its current hash table).

It is mainly used by the hashtable when the latter is deleted while the iterator is still alive.

Definition at line 1583 of file hashTable_tpl.h.

                                                                     {
    // remove the iterator from the table's iterator list
    __removeFromSafeList();

    // set its table as well as the element it points to to 0
    __table = nullptr;
    __bucket = nullptr;
    __next_bucket = nullptr;
    __index = Size(0);
  }

key()

template<typename Key , typename Val >

INLINE const HashTableConstIteratorSafe< Key, Val >::key_type & gum::HashTableConstIteratorSafe< Key, Val >::key ( ) const

inherited

Returns the key pointed to by the iterator.

Returns

Returns the key pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised when the iterator does not point to a valid hash table element

Definition at line 1564 of file hashTable_tpl.h.

Referenced by gum::SetTerminalNodePolicy< GUM_SCALAR >::id(), and gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::key().

                                                       {
    if (__bucket != nullptr)
      return __bucket->key();
    else {
      GUM_ERROR(UndefinedIteratorValue, "Accessing a nullptr object");
    }
  }

Here is the caller graph for this function:

operator!=() [1/2]

template<typename Key, typename Val>

INLINE bool gum::HashTableConstIteratorSafe< Key, Val >::operator!= ( const HashTableConstIteratorSafe< Key, Val > &  from ) const

noexceptinherited

Checks whether two iterators are not equal.

Parameters

from	from The iterator to test for inequality.

Returns

Returns true if from and this iterator are inequal.

Definition at line 1711 of file hashTable_tpl.h.

              {
    return ((__bucket != from.__bucket) || (__index != from.__index));
  }

operator!=() [2/2]

template<typename Key, typename Val>

INLINE bool gum::HashTableIteratorSafe< Key, Val >::operator!= ( const HashTableIteratorSafe< Key, Val > &  from ) const

noexcept

Checks whether two iterators are pointing toward different elements.

Parameters

from	The gum::HashTableIteratorSafe to test for inequality.

Returns

Returns true if this and from are not equal.

Definition at line 1849 of file hashTable_tpl.h.

                                                                                       {
    return HashTableConstIteratorSafe< Key, Val >::operator!=(from);
  }

operator*() [1/2]

template<typename Key , typename Val >

INLINE HashTableIteratorSafe< Key, Val >::value_type & gum::HashTableIteratorSafe< Key, Val >::operator*

(

)

Returns the value pointed to by the iterator.

Returns

Returns the value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised when the iterator does not point to a valid hash table element

Definition at line 1861 of file hashTable_tpl.h.

                                                  {
    return const_cast< Val& >(HashTableConstIteratorSafe< Key, Val >::operator*());
  }

operator*() [2/2]

template<typename Key , typename Val >

INLINE const HashTableIteratorSafe< Key, Val >::value_type & gum::HashTableIteratorSafe< Key, Val >::operator*

(

)

const

Returns the value pointed to by the iterator.

Returns

Returns the value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised when the iterator does not point to a valid hash table element.

Definition at line 1867 of file hashTable_tpl.h.

                                                        {
    return HashTableConstIteratorSafe< Key, Val >::operator*();
  }

operator+()

template<typename Key , typename Val >

INLINE HashTableIteratorSafe< Key, Val > gum::HashTableIteratorSafe< Key, Val >::operator+

(

Size

i

)

const

Returns a new iterator pointing to i elements further in the hashtable.

Parameters

i	The number of increments.

Returns

Returns this gum::HashTableIteratorSafe.

Definition at line 1841 of file hashTable_tpl.h.

                                                                    {
    HashTableIteratorSafe< Key, Val > iter{*this};
    iter += nb;
    return iter;
  }

operator++()

template<typename Key , typename Val >

INLINE HashTableIteratorSafe< Key, Val > & gum::HashTableIteratorSafe< Key, Val >::operator++ ( )

noexcept

Makes the iterator point to the next element in the hash table.

for (iter = hash.beginSafe (); iter != hash.endSafe (); ++iter) { }

The above loop is guaranteed to parse the whole hash table as long as no element is added to or deleted from the hash table while being in the loop. Deleting elements during the loop is guaranteed to never produce a segmentation fault.

Returns

This gum::HashTableIteratorSafe.

Definition at line 1827 of file hashTable_tpl.h.

                                                                  {
    HashTableConstIteratorSafe< Key, Val >::operator++();
    return *this;
  }

operator+=()

template<typename Key , typename Val >

INLINE HashTableIteratorSafe< Key, Val > & gum::HashTableIteratorSafe< Key, Val >::operator+= ( Size  i )

noexcept

Makes the iterator point to i elements further in the hashtable.

Parameters

i	The number of increments.

Returns

Return this gum::HashTableIteratorSafe.

Definition at line 1834 of file hashTable_tpl.h.

                                                                         {
    HashTableConstIteratorSafe< Key, Val >::operator+=(nb);
    return *this;
  }

operator=() [1/3]

template<typename Key, typename Val>

INLINE HashTableIteratorSafe< Key, Val > & gum::HashTableIteratorSafe< Key, Val >::operator=

(

const HashTableIteratorSafe< Key, Val > &

from

)

Copy operator.

Parameters

from	The gum::HashTableIteratorSafe to copy.

Returns

Returns this gum::HashTableIterator.

Definition at line 1804 of file hashTable_tpl.h.

                                                                                                     {
    GUM_OP_CPY(HashTableIteratorSafe);
    HashTableConstIteratorSafe< Key, Val >::operator=(from);
    return *this;
  }

operator=() [2/3]

template<typename Key, typename Val>

INLINE HashTableIteratorSafe< Key, Val > & gum::HashTableIteratorSafe< Key, Val >::operator=

(

const HashTableIterator< Key, Val > &

from

)

Copy operator.

Parameters

from	The gum::HashTableIterator to copy.

Returns

Returns this gum::HashTableIterator.

Definition at line 1812 of file hashTable_tpl.h.

                                                                                                 {
    GUM_OP_CPY(HashTableIteratorSafe);
    HashTableConstIteratorSafe< Key, Val >::operator=(from);
    return *this;
  }

operator=() [3/3]

template<typename Key, typename Val>

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

noexcept

Move operator.

Parameters

from	The gum::HashTableIteratorSafe to move.

Returns

Returns this gum::HashTableIterator.

Definition at line 1820 of file hashTable_tpl.h.

                                                                                                         {
    HashTableConstIteratorSafe< Key, Val >::operator=(std::move(from));
    return *this;
  }

operator==() [1/2]

template<typename Key, typename Val>

INLINE bool gum::HashTableConstIteratorSafe< Key, Val >::operator== ( const HashTableConstIteratorSafe< Key, Val > &  from ) const

noexceptinherited

Checks whether two iterators are equal.

Parameters

from	from The iterator to test for equality.

Returns

Returns true if from and this iterator are equal.

Definition at line 1718 of file hashTable_tpl.h.

              {
    return ((__bucket == from.__bucket) && (__index == from.__index));
  }

operator==() [2/2]

template<typename Key, typename Val>

INLINE bool gum::HashTableIteratorSafe< Key, Val >::operator== ( const HashTableIteratorSafe< Key, Val > &  from ) const

noexcept

Checks whether two iterators are pointing toward equal elements.

Parameters

from	The gum::HashTableIteratorSafe to test for equality.

Returns

Returns true if this and from are equal.

Definition at line 1855 of file hashTable_tpl.h.

                                                                                       {
    return HashTableConstIteratorSafe< Key, Val >::operator==(from);
  }

val() [1/2]

template<typename Key , typename Val >

INLINE const HashTableConstIteratorSafe< Key, Val >::mapped_type & gum::HashTableConstIteratorSafe< Key, Val >::val ( ) const

inherited

Returns the mapped value pointed to by the iterator.

Returns

Returns the mapped value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised when the iterator does not point to a valid hash table element.

Definition at line 1574 of file hashTable_tpl.h.

Referenced by gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::val(), and gum::SetTerminalNodePolicy< GUM_SCALAR >::value().

                                                       {
    if (__bucket != nullptr)
      return __bucket->val();
    else {
      GUM_ERROR(UndefinedIteratorValue, "Accessing a nullptr object");
    }
  }

Here is the caller graph for this function:

val() [2/2]

template<typename Key , typename Val >

INLINE HashTableIteratorSafe< Key, Val >::mapped_type & gum::HashTableIteratorSafe< Key, Val >::val

(

)

Returns the mapped value pointed to by the iterator.

Returns

Returns the mapped value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised when the iterator does not point to a valid hash table element.

Definition at line 1798 of file hashTable_tpl.h.

                                            {
    return const_cast< Val& >(HashTableConstIteratorSafe< Key, Val >::val());
  }

Member Data Documentation

__bucket

template<typename Key, typename Val>

HashTableBucket< Key, Val >* gum::HashTableConstIteratorSafe< Key, Val >::__bucket {nullptr}

protectedinherited

The bucket in the chained list pointed to by the iterator.

Definition at line 2135 of file hashTable.h.

Referenced by gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::operator=().

__index

template<typename Key, typename Val>

Size gum::HashTableConstIteratorSafe< Key, Val >::__index {Size(0)}

protectedinherited

the index of the chained list pointed to by the iterator in the array __nodes of the hash table.

Definition at line 2132 of file hashTable.h.

Referenced by gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::operator=().

__next_bucket

template<typename Key, typename Val>

HashTableBucket< Key, Val >* gum::HashTableConstIteratorSafe< Key, Val >::__next_bucket {nullptr}

protectedinherited

the bucket we should start from when we decide to do a ++.

Usually it should be equal to nullptr. However, if the user has deleted the object pointed to by bucket, this will point to another bucket. When it is equal to nullptr, it means that the bucket reached after a ++ belongs to another slot of the hash table's '__node' vector.

Definition at line 2145 of file hashTable.h.

Referenced by gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::operator=().

__table

template<typename Key, typename Val>

const HashTable< Key, Val >* gum::HashTableConstIteratorSafe< Key, Val >::__table {nullptr}

protectedinherited

The hash table the iterator is pointing to.

Definition at line 2126 of file hashTable.h.

Referenced by gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::HashTableConstIteratorSafe(), and gum::HashTableConstIteratorSafe< const gum::DiscreteVariable *, Idx >::operator=().

---

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

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