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

Safe Const Iterators for hashtables. More...

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

Public Types
using	iterator_category = std::forward_iterator_tag
	Types for STL compliance.
using	key_type = Key
	Types for STL compliance.
using	mapped_type = Val
	Types for STL compliance.
using	value_type = std::pair< const Key, Val >
	Types for STL compliance.
using	reference = value_type&
	Types for STL compliance.
using	const_reference = const value_type&
	Types for STL compliance.
using	pointer = value_type*
	Types for STL compliance.
using	const_pointer = const value_type*
	Types for STL compliance.
using	difference_type = std::ptrdiff_t
	Types for STL compliance.

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

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

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

Friends
class	HashTable< Key, Val >
	Class HashTable must be a friend because it stores iterator end and this can be properly initialized only when the hashtable has been fully allocated.

Detailed Description

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

Safe Const Iterators for hashtables.

HashTableConstIteratorSafe 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 HashTableConstIteratorSafe, using the latter to access this element will never crash the application. Instead it will properly throw a UndefinedIteratorValue exception.

Developers may consider using HashTable<x,y>::const_iterator_safe instead of HashTableConstIteratorSafe<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>::const_iterator_safe iter = table.cbeginSafe ();
       iter != table.cendSafe (); ++iter) {
  // display the values
  cerr << "at " << iter.key () << " value = " << iter.val () << endl;
  const HashTable<int,string>::value_type& elt = *iter;
  const std::pair<const int, string>& xelt = *iter;
}
 
// check whether two iterators point toward the same element
HashTable<int,string>::const_iterator_safe iter1 = table1.cbeginSafe ();
HashTable<int,string>::const_iterator_safe iter2 = table1.cendSafe ();
if (iter1 != iter) {
  cerr << "iter1 and iter2 point toward different elements";
}
 
// make iter1 point toward nothing
iter1.clear ();

Definition at line 1602 of file hashTable.h.

Member Typedef Documentation

const_pointer

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1613 of file hashTable.h.

const_reference

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1611 of file hashTable.h.

difference_type

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1614 of file hashTable.h.

iterator_category

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1606 of file hashTable.h.

key_type

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1607 of file hashTable.h.

mapped_type

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1608 of file hashTable.h.

pointer

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1612 of file hashTable.h.

reference

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1610 of file hashTable.h.

value_type

template<typename Key, typename Val>

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

Types for STL compliance.

Definition at line 1609 of file hashTable.h.

Constructor & Destructor Documentation

HashTableConstIteratorSafe() [1/6]

template<typename Key, typename Val>

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

explicit

Basic constructor: creates an iterator pointing to nothing.

Definition at line 1035 of file hashTable_tpl.h.

                                                                            {
    // for debugging purposes
    GUM_CONSTRUCTOR(HashTableConstIteratorSafe);
  }

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), ~HashTableConstIteratorSafe(), operator!=(), operator+(), operator=(), operator=(), operator=(), and operator==().

Here is the caller graph for this function:

HashTableConstIteratorSafe() [2/6]

template<typename Key, typename Val>

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

(

const HashTable< Key, Val > &

tab

)

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

Parameters

tab	A gum::HashTable to iterate over.

Definition at line 1041 of file hashTable_tpl.h.

                                        :
      _table_{reinterpret_cast< const HashTable< Key, Val >* >(&tab)} {
    // for debugging purposes
    GUM_CONSTRUCTOR(HashTableConstIteratorSafe);
 
    // make the hashtable keep track of this iterator
    _insertIntoSafeList_();
 
    if (_table_->_nb_elements_) {
      if (_table_->_begin_index_ != std::numeric_limits< Size >::max()) {
        _index_  = _table_->_begin_index_;
        _bucket_ = _table_->_nodes_[_index_]._end_list_;
      } else {
        // find the element we shall point to from the start of the hashtable
        for (Size i = _table_->_size_ - Size(1);; --i) {   // no test on i since
                                                           //  _nb_elements_ != 0
          if (_table_->_nodes_[i]._nb_elements_) {
            _index_                = i;
            _bucket_               = _table_->_nodes_[_index_]._end_list_;
            _table_->_begin_index_ = _index_;
            break;
          }
        }
      }
    }
  }

