gum::ListIteratorSafe< Val > Class Template Reference

Safe iterators for Lists. More...

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

Inheritance diagram for gum::ListIteratorSafe< Val >:

Collaboration diagram for gum::ListIteratorSafe< Val >:

Public Types
using	iterator_category = std::bidirectional_iterator_tag
	Types for STL compliance.
using	value_type = Val
	Types for STL compliance.
using	reference = Val&
	Types for STL compliance.
using	const_reference = const Val&
	Types for STL compliance.
using	pointer = Val*
	Types for STL compliance.
using	const_pointer = const Val*
	Types for STL compliance.
using	difference_type = std::ptrdiff_t
	Types for STL compliance.

Public Member Functions
Constructors / Destructors
	ListIteratorSafe () noexcept
	Default constructor.
	ListIteratorSafe (const List< Val > &theList)
	Constructor for a begin.
	ListIteratorSafe (const ListIteratorSafe< Val > &src)
	Copy constructor.
	ListIteratorSafe (const List< Val > &theList, Size ind_elt)
	Constructor for an iterator pointing to the ind_eltth element of a List.
	ListIteratorSafe (ListIteratorSafe< Val > &&src)
	Move constructor.
	~ListIteratorSafe ()
	Class Desctructor.
Operators
ListIteratorSafe< Val > &	operator= (const ListIteratorSafe< Val > &src)
	Copy operator.
ListIteratorSafe< Val > &	operator= (ListIteratorSafe< Val > &&src)
	Move operator.
ListIteratorSafe< Val > &	operator++ () noexcept
	Makes the iterator point to the next element in the List.
ListIteratorSafe< Val > &	operator+= (difference_type i) noexcept
	Makes the iterator point to i elements further in the List.
ListIteratorSafe< Val > &	operator-- () noexcept
	Makes the iterator point to the preceding element in the List.
ListIteratorSafe< Val > &	operator-= (difference_type i) noexcept
	Makes the iterator point to i elements befor in the List.
ListIteratorSafe< Val >	operator+ (difference_type i) noexcept
	Returns a new iterator pointing to i further elements in the gum::List.
ListIteratorSafe< Val >	operator- (difference_type i) noexcept
	Returns a new iterator pointing to i preceding elements in the gum::List.
Val &	operator* ()
	Gives access to the content of the iterator.
Val *	operator-> ()
	Dereferences the value pointed to by the iterator.
bool	operator!= (const ListIteratorSafe< Val > &src) const
	Checks whether two iterators point toward different elements.
bool	operator== (const ListIteratorSafe< Val > &src) const
	Checks whether two iterators point toward the same elements.
const Val &	operator* () const
	Gives access to the content of the iterator.
const Val *	operator-> () const
	Dereferences the value pointed to by the iterator.
Accessors / Modifiers
void	clear ()
	Makes the iterator point toward nothing.
void	setToEnd ()
	Positions the iterator to the end of the list.
bool	isEnd () const
	Returns a bool indicating whether the iterator points to the end of the list.
Operators
bool	operator!= (const ListConstIteratorSafe< Val > &src) const
	Checks whether two iterators point toward different elements.
bool	operator== (const ListConstIteratorSafe< Val > &src) const
	Checks whether two iterators point toward the same elements.

Private Member Functions
ListBucket< Val > *	_getBucket_ () const noexcept
	Returns the bucket the iterator is pointing to.
void	_removeFromSafeList_ () const
	Remove the iterator for its list' safe iterators list.
ListConstIteratorSafe< Val > &	_opPlus_ (Size i) noexcept
	Makes the iterator point to the next element in the List.
ListConstIteratorSafe< Val > &	_opMinus_ (Size i) noexcept
	Makes the iterator point to i elements before in the List.

Private Attributes
const List< Val > *	_list_ {nullptr}
	The list the iterator is pointing to.
ListBucket< Val > *	_bucket_ {nullptr}
	The bucket in the chained list pointed to by the iterator.
