Safe const iterators for Lists. More...

#include <agrum/core/list.h>

Inheritance diagram for gum::ListConstIteratorSafe< Val >:

Collaboration diagram for gum::ListConstIteratorSafe< Val >:

Public Member Functions
template<typename Alloc >
INLINE	ListConstIteratorSafe (const List< Val, Alloc > &theList)

Constructors / Destructors
	ListConstIteratorSafe () noexcept
	Default constructor. More...

template<typename Alloc >
	ListConstIteratorSafe (const List< Val, Alloc > &theList)
	Constructor for a begin. More...

	ListConstIteratorSafe (const ListConstIteratorSafe< Val > &src)
	Copy constructor. More...

template<typename Alloc >
	ListConstIteratorSafe (const List< Val, Alloc > &theList, Size ind_elt)
	Constructor for an iterator pointing to the ind_eltth element of a List. More...

	ListConstIteratorSafe (ListConstIteratorSafe< Val > &&src)
	Move constructor. More...

	~ListConstIteratorSafe ()
	Class Desctructor. More...

Accessors / Modifiers
void	clear ()
	Makes the iterator point toward nothing. More...

void	setToEnd ()
	Positions the iterator to the end of the list. More...

bool	isEnd () const
	Returns a bool indicating whether the iterator points to the end of the list. More...

Operators
ListConstIteratorSafe< Val > &	operator= (const ListConstIteratorSafe< Val > &src)
	Copy operator. More...

ListConstIteratorSafe< Val > &	operator= (ListConstIteratorSafe< Val > &&src)
	Move operator. More...

ListConstIteratorSafe< Val > &	operator++ () noexcept
	Makes the iterator point to the next element in the List. More...

ListConstIteratorSafe< Val > &	operator+= (difference_type i) noexcept
	Makes the iterator point to i elements further in the List. More...

ListConstIteratorSafe< Val > &	operator-- () noexcept
	Makes the iterator point to the preceding element in the List. More...

ListConstIteratorSafe< Val > &	operator-= (difference_type i) noexcept
	Makes the iterator point to i elements befor in the List. More...

ListConstIteratorSafe< Val >	operator+ (difference_type i) noexcept
	Returns a new iterator pointing to i further elements in the gum::List. More...

ListConstIteratorSafe< Val >	operator- (difference_type i) noexcept
	Returns a new iterator pointing to i preceding elements in the gum::List. More...

bool	operator!= (const ListConstIteratorSafe< Val > &src) const
	Checks whether two iterators point toward different elements. More...

bool	operator== (const ListConstIteratorSafe< Val > &src) const
	Checks whether two iterators point toward the same elements. More...

const Val &	operator* () const
	Gives access to the content of the iterator. More...

const Val *	operator-> () const
	Dereferences the value pointed to by the iterator. More...

Public Types

using	iterator_category = std::bidirectional_iterator_tag
	Types for STL compliance. More...

using	value_type = Val
	Types for STL compliance. More...

using	reference = Val &
	Types for STL compliance. More...

using	const_reference = const Val &
	Types for STL compliance. More...

using	pointer = Val *
	Types for STL compliance. More...

using	const_pointer = const Val *
	Types for STL compliance. More...

using	difference_type = std::ptrdiff_t
	Types for STL compliance. More...

Friends

template<typename T , typename A >
class	List
	class List must be a friend because it uses the getBucket method to speed up some processes. More...

class	ListConstIterator< Val >
	class List must be a friend because it uses the getBucket method to speed up some processes. More...

Detailed Description

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

Safe const iterators for Lists.

Class ListConstIteratorSafe implements safe const iterators for List. However, developers may consider using List<x>::const_iterator_safe instead of ListConstIteratorSafe<x>.

These const 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.

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>::const_iterator_safe iter = list.cbeginSafe ();
iter != list.cendSafe (); ++iter )
cerr << *iter << endl;
for ( List<string>::const_iterator_safe iter = list.cbeginSafe ();
iter != list.cendSafe (); iter += 2 ) // step = 2
cerr << *iter << endl;
for ( List<string>::const_iterator_safe iter = list.cbeginSafe ();
iter != list.cendSafe (); iter = iter + 2 ) // step = 2
cerr << *iter << endl;
for ( List<string>::const_iterator_safe iter = list.crbeginSafe ();
iter != list.crendSafe (); --iter )
cerr << *iter << endl;
// use member size() of the strings
for ( List<string>::const_iterator_safe iter = list.cbeginSafe ();
iter != list.cendSafe (); ++iter )
cerr << iter->size() << endl;