References HashTableConstIteratorSafe(), _insertIntoSafeList_(), _table_, and HashTable< Key, Val >.

Here is the call graph for this function:

HashTableConstIteratorSafe() [3/6]

template<typename Key, typename Val>

gum::HashTableConstIteratorSafe< Key, Val >::HashTableConstIteratorSafe	(	const HashTable< Key, Val > &	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).

Exceptions

UndefinedIteratorValue

Raised if the element cannot be found.

Definition at line 1070 of file hashTable_tpl.h.

                    : _table_{reinterpret_cast< const HashTable< Key, Val >* >(&tab)} {
    Size i;
 
    // check if we are looking for a begin() and we know for sure its index
    if ((ind_elt == Size(0)) && (_table_->_begin_index_ != std::numeric_limits< Size >::max())) {
      _index_  = _table_->_begin_index_;
      _bucket_ = _table_->_nodes_[_index_]._end_list_;
    } else {
      // check if it is faster to find the ind_eltth element from the start or
      // from the end of the hashtable
      if (ind_elt < (_table_->_nb_elements_ >> 1)) {
        // find the element we shall point to from the start of the hashtable
        for (i = _table_->_size_ - 1;; --i) {   // no test on i since
          // ind_elt < table_-> _nb_elements_
          if (_table_->_nodes_[i]._nb_elements_) {
            if (ind_elt >= _table_->_nodes_[i]._nb_elements_)
              ind_elt -= _table_->_nodes_[i]._nb_elements_;
            else {
              for (_bucket_ = _table_->_nodes_[i]._end_list_; ind_elt;
                   --ind_elt, _bucket_ = _bucket_->prev) {}
 
              _index_ = i;
              break;
            }
          }
        }
      } else {
        // ind_elt = the index of the element we should point to
        // check if the index passed as parameter is valid
        if (ind_elt >= _table_->_nb_elements_) {
          GUM_ERROR(UndefinedIteratorValue, "Not enough elements in the hashtable")
        }
 
        // find the element we shall point to from the end of the hashtable
        for (i = 0, ind_elt = _table_->_nb_elements_ - ind_elt - 1;; ++i) {
          if (_table_->_nodes_[i]._nb_elements_) {
            if (ind_elt >= _table_->_nodes_[i]._nb_elements_)
              ind_elt -= _table_->_nodes_[i]._nb_elements_;
            else {
              for (_bucket_ = _table_->_nodes_[i]._deb_list_; ind_elt;
                   --ind_elt, _bucket_ = _bucket_->next) {}
 
              _index_ = i;
              break;
            }
          }
        }
      }
    }
 
    // for debugging purposes
    GUM_CONSTRUCTOR(HashTableConstIteratorSafe);
 
    // make the hashtable keep track of this iterator
    _insertIntoSafeList_();
  }

References _table_, and HashTable< Key, Val >.

Here is the call graph for this function:

HashTableConstIteratorSafe() [4/6]

template<typename Key, typename Val>

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

(

const HashTableConstIteratorSafe< Key, Val > &

from

)

Copy constructor.

Parameters

from	The gum::HashTableConstIteratorSafe to copy.

Definition at line 1130 of file hashTable_tpl.h.

                                                          :
      _table_{from._table_}, _index_{from._index_}, _bucket_{from._bucket_},
      _next_bucket_{from._next_bucket_} {
    // make the hashtable keep track of this iterator
    if (_table_ != nullptr) { _insertIntoSafeList_(); }
 
    // for debugging purposes
    GUM_CONS_CPY(HashTableConstIteratorSafe);
  }

References HashTableConstIteratorSafe(), _bucket_, _index_, _insertIntoSafeList_(), _next_bucket_, and _table_.