ListBucket< Val > *	_next_current_bucket_ {nullptr}
	The bucket we should start from when we are pointing on a deleted bucket and we decide to do a ++.
ListBucket< Val > *	_prev_current_bucket_ {nullptr}
	The bucket we should start from when we are pointing on a deleted bucket and we decide to do a –.
bool	_null_pointing_ {false}
	Indicates whether the bucket the iterator points to has been deleted.

Detailed Description

template<typename Val>
class gum::ListIteratorSafe< Val >

Safe iterators for Lists.

Class ListIteratorSafe implements iterators for List. However, developers may consider using List<x>::iterator_safe instead of ListIteratorSafe<x>.

These iterators ensure that whenever they point to an element that is being deleted from memory, their accessing this element will never produce a segmentation fault but rather throw an exception. Similarly, incrementing or decrementing an iterator pointing to a deleted element is guaranteed to make the iterator point on the next (or preceding) element that has not been deleted. This enables safely writing code like:

for ( iter = mylist.beginSafe (); iter != mylist.endSafe (); ++iter )
  list.erase ( iter );

Usage example:

// create a list of strings
List<string> list;
list.pushBack ("toto"); list.pushBack ("titi");
 
// parse all the elements of a list
for (List<string>::iterator_safe iter = list.beginSafe();
     iter != list.endSafe(); ++iter)
  cerr << *iter << endl;
for ( List<string>::iterator_safe iter = list.beginSafe ();
      iter != list.endSafe (); iter += 2 ) // step = 2
  cerr << *iter << endl;
for ( List<string>::iterator_safe iter = list.beginSafe ();
      iter != list.endSafe (); iter = iter + 2 ) // step = 2
  cerr << *iter << endl;
for (List<string>::iterator_safe iter = list.rbeginSafe();
     iter != list.rendSafe(); --iter)
  cerr << *iter << endl;
 
// use member size() of the strings
for (List<string>::iterator_safe iter = list.beginSafe();
     iter != list.endSafe(); ++iter)
  cerr << iter->size() << endl;

Template Parameters

Val	The gum::List values type.

Definition at line 2318 of file list.h.

Member Typedef Documentation

const_pointer

template<typename Val>

using gum::ListIteratorSafe< Val >::const_pointer = const Val*

Types for STL compliance.

Definition at line 2327 of file list.h.

const_reference

template<typename Val>

using gum::ListIteratorSafe< Val >::const_reference = const Val&

Types for STL compliance.

Definition at line 2325 of file list.h.

difference_type

template<typename Val>

using gum::ListIteratorSafe< Val >::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 2328 of file list.h.

iterator_category

template<typename Val>

using gum::ListIteratorSafe< Val >::iterator_category = std::bidirectional_iterator_tag

Types for STL compliance.

Definition at line 2322 of file list.h.

pointer

template<typename Val>

using gum::ListIteratorSafe< Val >::pointer = Val*

Types for STL compliance.

Definition at line 2326 of file list.h.

reference

template<typename Val>

using gum::ListIteratorSafe< Val >::reference = Val&

Types for STL compliance.

Definition at line 2324 of file list.h.

value_type

template<typename Val>

using gum::ListIteratorSafe< Val >::value_type = Val

Types for STL compliance.

Definition at line 2323 of file list.h.

Constructor & Destructor Documentation

ListIteratorSafe() [1/5]

template<typename Val>

gum::ListIteratorSafe< Val >::ListIteratorSafe ( )

explicitnoexcept

Default constructor.

Returns an iterator pointing toward nothing.

Definition at line 962 of file list_tpl.h.

                                                     : ListConstIteratorSafe< Val >() {
    GUM_CONSTRUCTOR(ListIteratorSafe);
  }

References gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe(), and ListIteratorSafe().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ListIteratorSafe() [2/5]

template<typename Val>

gum::ListIteratorSafe< Val >::ListIteratorSafe

(

const List< Val > &

theList

)

Constructor for a begin.