Template Parameters

Val	The gum::List values type.

Definition at line 2030 of file list.h.

Member Typedef Documentation

◆ const_pointer

template<typename Val>

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

Types for STL compliance.

Definition at line 2039 of file list.h.

◆ const_reference

template<typename Val>

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

Types for STL compliance.

Definition at line 2037 of file list.h.

◆ difference_type

template<typename Val>

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

Types for STL compliance.

Definition at line 2040 of file list.h.

◆ iterator_category

template<typename Val>

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

Types for STL compliance.

Definition at line 2034 of file list.h.

◆ pointer

template<typename Val>

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

Types for STL compliance.

Definition at line 2038 of file list.h.

◆ reference

template<typename Val>

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

Types for STL compliance.

Definition at line 2036 of file list.h.

◆ value_type

template<typename Val>

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

Types for STL compliance.

Definition at line 2035 of file list.h.

Constructor & Destructor Documentation

◆ ListConstIteratorSafe() [1/6]

template<typename Val >

INLINE gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe ( )

noexcept

Default constructor.

Returns an iterator pointing toward nothing.

Definition at line 492 of file list_tpl.h.

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

◆ ListConstIteratorSafe() [2/6]

template<typename Val>

template<typename Alloc >

gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe ( const List< Val, Alloc > & theList )

Constructor for a begin.

Template Parameters

Alloc The gum::List allocator.

◆ ListConstIteratorSafe() [3/6]

template<typename Val >

INLINE gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe ( const ListConstIteratorSafe< Val > & src )

Copy constructor.

Parameters

src	The gum::ListConstIteratorSafe to copy.

Definition at line 514 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__list, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, and gum::List< Val, Alloc >::__safe_iterators.

                                               :
       __list{src.__list},
       __bucket{src.__bucket}, __next_current_bucket{src.__next_current_bucket},
       __prev_current_bucket{src.__prev_current_bucket}, __null_pointing{
                                                            src.__null_pointing} {
     // for debugging purposes
     GUM_CONS_CPY(ListConstIteratorSafe);
 
     // add the iterator to the list of safe iterators
     if (__list != nullptr) __list->__safe_iterators.push_back(this);
   }

◆ ListConstIteratorSafe() [4/6]

template<typename Val >

template<typename Alloc >

gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe	(	const List< Val, Alloc > &	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 531 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::List< Val, Alloc >::__deb_list, gum::List< Val, Alloc >::__end_list, gum::ListConstIteratorSafe< Val >::__list, gum::List< Val, Alloc >::__nb_elements, and GUM_ERROR.

                                                       :
       __list{
          reinterpret_cast< const List< Val, std::allocator< Val > >* >(&theList)} {
     // for debugging purposes
     GUM_CONSTRUCTOR(ListConstIteratorSafe);
 
     // check if the index ind_elt passed as parameter is valid
     if (ind_elt >= __list->__nb_elements) {
       GUM_ERROR(UndefinedIteratorValue, "Not enough elements in the list");
     }
 
     // check if it is faster to find the indexth element src the start or
     // src the end of the list
     if (ind_elt < (__list->__nb_elements >> 1)) {
       // find the element we shall point to src the start of the list
       for (__bucket = __list->__deb_list; ind_elt;
            --ind_elt, __bucket = __bucket->__next) {}
     } else {
       // find the element we shall point to src the end of the list
       for (__bucket = __list->__end_list,
           ind_elt = __list->__nb_elements - ind_elt - 1;
            ind_elt;
            --ind_elt, __bucket = __bucket->__prev) {}
     }
 
     // add the iterator to the list of safe iterators
     theList.__safe_iterators.push_back(this);
   }

◆ ListConstIteratorSafe() [5/6]

template<typename Val >

INLINE gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe ( ListConstIteratorSafe< Val > && src )

Move constructor.

Parameters

src	The gum::ListConstIterator to move.

Definition at line 563 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__list, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, and gum::List< Val, Alloc >::__safe_iterators.

                                          :
       __list{src.__list},
       __bucket{src.__bucket}, __next_current_bucket{src.__next_current_bucket},
       __prev_current_bucket{src.__prev_current_bucket}, __null_pointing{
                                                            src.__null_pointing} {
     // for debugging purposes
     GUM_CONS_MOV(ListConstIteratorSafe);
 
     if (__list != nullptr) {
       // substitute src by this in the list of safe iterators
       std::vector< ListConstIteratorSafe< Val >* >& vect =
          __list->__safe_iterators;
 
       for (auto ptr = vect.rbegin(); ptr != vect.rend(); --ptr) {
         if (*ptr == &src) {
           *ptr = this;
           break;
         }
       }
 
       src.__list = nullptr;
       src.__bucket = nullptr;
       src.__null_pointing = false;
     }
   }

◆ ~ListConstIteratorSafe()

template<typename Val >

INLINE gum::ListConstIteratorSafe< Val >::~ListConstIteratorSafe ( )

Class Desctructor.

Definition at line 692 of file list_tpl.h.

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

                                                               {
     // for debugging purposes
     GUM_DESTRUCTOR(ListConstIteratorSafe);
 
     // remove the iterator src the table's iterator list
     if (__list) __removeFromSafeList();
   }

Here is the call graph for this function:

◆ ListConstIteratorSafe() [6/6]

template<typename Val>

template<typename Alloc >

INLINE gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe ( const List< Val, Alloc > & theList )

Definition at line 500 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket.

                                         :
       __list{
          reinterpret_cast< const List< Val, std::allocator< Val > >* >(&theList)},
       __bucket{theList.__deb_list} {
     // for debugging purposes
     GUM_CONSTRUCTOR(ListConstIteratorSafe);
 
     // add the iterator to the list of safe iterators
     theList.__safe_iterators.push_back(this);
   }

Member Function Documentation

◆ __getBucket()

template<typename Val >

INLINE ListBucket< Val > * gum::ListConstIteratorSafe< Val >::__getBucket ( ) const

privatenoexcept

Returns the bucket the iterator is pointing to.

Definition at line 702 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket.

Referenced by gum::List< const gum::Potential< GUM_SCALAR > * >::__insert(), and gum::List< const gum::Potential< GUM_SCALAR > * >::erase().

               {
     return __bucket;
   }

Here is the caller graph for this function:

◆ __opMinus()

template<typename Val >

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< Val >::__opMinus ( Size i )

privatenoexcept

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

Definition at line 774 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__prev_current_bucket.

Referenced by gum::ListConstIteratorSafe< Val >::operator+=(), and gum::ListConstIteratorSafe< Val >::operator-=().

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

Here is the caller graph for this function:

◆ __opPlus()

template<typename Val >

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< Val >::__opPlus ( Size i )

privatenoexcept

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

Definition at line 812 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__prev_current_bucket.

Referenced by gum::ListConstIteratorSafe< Val >::operator+=(), and gum::ListConstIteratorSafe< Val >::operator-=().

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

Here is the caller graph for this function:

◆ __removeFromSafeList()

template<typename Val >

INLINE void gum::ListConstIteratorSafe< Val >::__removeFromSafeList ( ) const

private

Remove the iterator for its list' safe iterators list.

Definition at line 592 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__list, gum::List< Val, Alloc >::__safe_iterators, and gum::ListConstIteratorSafe< Val >::operator=().

Referenced by gum::ListConstIteratorSafe< Val >::clear(), gum::ListConstIteratorSafe< Val >::operator=(), and gum::ListConstIteratorSafe< Val >::~ListConstIteratorSafe().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

template<typename Val >

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

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 709 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__list, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__removeFromSafeList().

Referenced by gum::ListConstIteratorSafe< Val >::setToEnd().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isEnd()

template<typename Val >

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

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 728 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, and gum::ListConstIteratorSafe< Val >::operator++().

                                                         {
     return __null_pointing ? (__next_current_bucket == nullptr)
                                 && (__prev_current_bucket == nullptr)
                            : (__bucket == nullptr);
   }

Here is the call graph for this function:

◆ operator!=()

template<typename Val >

INLINE bool gum::ListConstIteratorSafe< Val >::operator!= ( const ListConstIteratorSafe< 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::ListConstIteratorSafe to test for inequality.

Returns: Returns true if src and this are equal.

Definition at line 925 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, and gum::ListConstIteratorSafe< Val >::operator==().

Referenced by gum::ListConstIteratorSafe< Val >::operator-().

                                                                         {
     return __null_pointing
               ? (__next_current_bucket != src.__next_current_bucket)
                    || (__prev_current_bucket != src.__prev_current_bucket)
               : (__bucket != src.__bucket);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator*()

template<typename Val >

INLINE const Val & gum::ListConstIteratorSafe< 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 954 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, and GUM_ERROR.

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

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

Here is the caller graph for this function:

◆ operator+()

template<typename Val>

INLINE ListConstIteratorSafe< Val > gum::ListConstIteratorSafe< 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 911 of file list_tpl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator++()

template<typename Val >

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< 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::ListConstIteratorSafe.

Definition at line 737 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__prev_current_bucket.

Referenced by gum::ListConstIteratorSafe< Val >::isEnd(), and gum::ListIteratorSafe< Val >::operator++().

                                                              {
     // 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;
         return *this;
       }
 
       // 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;
         return *this;
       }
 
       // 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; }
 
       return *this;
     }
   }