Here is the call graph for this function:

HashTableConstIteratorSafe() [5/6]

template<typename Key, typename Val>

INLINE gum::HashTableConstIteratorSafe< Key, Val >::HashTableConstIteratorSafe ( const HashTableConstIterator< Key, Val > & from )

explicit

Copy constructor.

Parameters

from	The gum::HashTableConstIterator to copy.

Definition at line 1142 of file hashTable_tpl.h.

                                                      :
      _table_{from._table_}, _index_{from._index_}, _bucket_{from._bucket_} {
    // make the hashtable keep track of this iterator
    if (_table_ != nullptr) { _insertIntoSafeList_(); }
 
    // for debugging purposes
    GUM_CONS_CPY(HashTableConstIteratorSafe);
  }

References HashTableConstIteratorSafe(), _bucket_, _index_, _insertIntoSafeList_(), and _table_.

Here is the call graph for this function:

HashTableConstIteratorSafe() [6/6]

template<typename Key, typename Val>

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

(

HashTableConstIteratorSafe< Key, Val > &&

from

)

Move constructor.

Parameters

from	The gum::HashTableConstIteratorSafe to move.

Definition at line 1153 of file hashTable_tpl.h.

                                                     :
      _table_{from._table_}, _index_{from._index_}, _bucket_{from._bucket_},
      _next_bucket_{from._next_bucket_} {
    GUM_CONS_MOV(HashTableConstIteratorSafe);
 
    // find "from" in the hashtable's list of safe iterators and substitute
    // it by this
    if (_table_ != nullptr) {
      std::vector< HashTableConstIteratorSafe< Key, Val >* >& vect = _table_->_safe_iterators_;
 
      for (auto ptr = vect.rbegin(); ptr != vect.rend(); ++ptr) {
        if (*ptr == &from) {
          *ptr         = this;
          from._table_ = nullptr;
          break;
        }
      }
    }
  }

References HashTableConstIteratorSafe(), _bucket_, _index_, _next_bucket_, and _table_.

Here is the call graph for this function:

~HashTableConstIteratorSafe()

template<typename Key, typename Val>

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

noexcept

Destructor.

Definition at line 1175 of file hashTable_tpl.h.

                                                                                      {
    // for debugging purposes
    GUM_DESTRUCTOR(HashTableConstIteratorSafe);
 
    // remove the iterator from the table's iterator list
    _removeFromSafeList_();
  }

References HashTableConstIteratorSafe(), and _removeFromSafeList_().

Here is the call graph for this function:

Member Function Documentation

_getBucket_()

template<typename Key, typename Val>

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

protectednoexcept

Returns the current iterator's bucket.

Definition at line 1433 of file hashTable_tpl.h.

                                                                            {
    return _bucket_;
  }

References _bucket_.

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

Here is the caller graph for this function:

_getIndex_()

template<typename Key, typename Val>

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

protectednoexcept

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 1438 of file hashTable_tpl.h.

                                                                                {
    return _index_;
  }

References _index_.

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

Here is the caller graph for this function:

_insertIntoSafeList_()

template<typename Key, typename Val>

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

protected

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

Definition at line 1013 of file hashTable_tpl.h.

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

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), and operator=().

Here is the caller graph for this function:

_removeFromSafeList_()

template<typename Key, typename Val>

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

protected

Removes the iterator from its hashtable' safe iterators list.

Definition at line 1019 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;
      }
    }
  }

References _table_.

Referenced by ~HashTableConstIteratorSafe(), operator=(), and operator=().

Here is the caller graph for this function:

clear()

template<typename Key, typename Val>

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

noexcept

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 1290 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

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 1277 of file hashTable_tpl.h.

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

References _bucket_.

operator!=()

template<typename Key, typename Val>

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

noexcept

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 1413 of file hashTable_tpl.h.

                                                                         {
    return ((_bucket_ != from._bucket_) || (_index_ != from._index_));
  }