Definition at line 969 of file list_tpl.h.

                                                                      :
      ListConstIteratorSafe< Val >(theList) {
    GUM_CONSTRUCTOR(ListIteratorSafe);
  }

References gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe(), ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::List< Val >.

Here is the call graph for this function:

ListIteratorSafe() [3/5]

template<typename Val>

gum::ListIteratorSafe< Val >::ListIteratorSafe

(

const ListIteratorSafe< Val > &

src

)

Copy constructor.

Parameters

src	The gum::ListConstIteratorSafe to copy.

Definition at line 976 of file list_tpl.h.

                                                                              :
      ListConstIteratorSafe< Val >(src) {
    GUM_CONS_CPY(ListIteratorSafe);
  }

References ListIteratorSafe().

Here is the call graph for this function:

ListIteratorSafe() [4/5]

template<typename Val>

gum::ListIteratorSafe< Val >::ListIteratorSafe	(	const List< Val > &	theList,
		Size	ind_elt )

Constructor for an iterator pointing to the ind_eltth element of a List.

Parameters

theList	The list to iterate over.
ind_elt	The iterator starting position.

Exceptions

UndefinedIteratorValue

Raised if the element does not exist in the list.

Definition at line 984 of file list_tpl.h.

                                                                                    :
      ListConstIteratorSafe< Val >(theList, ind_elt) {
    GUM_CONSTRUCTOR(ListIteratorSafe);
  }

References gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe(), ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::List< Val >.

Here is the call graph for this function:

ListIteratorSafe() [5/5]

template<typename Val>

gum::ListIteratorSafe< Val >::ListIteratorSafe

(

ListIteratorSafe< Val > &&

src

)

Move constructor.

Parameters

src	The gum::ListConstIterator to move.

Definition at line 991 of file list_tpl.h.

                                                                         :
      ListConstIteratorSafe< Val >(std::move(src)) {
    GUM_CONS_MOV(ListIteratorSafe);
  }

References gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe(), and ListIteratorSafe().

Here is the call graph for this function:

~ListIteratorSafe()

template<typename Val>

gum::ListIteratorSafe< Val >::~ListIteratorSafe

(

)

Class Desctructor.

Definition at line 1016 of file list_tpl.h.

                                             {
    GUM_DESTRUCTOR(ListIteratorSafe);
  }

References ListIteratorSafe().

Here is the call graph for this function:

Member Function Documentation

_getBucket_()

template<typename Val>

ListBucket< Val > * gum::ListConstIteratorSafe< Val >::_getBucket_ ( ) const

privatenoexceptinherited

Returns the bucket the iterator is pointing to.

Definition at line 700 of file list_tpl.h.

                                                                              {
    return _bucket_;
  }

Referenced by gum::List< Val >::_insert_(), gum::List< Val >::erase(), and gum::List< Val >::erase().

Here is the caller graph for this function:

_opMinus_()

template<typename Val>

ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< Val >::_opMinus_ ( Size i )

privatenoexceptinherited

Makes the iterator point to i elements before in the List.

Definition at line 769 of file list_tpl.h.

                                                                                       {
    // check if we are pointing to something that has been deleted
    if (_null_pointing_) {
      _null_pointing_ = false;
 
      // if we are pointing to an element of the chained list that has been
      // deleted
      // but that has a preceding element, just point on the latter
      if (_prev_current_bucket_ != nullptr) {
        _bucket_ = _prev_current_bucket_->_prev_;
      } else {
        // here we were pointing on an extremity of the list (either end or
        // rend)
        // if next_current_bucket is not null, then we are at end and doing
        // a -- shall now point to the beginning of the list
        if (_next_current_bucket_ != nullptr) {
          _bucket_ = _next_current_bucket_;
        } else {
          // here, we are at the rend of the chained list, hence we shall remain
          // at rend
          _bucket_ = nullptr;
          return *this;
        }
      }
    } else {
      // if we are pointing to an element of the chained list, just
      // point on the preceding bucket in this list
      if (_bucket_ != nullptr) { _bucket_ = _bucket_->_prev_; }
    }
 
    for (--i; i && (_bucket_ != nullptr); --i, _bucket_ = _bucket_->_prev_) {}
 
    return *this;
  }

