`double_list_iterator` Class Template

A class template for a doubly linked list forward iterator. More...

Declaration

template <class T, class N = T, class U = T> class micro_os_plus::utils::double_list_iterator<T, N, U> { ... }

Included Headers

Public Member Typedefs Index

template <class T, class N = T, class U = T>
using	difference_type = ptrdiff_t
	Type of pointer difference. More...

template <class T, class N = T, class U = T>
using	iterator_category = std::forward_iterator_tag
	Category of iterator. More...

template <class T, class N = T, class U = T>
using	iterator_pointer = N *
	Type of reference to the iterator internal pointer. More...

template <class T, class N = T, class U = T>
using	pointer = value_type *
	Type of pointer to object pointed to by the iterator. More...

template <class T, class N = T, class U = T>
using	reference = value_type &
	Type of reference to object pointed to by the iterator. More...

template <class T, class N = T, class U = T>
using	value_type = U
	Type of value pointed to by the iterator. More...

Public Constructors Index

template <class T, class N = T, class U = T>
constexpr	double_list_iterator ()
	Default constructor. Constructs an iterator pointing to nullptr. More...

template <class T, class N = T, class U = T>
constexpr	double_list_iterator (iterator_pointer const node)
	Construct an iterator from a node pointer. More...

template <class T, class N = T, class U = T>
constexpr	double_list_iterator (reference element)
	Construct an iterator from a reference to an element. More...

Public Operators Index

template <class T, class N = T, class U = T>
constexpr bool	operator!= (const double_list_iterator &other) const
	Inequality comparison operator. More...

template <class T, class N = T, class U = T>
constexpr reference	operator* () const
	Dereference operator. More...

template <class T, class N = T, class U = T>
constexpr double_list_iterator &	operator++ ()
	Pre-increment operator. More...

template <class T, class N = T, class U = T>
constexpr double_list_iterator	operator++ (int)
	Post-increment operator. More...

template <class T, class N = T, class U = T>
constexpr double_list_iterator &	operator-- ()
	Pre-decrement operator. More...

template <class T, class N = T, class U = T>
constexpr double_list_iterator	operator-- (int)
	Post-decrement operator. More...

template <class T, class N = T, class U = T>
constexpr pointer	operator-> () const
	Pointer access operator. More...

template <class T, class N = T, class U = T>
constexpr bool	operator== (const double_list_iterator &other) const
	Equality comparison operator. More...

Public Member Functions Index

template <class T, class N = T, class U = T>
constexpr iterator_pointer	get_iterator_pointer (void) const
	Get the internal iterator pointer (node pointer). More...

template <class T, class N = T, class U = T>
constexpr pointer	get_pointer (void) const
	Get a pointer to the value pointed to by the iterator. More...

Protected Member Attributes Index

template <class T, class N = T, class U = T>
iterator_pointer	node_
	Pointer to the node. More...

Description

A class template for a doubly linked list forward iterator.

Template Parameters

T	Type of object returned by the iterator.
N	Type of intrusive node. Must have the public members previous & next.
U	Type stored in the list, derived from T.

This iterator provides an interface similar to std::list::iterator for traversing a doubly linked list. It supports bidirectional iteration and access to the underlying node and value. In a typical doubly linked list, all types are double_list_links.

Definition at line 494 of file lists.h.

Public Member Typedefs

difference_type

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::difference_type = ptrdiff_t

Type of pointer difference.

Definition at line 520 of file lists.h.

520 using difference_type = ptrdiff_t;

iterator_category

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::iterator_category = std::forward_iterator_tag

Category of iterator.

Definition at line 525 of file lists.h.

525 using iterator_category = std::forward_iterator_tag;

iterator_pointer

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::iterator_pointer = N*

Type of reference to the iterator internal pointer.

Definition at line 515 of file lists.h.

515 using iterator_pointer = N*;

pointer

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::pointer = value_type*

Type of pointer to object pointed to by the iterator.

Definition at line 505 of file lists.h.

505 using pointer = value_type*;

reference

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::reference = value_type&

Type of reference to object pointed to by the iterator.

Definition at line 510 of file lists.h.

510 using reference = value_type&;

value_type

template <class T, class N = T, class U = T>

using micro_os_plus::utils::double_list_iterator< T, N, U >::value_type = U

