Skip to main content

The intrusive_list_iterator Class Template Reference

A class template for the intrusive list iterator. More...

Declaration

template <class T, class N, N T::* MP, class U = T>
class micro_os_plus::utils::intrusive_list_iterator<T, N, MP, U>;

Included Headers

Public Member Typedefs Index

usingdifference_type = ptrdiff_t

Type of pointer difference. More...

usingiterator_category = std::forward_iterator_tag

Category of iterator. More...

usingiterator_pointer = N *

Type of reference to the iterator internal pointer. More...

usingpointer = value_type *

Type of pointer to object pointed to by the iterator. More...

usingreference = value_type &

Type of reference to object pointed to by the iterator. More...

usingvalue_type = U

Type of value pointed to by the iterator. More...

Protected Member Attributes Index

iterator_pointernode_

Pointer to intrusive node. More...

Public Constructors Index

constexprintrusive_list_iterator ()

Default constructor. Constructs an iterator pointing to nullptr. More...

constexprintrusive_list_iterator (iterator_pointer const node)

Construct an iterator from a node pointer. More...

constexprintrusive_list_iterator (reference element)

Construct an iterator from a reference to an element. More...

Public Member Functions Index

iterator_pointerget_iterator_pointer (void) const

Retrieve the iterator pointer for the current node. More...

pointerget_pointer (void) const

Get the object node from the intrusive node. More...

intrusive_list_iterator &operator-- ()

Pre-decrement operator. More...

intrusive_list_iteratoroperator-- (int)

Post-decrement operator. More...

pointeroperator-> () const

Pointer access operator. More...

booloperator!= (const intrusive_list_iterator &other) const

Inequality comparison operator. More...

referenceoperator* () const

Dereference operator. More...

intrusive_list_iterator &operator++ ()

Pre-increment operator. More...

intrusive_list_iteratoroperator++ (int)

Post-increment operator. More...

booloperator== (const intrusive_list_iterator &other) const

Equality comparison operator. More...

Description

A class template for the intrusive list iterator.

Template Parameters
TType of object that includes the intrusive node.
NType of intrusive node. Must have the public members previous & next.
MPName of the intrusive node member in object T.
UType stored in the list, derived from T.

This class provides an interface similar to std::list::iterator, except that it keeps track of the offset where the intrusive list element is located in the parent object. It supports bidirectional iteration and access to the underlying object and node.

Definition at line 928 of file lists.h.

Public Member Typedefs

difference_type

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::difference_type = ptrdiff_t

Type of pointer difference.

Definition at line 954 of file lists.h.

iterator_category

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::iterator_category = std::forward_iterator_tag

Category of iterator.

Definition at line 959 of file lists.h.

iterator_pointer

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::iterator_pointer = N*

Type of reference to the iterator internal pointer.

Definition at line 949 of file lists.h.

pointer

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::pointer = value_type*

Type of pointer to object pointed to by the iterator.

Definition at line 939 of file lists.h.

reference

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::reference = value_type&

Type of reference to object pointed to by the iterator.

Definition at line 944 of file lists.h.

value_type

template <class T, class N, N T::* MP, class U = T>
using micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::value_type = U

Type of value pointed to by the iterator.

Definition at line 934 of file lists.h.

Protected Member Attributes

node_

template <class T, class N, N T::* MP, class U = T>
iterator_pointer micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::node_
protected

Pointer to intrusive node.

Stores the address of the current intrusive node in the list.

Definition at line 1081 of file lists.h.

Public Constructors

intrusive_list_iterator()

template <class T, class N, N T::* MP, class U = T>
micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::intrusive_list_iterator ()
constexpr

Default constructor. Constructs an iterator pointing to nullptr.

The default constructor for intrusive_list_iterator initialises the iterator to a null state, meaning it does not point to any node in the list. This is typically used to create an "end" iterator or to initialise an iterator variable before assigning it to a valid node.

info

The internal node pointer is value-initialised (set to nullptr), ensuring that the iterator is safe to use in comparisons and will not dereference an invalid address.

Declaration at line 967 of file lists.h, definition at line 735 of file lists-inlines.h.

intrusive_list_iterator()

template <class T, class N, N T::* MP, class U = T>
micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::intrusive_list_iterator (iterator_pointer const node)
explicitconstexpr

Construct an iterator from a node pointer.

Parameters
nodePointer to the node to which the iterator should point.

This constructor creates an intrusive_list_iterator that points to the specified node. The internal node pointer is set to the provided node address, allowing the iterator to traverse the list starting from that node. This is typically used to initialise an iterator to a specific position within the list, such as the beginning or end.

Declaration at line 974 of file lists.h, definition at line 749 of file lists-inlines.h.

intrusive_list_iterator()

template <class T, class N, N T::* MP, class U = T>
micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::intrusive_list_iterator (reference element)
explicitconstexpr

Construct an iterator from a reference to an element.

Parameters
elementReference to the element to which the iterator should point.

This constructor creates an intrusive_list_iterator that points to the specified element. The internal node pointer is set to the address of the intrusive node member within the given element, allowing the iterator to traverse the list starting from that element. This is typically used to initialise an iterator to a specific object in the list.