References ListConstIteratorSafe(), and _null_pointing_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

_opPlus_()

template<typename Val>

ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< Val >::_opPlus_ ( Size i )

privatenoexceptinherited

Makes the iterator point to the next element in the List.

Definition at line 806 of file list_tpl.h.

                                                                                      {
    // check if we are pointing to something that has been deleted
    if (_null_pointing_) {
      _null_pointing_ = false;
 
      // if we are pointing to an element of the chained list that has been
      // deleted
      // but that has a next element, just point on the latter
      if (_next_current_bucket_ != nullptr) {
        _bucket_ = _next_current_bucket_->_next_;
      } else {
        // here we were pointing on an extremity of the list (either end or
        // rend)
        // if prev_current_bucket is not null, then we are at rend and doing
        // a ++ shall now point to the beginning of the list
        if (_prev_current_bucket_ != nullptr) {
          _bucket_ = _prev_current_bucket_;
        } else {
          // here, we are at the end of the chained list, hence we shall
          // remain at end
          _bucket_ = nullptr;
          return *this;
        }
      }
    } else {
      // if we are pointing to an element of the chained list, just
      // point on the next bucket in this list
      if (_bucket_ != nullptr) { _bucket_ = _bucket_->_next_; }
    }
 
    for (--i; i && (_bucket_ != nullptr); --i, _bucket_ = _bucket_->_next_) {}
 
    return *this;
  }

References ListConstIteratorSafe(), _bucket_, _next_current_bucket_, _null_pointing_, and _prev_current_bucket_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

_removeFromSafeList_()

template<typename Val>

void gum::ListConstIteratorSafe< Val >::_removeFromSafeList_ ( ) const

privateinherited

Remove the iterator for its list' safe iterators list.

Definition at line 591 of file list_tpl.h.

                                                                {
    // find where the iterator is
    std::vector< ListConstIteratorSafe< Val >* >& vect = _list_->_safe_iterators_;
 
    for (auto i = vect.size() - 1; i >= 0; --i) {
      if (vect[i] == this) {
        vect.erase(vect.begin() + i);
        break;
      }
    }
  }

References _list_.

Referenced by ~ListConstIteratorSafe(), and clear().

Here is the caller graph for this function:

clear()

template<typename Val>

void gum::ListConstIteratorSafe< Val >::clear ( )

inherited

Makes the iterator point toward nothing.

A method for detaching the iterator from the List it is attached to. It is mainly used by the List when the latter is deleted while the iterator is still alive. After being detached, the iterator does not point to any element, i.e., trying to access its content will raise an exception.

Definition at line 706 of file list_tpl.h.

                                           {
    // remove the iterator src the list's iterator list
    if (_list_) _removeFromSafeList_();
 
    // set its list as well as the element it points to to nullptr
    _list_          = nullptr;
    _bucket_        = nullptr;
    _null_pointing_ = false;
  }

References _bucket_, _list_, _null_pointing_, and _removeFromSafeList_().

Referenced by setToEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

isEnd()

template<typename Val>

bool gum::ListConstIteratorSafe< Val >::isEnd ( ) const

inherited

Returns a bool indicating whether the iterator points to the end of the list.

Returns

Returns a bool indicating whether the iterator points to the end of the list.

Definition at line 725 of file list_tpl.h.

                                                 {
    return _null_pointing_
             ? (_next_current_bucket_ == nullptr) && (_prev_current_bucket_ == nullptr)
             : (_bucket_ == nullptr);
  }

References _bucket_, _next_current_bucket_, _null_pointing_, and _prev_current_bucket_.

operator!=() [1/2]

template<typename Val>

bool gum::ListConstIteratorSafe< Val >::operator!= ( const ListConstIteratorSafe< Val > & src ) const

inherited

Checks whether two iterators point toward different elements.

Warning