Type of value pointed to by the iterator.

Definition at line 500 of file lists.h.

500 using value_type = U;

Public Constructors

double_list_iterator()

template <class T, class N = T, class U = T>

micro_os_plus::utils::double_list_iterator< T, N, U >::double_list_iterator ()

constexpr

Default constructor. Constructs an iterator pointing to nullptr.

The default constructor for double_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 533 of file lists.h, definition at line 285 of file lists-inlines.h.

285 constexpr double_list_iterator<T, N, U>::double_list_iterator () : node_{}

286 {

287 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

Referenced by micro_os_plus::utils::double_list_iterator< T, N, U >::operator!= and micro_os_plus::utils::double_list_iterator< T, N, U >::operator==.

double_list_iterator()

template <class T, class N = T, class U = T>

micro_os_plus::utils::double_list_iterator< T, N, U >::double_list_iterator (iterator_pointer const node)

explicit constexpr

Construct an iterator from a node pointer.

Parameters

node	Pointer to the node to which the iterator should point.

This constructor creates a double_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 constructor is typically used to initialise an iterator to a specific position within the list, such as the beginning or end.

Declaration at line 540 of file lists.h, definition at line 298 of file lists-inlines.h.

298 constexpr double_list_iterator<T, N, U>::double_list_iterator (

299 iterator_pointer const node)

300 : node_{ node }

301 {

302 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

double_list_iterator()

template <class T, class N = T, class U = T>

micro_os_plus::utils::double_list_iterator< T, N, U >::double_list_iterator (reference element)

explicit constexpr

Construct an iterator from a reference to an element.

Parameters

element

Reference to the element to which the iterator should point.

Definition at line 548 of file lists.h.

Public Operators

operator--()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U > & micro_os_plus::utils::double_list_iterator< T, N, U >::operator-- ()

constexpr

Pre-decrement operator.

Returns: Reference to the decremented iterator.

The pre-decrement operator (operator--) moves the 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 pointer. This enables backward traversal of the list, following the linked structure in reverse.

Declaration at line 591 of file lists.h, definition at line 391 of file lists-inlines.h.

391 double_list_iterator<T, N, U>::operator--()

392 {

393 node_ = static_cast<iterator_pointer> (node_->previous);

394 return *this;

395 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

operator--()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U > micro_os_plus::utils::double_list_iterator< T, N, U >::operator-- (int)

constexpr

Post-decrement operator.

Returns: Iterator before decrement.

The post-decrement operator (operator--(int)) moves the 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 599 of file lists.h, definition at line 407 of file lists-inlines.h.

407 double_list_iterator<T, N, U>::operator--(int)

408 {

409 const auto tmp = *this;

410 node_ = static_cast<iterator_pointer> (node_->previous);

411 return tmp;

412 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

operator->()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U >::pointer micro_os_plus::utils::double_list_iterator< T, N, U >::operator-> ()

constexpr

Pointer access operator.

Returns: Pointer to the value pointed to by the iterator.

The pointer access operator (operator->) allows the 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 559 of file lists.h, definition at line 325 of file lists-inlines.h.

325 double_list_iterator<T, N, U>::operator->() const

326 {

327 return get_pointer ();

328 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::get_pointer.

operator!=()

template <class T, class N = T, class U = T>

bool micro_os_plus::utils::double_list_iterator< T, N, U >::operator!= (const double_list_iterator & other)

constexpr

Inequality comparison operator.

Parameters

other

Iterator to compare with.

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

The inequality comparison operator (operator!=) checks whether two 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 619 of file lists.h, definition at line 440 of file lists-inlines.h.

440 double_list_iterator<T, N, U>::operator!=(

441 const double_list_iterator& other) const

442 {

443 return node_ != other.node_;

444 }

References micro_os_plus::utils::double_list_iterator< T, N, U >::double_list_iterator and micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

operator*()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U >::reference micro_os_plus::utils::double_list_iterator< T, N, U >::operator* ()

constexpr

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 567 of file lists.h, definition at line 343 of file lists-inlines.h.

343 double_list_iterator<T, N, U>::operator*() const

344 {

345 return *get_pointer ();

346 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::get_pointer.

operator++()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U > & micro_os_plus::utils::double_list_iterator< T, N, U >::operator++ ()

constexpr

Pre-increment operator.

Returns: Reference to the incremented iterator.

The pre-increment operator (operator++) advances the 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 allows the iterator to traverse the list in the forward direction, following the linked structure.

Declaration at line 575 of file lists.h, definition at line 358 of file lists-inlines.h.

358 double_list_iterator<T, N, U>::operator++()

359 {

360 node_ = static_cast<N*> (node_->next ());

361 return *this;

362 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

operator++()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U > micro_os_plus::utils::double_list_iterator< T, N, U >::operator++ (int)

constexpr

Post-increment operator.

Returns: Iterator before increment.

The post-increment operator (operator++(int)) advances the 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 583 of file lists.h, definition at line 374 of file lists-inlines.h.

374 double_list_iterator<T, N, U>::operator++(int)

375 {

376 const auto tmp = *this;

377 node_ = static_cast<iterator_pointer> (node_->next);

378 return tmp;

379 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

operator==()

template <class T, class N = T, class U = T>

bool micro_os_plus::utils::double_list_iterator< T, N, U >::operator== (const double_list_iterator & other)

constexpr

Equality comparison operator.

Parameters

other

Iterator to compare with.

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

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

Declaration at line 609 of file lists.h, definition at line 424 of file lists-inlines.h.

424 double_list_iterator<T, N, U>::operator==(

425 const double_list_iterator& other) const

426 {

427 return node_ == other.node_;

428 }

References micro_os_plus::utils::double_list_iterator< T, N, U >::double_list_iterator and micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

Public Member Functions

get_iterator_pointer()

template <class T, class N = T, class U = T>

double_list_iterator< T, N, U >::iterator_pointer micro_os_plus::utils::double_list_iterator< T, N, U >::get_iterator_pointer (void)

constexpr

Get the internal iterator pointer (node pointer).

Parameters: None.

Returns: Pointer to the node.

Returns the internal node pointer that the iterator currently references. This is useful for advanced list operations or when direct access to the underlying node structure is required, such as for interoperability with other list utilities or for debugging purposes.

Declaration at line 639 of file lists.h, definition at line 455 of file lists-inlines.h.

455 double_list_iterator<T, N, U>::get_iterator_pointer () const

456 {

457 return node_;

458 }

Reference micro_os_plus::utils::double_list_iterator< T, N, U >::node_.

get_pointer()

template <class T, class N = T, class U = T>

pointer micro_os_plus::utils::double_list_iterator< T, N, U >::get_pointer (void)

constexpr

Get a pointer to the value pointed to by the iterator.

Parameters: None.

Returns: Pointer to the value.

Definition at line 629 of file lists.h.

Referenced by micro_os_plus::utils::double_list_iterator< T, N, U >::operator* and micro_os_plus::utils::double_list_iterator< T, N, U >::operator->.

Protected Member Attributes

node_

template <class T, class N = T, class U = T>

iterator_pointer micro_os_plus::utils::double_list_iterator< T, N, U >::node_

protected

Pointer to the node.

Definition at line 645 of file lists.h.

645 iterator_pointer node_;

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

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.14.0.

Declaration​

Included Headers​

Public Member Typedefs Index​

Public Constructors Index​

Public Operators Index​

Public Member Functions Index​

Protected Member Attributes Index​

Description​

Public Member Typedefs​

difference_type​

iterator_category​

iterator_pointer​

pointer​

reference​

value_type​

Public Constructors​

double_list_iterator()​

double_list_iterator()​

double_list_iterator()​

Public Operators​

operator--()​

operator--()​

operator->()​

operator!=()​

operator*()​

operator++()​

operator++()​

operator==()​

Public Member Functions​

get_iterator_pointer()​

get_pointer()​

Protected Member Attributes​

node_​

Declaration

Included Headers

Public Member Typedefs Index

Public Constructors Index

Public Operators Index

Public Member Functions Index

Protected Member Attributes Index

Description

Public Member Typedefs

difference_type

iterator_category

iterator_pointer

pointer

reference

value_type

Public Constructors

double_list_iterator()

double_list_iterator()

double_list_iterator()

Public Operators

operator--()

operator--()

operator->()

operator!=()

operator*()

operator++()

operator++()

operator==()

Public Member Functions

get_iterator_pointer()

get_pointer()

Protected Member Attributes

node_