References HashTableConstIteratorSafe(), _bucket_, HashTableConstIterator< Key, Val >::_bucket_, _index_, and HashTableConstIterator< Key, Val >::_index_.

Here is the call graph for this function:

operator*()

template<typename Key, typename Val>

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

(

)

const

Returns the element pointed to by the iterator.

Returns

Returns the element pointed to by the iterator.

Exceptions

UndefinedIteratorValue

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

Definition at line 1426 of file hashTable_tpl.h.

                                                              {
    if (_bucket_) return _bucket_->elt();
    else { GUM_ERROR(UndefinedIteratorValue, "Accessing a nullptr object") }
  }

References _bucket_, and GUM_ERROR.

operator+()

template<typename Key, typename Val>

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

(

Size

i

)

const

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

Parameters

i	The number of steps to increment the gum::HashTableConstIteratorSafe.

Returns

Returns a new gum::HashTableConstIteratorSafe.

Definition at line 1408 of file hashTable_tpl.h.

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

References HashTableConstIteratorSafe().

Here is the call graph for this function:

operator++()

template<typename Key, typename Val>

HashTableConstIteratorSafe< Key, Val > & gum::HashTableConstIteratorSafe< 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

Returns this gum::HashTableConstIteratorSafe pointing to the next element in the gum::HashTable it's iterating over.

Definition at line 1305 of file hashTable_tpl.h.

                                                                  {
    // if  _bucket_ != nullptr then use it, else use next_bucket
    if (_bucket_ == nullptr) {
      // note that this case only happens when the iterator pointed to an
      // element
      // that has just been erased. Fortunately, in this case, the Hashtable's
      // erase functions update appropriately the  _next_bucket_ and  _index_
      // fields.
      _bucket_      = _next_bucket_;
      _next_bucket_ = nullptr;
    } else {
      // ok, here we can use  _bucket_ as a starting point
 
      // if we are not pointing on the first element of the chained list, just
      // point to the preceding bucket in this list
      if (_bucket_->prev) {
        _bucket_ = _bucket_->prev;
        // here, no need to update  _next_bucket_, which is compulsorily
        // equal to nullptr, nor  _index_ which has not changed.
      } else {
        // ok, here we are on the beginning of a chained list,
        // so 2 cases can obtain:
        // 1/ index = 0 : then we have reached the end of the hashtable
        // 2/ index != 0 => we must search for a new slot containing elements
 
        // case 1:
        if (_index_ == Size(0)) {
          _bucket_ = nullptr;
          // we are thus at the end() of the hashTable
        }
        // case 2:
        else {
          // arrived here, we need to parse the hash table until we find a new
          // bucket because we are pointing on a chained list with no more
          // element
          // to the left of the current element
          if (_index_ > Size(0)) {
            for (Size i = _index_ - Size(1); i > Size(0); --i) {
              if (_table_->_nodes_[i]._nb_elements_) {
                _index_  = i;
                _bucket_ = _table_->_nodes_[i]._end_list_;
                return *this;
              }
            }
          }
 
          if (_table_->_nodes_[0]._nb_elements_) _bucket_ = _table_->_nodes_[0]._end_list_;
          else _bucket_ = nullptr;
 
          _index_ = 0;
        }
      }
    }
 
    return *this;
  }

operator+=()

template<typename Key, typename Val>

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

noexcept

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

Parameters

i	The number of steps to increment the gum::HashTableConstIteratorSafe.

Returns

Returns this gum::HashTableConstIteratorSafe.