the end and rend iterators are always equal, whatever the list they belong to, i.e., list1.end() == list2.rend().

Parameters

src	The gum::ListConstIteratorSafe to test for inequality.

Returns

Returns true if src and this are equal.

Definition at line 913 of file list_tpl.h.

                                                                                           {
    return _null_pointing_ ? (_next_current_bucket_ != src._next_current_bucket_)
                                 || (_prev_current_bucket_ != src._prev_current_bucket_)
                           : (_bucket_ != src._bucket_);
  }

References ListConstIteratorSafe(), _bucket_, _next_current_bucket_, _null_pointing_, and _prev_current_bucket_.

Here is the call graph for this function:

operator!=() [2/2]

template<typename Val>

bool gum::ListIteratorSafe< Val >::operator!=

(

const ListIteratorSafe< Val > &

src

)

const

Checks whether two iterators point toward different elements.

Warning

the end and rend iterators are always equal, whatever the list they belong to, i.e., list1.end() == list2.rend().

Parameters

src	The gum::ListIteratorSafe to test for inequality.

Returns

Returns true if src and this are equal.

Definition at line 1028 of file list_tpl.h.

                                                                                 {
    return !operator==(src);
  }

References ListIteratorSafe(), and gum::operator==().

Here is the call graph for this function:

operator*() [1/2]

template<typename Val>

Val & gum::ListIteratorSafe< Val >::operator*

(

)

Gives access to the content of the iterator.

Exceptions

UndefinedIteratorValue

Raised if the iterator points to nothing.

Returns

Returns the content of the iterator.

Definition at line 1090 of file list_tpl.h.

                                          {
    return const_cast< Val& >(ListConstIteratorSafe< Val >::operator*());
  }

References gum::ListConstIteratorSafe< Val >::operator*().

Here is the call graph for this function:

operator*() [2/2]

template<typename Val>

const Val & gum::ListIteratorSafe< Val >::operator*

(

)

const

Gives access to the content of the iterator.

Exceptions

UndefinedIteratorValue

Raised if the iterator points to nothing.

Returns

Returns the content of the iterator.

Definition at line 1096 of file list_tpl.h.

                                                      {
    return ListConstIteratorSafe< Val >::operator*();
  }

References gum::ListConstIteratorSafe< Val >::operator*().

Here is the call graph for this function:

operator+()

template<typename Val>

ListIteratorSafe< Val > gum::ListIteratorSafe< Val >::operator+ ( difference_type i )

noexcept

Returns a new iterator pointing to i further elements in the gum::List.

Parameters

i	The number of steps to move the iterator.

Returns

Returns a new gum::ListConstIteratoSafe.

Definition at line 1064 of file list_tpl.h.

                                                                  {
    return ListIteratorSafe< Val >(*this) += i;
  }

References ListIteratorSafe().

Here is the call graph for this function:

operator++()

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator++ ( )

noexcept

Makes the iterator point to the next element in the List.

for (iter = list.begin(); iter != list.end(); ++iter) { }

The above loop is guaranteed to parse the whole List as long as no element is added to or deleted from the List while being in the loop. Runs in constant time.

Returns

Returns this gum::ListIteratorSafe.