Declaration at line 982 of file lists.h, definition at line 764 of file lists-inlines.h.

Public Member Functions

get_iterator_pointer()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U >::iterator_pointer micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::get_iterator_pointer (void) const
inline

Retrieve the iterator pointer for the current node.

Parameters

None.

Returns

The iterator pointer corresponding to the current node.

Returns a pointer to the internal iterator node associated with the current object. This is typically used for advanced list operations or when direct access to the underlying node is required.

Declaration at line 1072 of file lists.h, definition at line 938 of file lists-inlines.h.

get_pointer()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U >::pointer micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::get_pointer (void) const
inline

Get the object node from the intrusive node.

Parameters

None.

Returns

Pointer to object node.

Computes and returns a pointer to the parent object that contains the intrusive node currently referenced by the iterator. This is achieved by calculating the offset of the intrusive node member within the parent object type and subtracting it from the node's address. This technique allows the iterator to provide access to the full object from just the node pointer, enabling intrusive list traversal and manipulation.

Declaration at line 1062 of file lists.h, definition at line 914 of file lists-inlines.h.

operator!=()

template <class T, class N, N T::* MP, class U = T>
bool micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator!= (const intrusive_list_iterator & other) const
inline

Inequality comparison operator.

Parameters
otherIterator to compare with.
Returns

true if the iterators point to different nodes, false otherwise.

The inequality comparison operator (operator!=) checks whether two intrusive list iterators point to different nodes in the list by comparing their internal node pointers. This is useful for standard iterator operations, such as determining whether an iterator has reached the end of a range or for loop termination conditions.

Declaration at line 1052 of file lists.h, definition at line 897 of file lists-inlines.h.

operator*()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U >::reference micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator* () const
inline

Dereference operator.

Returns

Reference to the value pointed to by the iterator.

The dereference operator (operator*) provides access to the value or object pointed to by the iterator. Internally, it calls get_pointer() to obtain a pointer to the underlying value or object associated with the current node in the list, and then dereferences it to return a reference.

This allows the iterator to be used in a manner similar to standard C++ iterators, enabling direct access to the list element for reading or modification.

Declaration at line 1001 of file lists.h, definition at line 800 of file lists-inlines.h.

operator++()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U > & micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator++ ()
inline

Pre-increment operator.

Returns

Reference to the incremented iterator.

The pre-increment operator (operator++) advances the intrusive list iterator to the next node in the list. It updates the internal node pointer to point to the node returned by the current node's next() method. This enables forward traversal of the list, following the linked structure.

Declaration at line 1009 of file lists.h, definition at line 815 of file lists-inlines.h.

operator++()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U > micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator++ (int)
inline

Post-increment operator.

Returns

Iterator before increment.

The post-increment operator (operator++(int)) advances the intrusive list iterator to the next node in the list, but returns a copy of the iterator as it was before the increment. This allows iteration logic that requires access to the current element before moving to the next one, following the standard C++ iterator semantics for post-increment.

Declaration at line 1017 of file lists.h, definition at line 831 of file lists-inlines.h.

operator--()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U > & micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator-- ()
inline

Pre-decrement operator.

Returns

Reference to the decremented iterator.

The pre-decrement operator (operator--) moves the intrusive list iterator to the previous node in the list. It updates the internal node pointer to point to the node returned by the current node's previous() method. This enables backward traversal of the list, following the linked structure in reverse.

Declaration at line 1025 of file lists.h, definition at line 848 of file lists-inlines.h.

operator--()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U > micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator-- (int)

Post-decrement operator.

Returns

Iterator before decrement.

The post-decrement operator (operator--(int)) moves the intrusive list iterator to the previous node in the list, but returns a copy of the iterator as it was before the decrement. This enables iteration logic that requires access to the current element before moving backward, following the standard C++ iterator semantics for post-decrement.

Declaration at line 1033 of file lists.h, definition at line 864 of file lists-inlines.h.

operator->()

template <class T, class N, N T::* MP, class U = T>
intrusive_list_iterator< T, N, MP, U >::pointer micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator-> () const
inline

Pointer access operator.

Returns

Pointer to the value pointed to by the iterator.

The pointer access operator (operator->) allows the intrusive list iterator to provide direct access to the value pointed to by the iterator, mimicking the behavior of a raw pointer. Internally, it calls get_pointer(), which computes and returns a pointer to the underlying value or object associated with the current node in the list.

Declaration at line 993 of file lists.h, definition at line 782 of file lists-inlines.h.

operator==()

template <class T, class N, N T::* MP, class U = T>
bool micro_os_plus::utils::intrusive_list_iterator< T, N, MP, U >::operator== (const intrusive_list_iterator & other) const
inline

Equality comparison operator.

Parameters
otherIterator to compare with.
Returns

true if both iterators point to the same node, false otherwise.

The equality comparison operator (operator==) checks whether two intrusive list iterators point to the same node in the list by comparing their internal node pointers. This enables standard iterator comparisons, such as detecting the end of a range or verifying if two iterators refer to the same position within the list.

Declaration at line 1043 of file lists.h, definition at line 881 of file lists-inlines.h.


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


Generated via docusaurus-plugin-doxygen by Doxygen 1.13.2