Here is the caller graph for this function:

◆ operator+=()

template<typename Val>

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< 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::ListConstIterator.

Definition at line 849 of file list_tpl.h.

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

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

                                                                       {
     if (!i) return *this;
 
     if (i < 0)
       return __opMinus(-i);
     else
       return __opPlus(i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator-()

template<typename Val>

INLINE ListConstIteratorSafe< Val > gum::ListConstIteratorSafe< 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::ListConstIteratorSafe.

Definition at line 918 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::operator!=().

Referenced by gum::ListConstIteratorSafe< Val >::operator+().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator--()

template<typename Val >

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< 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::ListConstIteratorSafe.

Definition at line 862 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__prev_current_bucket.

Referenced by gum::ListConstIteratorSafe< Val >::operator+=(), and gum::ListIteratorSafe< Val >::operator--().

                                                              {
     // 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;
         return *this;
       }
 
       // 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;
         return *this;
       }
 
       // 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; }
 
       return *this;
     }
   }

Here is the caller graph for this function:

◆ operator-=()

template<typename Val>

INLINE ListConstIteratorSafe< Val > & gum::ListConstIteratorSafe< 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::ListConstIteratorSafe.

Definition at line 898 of file list_tpl.h.

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

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

                                                                       {
     if (!i) return *this;
 
     if (i < 0)
       return __opPlus(-i);
     else
       return __opMinus(i);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator->()

template<typename Val >

INLINE const Val * gum::ListConstIteratorSafe< 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 944 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, and GUM_ERROR.

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

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

Here is the caller graph for this function:

◆ operator=() [1/2]

template<typename Val >

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

Copy operator.

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

Parameters

src	The gum::ListConstIteratorSafe to copy.

Returns: Returns this gum::ListConstIteratorSafe.

Definition at line 607 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__list, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, gum::ListConstIteratorSafe< Val >::__removeFromSafeList(), and gum::List< Val, Alloc >::__safe_iterators.

Referenced by gum::ListConstIteratorSafe< Val >::__removeFromSafeList(), and gum::ListIteratorSafe< Val >::operator=().

                                                                                    {
     // avoid self assignment
     if (this != &src) {
       // for debugging purposes
       GUM_OP_CPY(ListConstIteratorSafe);
 
       // check if src and this belong to the same list. If this is not
       // the case, we shall remove this from its iterator's list and
       // put it into src's list one.
       if (__list && (src.__list != __list)) {
         __removeFromSafeList();
         __list = nullptr;
       }
 
       // if necessary, put this into the same list of safe iterators as src
       if (src.__list && (src.__list != __list)) {
         try {
           src.__list->__safe_iterators.push_back(this);
         } catch (...) {
           __list = nullptr;
           __bucket = nullptr;
           __null_pointing = false;
           throw;
         }
       }
 
       __list = src.__list;
       __bucket = src.__bucket;
       __prev_current_bucket = src.__prev_current_bucket;
       __next_current_bucket = src.__next_current_bucket;
       __null_pointing = src.__null_pointing;
     }
 
     return *this;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [2/2]

template<typename Val >

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

Move operator.

Parameters

src	The gum::ListConstIteratorSafe to move.

Returns: Returns this gum::ListConstIteratorSafe.

Definition at line 646 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__list, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, gum::ListConstIteratorSafe< Val >::__prev_current_bucket, gum::ListConstIteratorSafe< Val >::__removeFromSafeList(), and gum::List< Val, Alloc >::__safe_iterators.

                                                                               {
     // avoid self assignment
     if (this != &src) {
       // for debugging purposes
       GUM_OP_MOV(ListConstIteratorSafe);
 
       // if the two iterators do not point to the same list, remove
       // the current iterator from its safe iterators list
       if ((__list != nullptr) && (src.__list != __list)) {
         __removeFromSafeList();
         __list = nullptr;
       }
 
       // now if src points to a list, put this at its location
       if ((src.__list != nullptr)) {
         std::vector< ListConstIteratorSafe< Val >* >& vect =
            src.__list->__safe_iterators;
         Idx index_src = Size(vect.size()) - 1;
 
         for (;; --index_src) {
           if (vect[index_src] == &src) { break; }
         }
 
         if (__list == nullptr) {
           vect[index_src] = this;
         } else {
           vect.erase(vect.begin() + index_src);
         }
       }
 
       __list = src.__list;
       __bucket = src.__bucket;
       __prev_current_bucket = src.__prev_current_bucket;
       __next_current_bucket = src.__next_current_bucket;
       __null_pointing = src.__null_pointing;
 
       src.__list = nullptr;
       src.__bucket = nullptr;
       src.__null_pointing = false;
     }
 
     return *this;
   }

Here is the call graph for this function:

◆ operator==()

template<typename Val >

INLINE bool gum::ListConstIteratorSafe< Val >::operator== ( const ListConstIteratorSafe< 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::ListConstIteratorSafe to test for equality.

Returns: Returns true if src and this are equal.

Definition at line 935 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::__bucket, gum::ListConstIteratorSafe< Val >::__next_current_bucket, gum::ListConstIteratorSafe< Val >::__null_pointing, and gum::ListConstIteratorSafe< Val >::__prev_current_bucket.

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

                                                                         {
     return __null_pointing
               ? (__next_current_bucket == src.__next_current_bucket)
                    && (__prev_current_bucket == src.__prev_current_bucket)
               : (__bucket == src.__bucket);
   }

Here is the caller graph for this function:

◆ setToEnd()

template<typename Val >

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

Positions the iterator to the end of the list.

Definition at line 721 of file list_tpl.h.

References gum::ListConstIteratorSafe< Val >::clear().

                                                      {
     clear();
   }

Here is the call graph for this function:

Friends And Related Function Documentation

◆ List

template<typename Val>

template<typename T , typename A >

friend class List

friend

class List must be a friend because it uses the getBucket method to speed up some processes.

Definition at line 2248 of file list.h.

◆ ListConstIterator< Val >

template<typename Val>

friend class ListConstIterator< Val >

friend

class List must be a friend because it uses the getBucket method to speed up some processes.

Definition at line 2249 of file list.h.

Member Data Documentation

◆ __bucket

template<typename Val>

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

private

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

Definition at line 2256 of file list.h.

◆ __list

template<typename Val>

const List< Val, std::allocator< Val > >* gum::ListConstIteratorSafe< Val >::__list {nullptr}

private

The list the iterator is pointing to.

Definition at line 2253 of file list.h.

Referenced by gum::ListConstIteratorSafe< Val >::__removeFromSafeList(), gum::ListConstIteratorSafe< Val >::clear(), gum::List< const gum::Potential< GUM_SCALAR > * >::insert(), gum::ListConstIteratorSafe< Val >::ListConstIteratorSafe(), gum::ListConstIteratorSafe< Val >::operator=(), and gum::ListConstIteratorSafe< Val >::~ListConstIteratorSafe().

◆ __next_current_bucket

template<typename Val>

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

private

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

Definition at line 2260 of file list.h.

◆ __null_pointing

template<typename Val>

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

private

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

Definition at line 2267 of file list.h.

◆ __prev_current_bucket

template<typename Val>

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

private

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

Definition at line 2264 of file list.h.

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

agrum/core/list.h
agrum/core/list_tpl.h

Public Member Functions

Public Types

Friends

Detailed Description

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

Member Typedef Documentation

◆ const_pointer

◆ const_reference

◆ difference_type

◆ iterator_category

◆ pointer

◆ reference

◆ value_type

Constructor & Destructor Documentation

◆ ListConstIteratorSafe() [1/6]

◆ ListConstIteratorSafe() [2/6]

◆ ListConstIteratorSafe() [3/6]

◆ ListConstIteratorSafe() [4/6]

◆ ListConstIteratorSafe() [5/6]

◆ ~ListConstIteratorSafe()

◆ ListConstIteratorSafe() [6/6]

Member Function Documentation

◆ __getBucket()

◆ __opMinus()

◆ __opPlus()

◆ __removeFromSafeList()

◆ clear()

◆ isEnd()

◆ operator!=()

◆ operator*()

◆ operator+()

◆ operator++()

◆ operator+=()

◆ operator-()

◆ operator--()

◆ operator-=()

◆ operator->()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ setToEnd()

Friends And Related Function Documentation

◆ List

◆ ListConstIterator< Val >

Member Data Documentation

◆ __bucket

◆ __list

◆ __next_current_bucket

◆ __null_pointing

◆ __prev_current_bucket

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