Definition at line 1364 of file hashTable_tpl.h.

                                                                       {
    if ((nb == Size(0)) || (_table_ == nullptr)) return *this;
 
    // if  _bucket_ != nullptr then use it, else use next_bucket
    if (_bucket_ == nullptr) {
      // note that this case only happens when the iterator pointed to an
      // element
      // that has just been erased. Fortunately, in this case, the Hashtable's
      // erase functions update appropriately the  _next_bucket_ and  _index_
      // fields.
      _bucket_      = _next_bucket_;
      _next_bucket_ = nullptr;
      --nb;
    }
 
    // ok, here we can use  _bucket_ as a starting point: parse all the elements
    // of the current chained list
    for (; nb && _bucket_ != nullptr; --nb, _bucket_ = _bucket_->prev) {}
 
    if (_bucket_ != nullptr) return *this;
 
    // here, we shall skip all the chained list that have not sufficiently
    // many elements
    --_index_;
 
    for (; _index_ < _table_->_size_ && nb >= _table_->_nodes_[_index_]._nb_elements_;
         nb -= _table_->_nodes_[_index_]._nb_elements_, --_index_) {}
 
    // here: either  _index_ >=  _table_-> _size_, which means that we did not find
    // the element we looked for, i.e., we are at the end of the hashtable, or
    // nb <  _table_-> _nodes_[ _index_]. _nb_elements_, and we should parse the
    // chained list to get the element (which, we know for sure, exists)
    if (_index_ >= _table_->_size_) {
      _index_ = Size(0);
      return *this;
    }
 
    for (_bucket_ = _table_->_nodes_[_index_]._end_list_; nb; --nb, _bucket_ = _bucket_->prev) {}
 
    return *this;
  }

References _bucket_, _index_, _next_bucket_, and _table_.

Referenced by gum::HashTable< const gum::DiscreteVariable *, Idx >::_create_().

Here is the caller graph for this function:

operator=() [1/3]

template<typename Key, typename Val>

HashTableConstIteratorSafe< Key, Val > & gum::HashTableConstIteratorSafe< Key, Val >::operator=

(

const HashTableConstIterator< Key, Val > &

from

)

Copy operator.

Parameters

from	The gum::HashTableConstIterator to copy.

Returns

Returns this gum::HashTableConstIteratorSafe.

Definition at line 1211 of file hashTable_tpl.h.

                                                      {
    // here, no need to avoid self assignment: this would slow down normal
    // assignments and, in any case, this would not result in an iterator in
    // an incoherent state
    // check if the current hashtable is different from that of "from". In such
    // a case, we shall remove the iterator from its current hashtable
    // iterator's
    // list and add it to the new hashtable iterator's list
    if (_table_ != from._table_) {
      // remove the iterator from its hashtable iterator's list'
      _removeFromSafeList_();
 
      _table_ = from._table_;
 
      // add to the new table
      if (_table_) { _insertIntoSafeList_(); }
    }
 
    _index_       = from._index_;
    _bucket_      = from._bucket_;
    _next_bucket_ = nullptr;
 
    return *this;
  }

References HashTableConstIteratorSafe(), _table_, and HashTableConstIterator< Key, Val >::_table_.

Here is the call graph for this function:

operator=() [2/3]

template<typename Key, typename Val>

HashTableConstIteratorSafe< Key, Val > & gum::HashTableConstIteratorSafe< Key, Val >::operator=

(

const HashTableConstIteratorSafe< Key, Val > &

from

)

Copy operator.

Parameters

from	The gum::HashTableConstIteratorSafe to copy.

Returns

Returns this gum::HashTableConstIteratorSafe.

Definition at line 1184 of file hashTable_tpl.h.

                                                          {
    // here, no need to avoid self assignment: this would slow down normal
    // assignments and, in any case, this would not result in an iterator in
    // an incoherent state
    // check if the current hashtable is different from that of "from". In such
    // a case, we shall remove the iterator from its current hashtable
    // iterator's
    // list and add it to the new hashtable iterator's list
    if (_table_ != from._table_) {
      // remove the iterator from its hashtable iterator's list'
      _removeFromSafeList_();
 
      _table_ = from._table_;
 
      // add to the new table
      if (_table_) { _insertIntoSafeList_(); }
    }
 
    _index_       = from._index_;
    _bucket_      = from._bucket_;
    _next_bucket_ = from._next_bucket_;
 
    return *this;
  }