Definition at line 1034 of file list_tpl.h.

                                                                        {
    ListConstIteratorSafe< Val >::operator++();
    return *this;
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator++().

Here is the call graph for this function:

operator+=()

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator+= ( difference_type i )

noexcept

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

Parameters

i	The number of steps to move the iterator.

Returns

Returns this gum::ListIterator.

Definition at line 1041 of file list_tpl.h.

                                                                  {
    ListConstIteratorSafe< Val >::operator+=(i);
    return *this;
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator+=().

Here is the call graph for this function:

operator-()

template<typename Val>

ListIteratorSafe< Val > gum::ListIteratorSafe< Val >::operator- ( difference_type i )

noexcept

Returns a new iterator pointing to i preceding elements in the gum::List.

Parameters

i	The number of steps to move the iterator.

Returns

Returns a new gum::ListIteratorSafe.

Definition at line 1071 of file list_tpl.h.

                                                                  {
    return ListIteratorSafe< Val >(*this) -= i;
  }

References ListIteratorSafe().

Here is the call graph for this function:

operator--()

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator-- ( )

noexcept

Makes the iterator point to the preceding element in the List.

for (iter = list.rbegin(); iter != list.rend(); --iter) { }

The above loop is guaranteed to parse the whole List as long as no element is added to or deleted from the List while being in the loop. Runs in constant time.

Returns

Returns this gum::ListIteratorSafe.

Definition at line 1049 of file list_tpl.h.

                                                                        {
    ListConstIteratorSafe< Val >::operator--();
    return *this;
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator--().

Here is the call graph for this function:

operator-=()

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator-= ( difference_type i )

noexcept

Makes the iterator point to i elements befor in the List.

Parameters

i	The number of steps to move the iterator.

Returns

Returns this gum::ListIteratorSafe.

Definition at line 1056 of file list_tpl.h.

                                                                  {
    ListConstIteratorSafe< Val >::operator-=(i);
    return *this;
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator-=().

Here is the call graph for this function:

operator->() [1/2]

template<typename Val>

Val * gum::ListIteratorSafe< Val >::operator->

(

)

Dereferences the value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised if the iterator points to nothing.

Returns

Returns the value pointed to by the iterator.

Definition at line 1078 of file list_tpl.h.

                                           {
    return const_cast< Val* >(ListConstIteratorSafe< Val >::operator->());
  }

References gum::ListConstIteratorSafe< Val >::operator->().

Here is the call graph for this function:

operator->() [2/2]

template<typename Val>

const Val * gum::ListIteratorSafe< Val >::operator->

(

)

const

Dereferences the value pointed to by the iterator.

Exceptions

UndefinedIteratorValue

Raised if the iterator points to nothing.

Returns

Returns the value pointed to by the iterator.

Definition at line 1084 of file list_tpl.h.

                                                       {
    return ListConstIteratorSafe< Val >::operator->();
  }

References gum::ListConstIteratorSafe< Val >::operator->().

Here is the call graph for this function:

operator=() [1/2]

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator=

(

const ListIteratorSafe< Val > &

src

)

Copy operator.

The current iterator now points to the same element as iterator from.

Parameters

src	The gum::ListIteratorSafe to copy.

Returns

Returns this gum::ListIteratorSafe.

Definition at line 998 of file list_tpl.h.

                                                                                              {
    // for debugging purposes
    GUM_OP_CPY(ListIteratorSafe);
    ListConstIteratorSafe< Val >::operator=(src);
    return *this;
  }

References ListIteratorSafe().

Here is the call graph for this function:

operator=() [2/2]

template<typename Val>

ListIteratorSafe< Val > & gum::ListIteratorSafe< Val >::operator=

(

ListIteratorSafe< Val > &&

src

)

Move operator.

Parameters

src	The gum::ListIteratorSafe to move.

Returns

Returns this gum::ListIteratorSafe.

Definition at line 1007 of file list_tpl.h.

                                                                                         {
    // for debugging purposes
    GUM_OP_MOV(ListIteratorSafe);
    ListConstIteratorSafe< Val >::operator=(std::move(src));
    return *this;
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator=().

Here is the call graph for this function:

operator==() [1/2]

template<typename Val>

bool gum::ListConstIteratorSafe< Val >::operator== ( const ListConstIteratorSafe< Val > & src ) const

inherited

Checks whether two iterators point toward the same elements.

Warning

the end and rend iterators are always equal, whatever the list they belong to, i.e., list1.end() == list2.rend().

Parameters

src	The gum::ListConstIteratorSafe to test for equality.

Returns

Returns true if src and this are equal.

Definition at line 921 of file list_tpl.h.

                                                                                           {
    return _null_pointing_ ? (_next_current_bucket_ == src._next_current_bucket_)
                                 && (_prev_current_bucket_ == src._prev_current_bucket_)
                           : (_bucket_ == src._bucket_);
  }

References ListConstIteratorSafe(), _bucket_, _next_current_bucket_, _null_pointing_, and _prev_current_bucket_.

Referenced by gum::ListIteratorSafe< Val >::operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

operator==() [2/2]

template<typename Val>

bool gum::ListIteratorSafe< Val >::operator==

(

const ListIteratorSafe< Val > &

src

)

const

Checks whether two iterators point toward the same elements.

Warning

the end and rend iterators are always equal, whatever the list they belong to, i.e., list1.end() == list2.rend().

Parameters

src	The gum::ListIteratorSafe to test for equality.

Returns

Returns true if src and this are equal.

Definition at line 1022 of file list_tpl.h.

                                                                                 {
    return ListConstIteratorSafe< Val >::operator==(src);
  }

References ListIteratorSafe(), and gum::ListConstIteratorSafe< Val >::operator==().

Here is the call graph for this function:

setToEnd()

template<typename Val>

void gum::ListConstIteratorSafe< Val >::setToEnd ( )

inherited

Positions the iterator to the end of the list.

Definition at line 718 of file list_tpl.h.

                                              {
    clear();
  }

References clear().

Here is the call graph for this function:

Member Data Documentation

_bucket_

template<typename Val>

ListBucket< Val >* gum::ListConstIteratorSafe< Val >::_bucket_ {nullptr}

privateinherited

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

Definition at line 2232 of file list.h.

{nullptr};

Referenced by ListConstIteratorSafe(), ListConstIteratorSafe(), ListConstIteratorSafe(), _opPlus_(), clear(), isEnd(), operator!=(), operator*(), operator++(), operator--(), operator->(), and operator==().

_list_

template<typename Val>

const List< Val >* gum::ListConstIteratorSafe< Val >::_list_ {nullptr}

privateinherited

The list the iterator is pointing to.

Definition at line 2229 of file list.h.

{nullptr};

Referenced by ListConstIteratorSafe(), ListConstIteratorSafe(), ListConstIteratorSafe(), ListConstIteratorSafe(), ~ListConstIteratorSafe(), _removeFromSafeList_(), clear(), gum::List< gum::Instantiation * >::crend(), gum::List< Val >::insert(), gum::List< Val >::insert(), operator=(), and gum::List< gum::Instantiation * >::rend().

_next_current_bucket_

template<typename Val>

ListBucket< Val >* gum::ListConstIteratorSafe< Val >::_next_current_bucket_ {nullptr}

privateinherited

The bucket we should start from when we are pointing on a deleted bucket and we decide to do a ++.

Definition at line 2236 of file list.h.

{nullptr};

Referenced by ListConstIteratorSafe(), ListConstIteratorSafe(), gum::List< Val >::_insert_(), _opPlus_(), isEnd(), operator!=(), operator++(), operator--(), and operator==().

_null_pointing_

template<typename Val>

bool gum::ListConstIteratorSafe< Val >::_null_pointing_ {false}

privateinherited

Indicates whether the bucket the iterator points to has been deleted.

Definition at line 2243 of file list.h.

{false};

Referenced by ListConstIteratorSafe(), ListConstIteratorSafe(), gum::List< Val >::_insert_(), _opMinus_(), _opPlus_(), clear(), isEnd(), operator!=(), operator++(), operator--(), and operator==().

_prev_current_bucket_

template<typename Val>

ListBucket< Val >* gum::ListConstIteratorSafe< Val >::_prev_current_bucket_ {nullptr}

privateinherited

The bucket we should start from when we are pointing on a deleted bucket and we decide to do a –.

Definition at line 2240 of file list.h.

{nullptr};

Referenced by ListConstIteratorSafe(), ListConstIteratorSafe(), gum::List< Val >::_insert_(), _opPlus_(), isEnd(), operator!=(), operator++(), operator--(), and operator==().

---

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

• agrum/base/core/list.h
• agrum/base/core/list_tpl.h