References HashTableConstIteratorSafe(), _bucket_, _index_, _insertIntoSafeList_(), _next_bucket_, _removeFromSafeList_(), and _table_.

Referenced by gum::HashTable< const gum::DiscreteVariable *, Idx >::_erase_().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [3/3]

template<typename Key, typename Val>

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

noexcept

Move operator.

Parameters

from	The gum::HashTableConstIteratorSafe to move.

Returns

Returns this gum::HashTableConstIteratorSafe.

Definition at line 1238 of file hashTable_tpl.h.

                                                              {
    // here, no need to avoid self assignment: this would slow down normal
    // assignments and, in any case, this would not result in an iterator in
    // an incoherent state
    // check if the current hashtable is different from that of "from". In such
    // a case, we shall remove the iterator from its current hashtable
    // iterator's
    // list and add it to the new hashtable iterator's list
    if (_table_ != from._table_) {
      // remove the iterator from its hashtable iterator's list'
      _removeFromSafeList_();
 
      if (from._table_ != nullptr) {
        // substitute from by this in the list of safe iterators
        std::vector< HashTableConstIteratorSafe< Key, Val >* >& vect
            = from._table_->_safe_iterators_;
 
        for (auto ptr = vect.rbegin(); ptr != vect.rend(); ++ptr) {
          if (*ptr == &from) {
            *ptr = this;
            break;
          }
        }
      }
 
      _table_      = from._table_;
      from._table_ = nullptr;
    }
 
    _index_       = from._index_;
    _bucket_      = from._bucket_;
    _next_bucket_ = from._next_bucket_;
 
    return *this;
  }

References HashTableConstIteratorSafe(), _bucket_, HashTableConstIterator< Key, Val >::_bucket_, _index_, HashTableConstIterator< Key, Val >::_index_, _next_bucket_, _removeFromSafeList_(), _table_, and HashTableConstIterator< Key, Val >::_table_.

Here is the call graph for this function:

operator==()

template<typename Key, typename Val>

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

noexcept

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 1419 of file hashTable_tpl.h.

                                                                         {
    return ((_bucket_ == from._bucket_) && (_index_ == from._index_));
  }

References HashTableConstIteratorSafe(), _bucket_, HashTableConstIterator< Key, Val >::_bucket_, _index_, and HashTableConstIterator< Key, Val >::_index_.

Here is the call graph for this function:

val()

template<typename Key, typename Val>

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

(

)

const

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 1284 of file hashTable_tpl.h.

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

References _bucket_, and GUM_ERROR.

Friends And Related Symbol Documentation

HashTable< Key, Val >

template<typename Key, typename Val>

friend class HashTable< Key, Val >

friend

Class HashTable must be a friend because it stores iterator end and this can be properly initialized only when the hashtable has been fully allocated.

Thus, proper initialization can only take place within the constructor's code of the hashtable.

Definition at line 1793 of file hashTable.h.

Referenced by HashTableConstIteratorSafe(), and HashTableConstIteratorSafe().

Member Data Documentation

_bucket_

template<typename Key, typename Val>

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

protected

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

Definition at line 1816 of file hashTable.h.

{nullptr};

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), _getBucket_(), key(), operator!=(), operator*(), operator+=(), operator=(), operator=(), operator==(), and val().

_index_

template<typename Key, typename Val>

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

protected

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

Definition at line 1813 of file hashTable.h.

{Size(0)};

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), _getIndex_(), operator!=(), operator+=(), operator=(), operator=(), and operator==().

_next_bucket_

template<typename Key, typename Val>

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

protected

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 1826 of file hashTable.h.

{nullptr};

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), operator+=(), operator=(), and operator=().

_table_

template<typename Key, typename Val>

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

protected

The hash table the iterator is pointing to.

Definition at line 1807 of file hashTable.h.

{nullptr};

Referenced by HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), HashTableConstIteratorSafe(), _removeFromSafeList_(), operator+=(), operator=(), operator=(), and operator=().

---

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

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