os::utils::static_double_list_links Class Reference

Statically allocated core of a double linked list, pointers to next, previous. More...

#include <cmsis-plus/utils/lists.h>

Inheritance diagram for os::utils::static_double_list_links:

Public Member Functions
Constructors & Destructor
	static_double_list_links ()
	Construct a list node (BSS initialised).
	~static_double_list_links ()
	Destruct the node.
Public Member Functions
void	unlink (void)
	Remove the node from the list.
bool	unlinked (void)
	Check if the node is unlinked.
static_double_list_links *	next (void) const
static_double_list_links *	prev (void) const
void	next (static_double_list_links *n)
void	prev (static_double_list_links *n)

Protected Attributes
Private Member Variables
static_double_list_links *	prev_
	Pointer to previous node.
static_double_list_links *	next_
	Pointer to next node.

Detailed Description

This is the simplest list node, used as base class for other list nodes and as storage for static_double_list, that must be available for any statically constructed objects while still avoiding the 'static initialisation order fiasco'.

The idea is to design the object in such a way as to benefit from the standard BSS initialisation, in other words take nullptr as starting values.

Definition at line 47 of file lists.h.

Constructor & Destructor Documentation

static_double_list_links()

os::utils::static_double_list_links::static_double_list_links ( )

inline

Definition at line 814 of file lists.h.

    {
    }

~static_double_list_links()

os::utils::static_double_list_links::~static_double_list_links ( )

inline

Definition at line 818 of file lists.h.

    {
      // Revert the content to a state similar to the statically initialised
      // state (BSS zero).
      // Unfortunately GCC removes this code as part of
      // _dead store elimination_.
      // next_ = nullptr;
      // prev_ = nullptr;
    }

Member Function Documentation

next() [1/2]

void os::utils::static_double_list_links::next ( static_double_list_links *  n )

inline

Definition at line 847 of file lists.h.

    {
      next_ = n;
    }

References next_.

next() [2/2]

static_double_list_links * os::utils::static_double_list_links::next ( void  ) const

inline

Definition at line 835 of file lists.h.

    {
      return next_;
    }

References next_.

Referenced by os::rtos::internal::waiting_threads_list::begin(), os::rtos::internal::clock_timestamps_list::check_timestamp(), os::utils::static_double_list::clear(), os::utils::static_double_list::empty(), os::utils::static_double_list::head(), and os::utils::static_double_list::insert_after().

prev() [1/2]

void os::utils::static_double_list_links::prev ( static_double_list_links *  n )

inline

Definition at line 853 of file lists.h.

    {
      prev_ = n;
    }

References prev_.

prev() [2/2]

static_double_list_links * os::utils::static_double_list_links::prev ( void  ) const

inline

Definition at line 841 of file lists.h.

    {
      return prev_;
    }

References prev_.

Referenced by os::utils::static_double_list::clear(), os::utils::static_double_list::insert_after(), os::rtos::internal::clock_timestamps_list::link(), os::rtos::internal::ready_threads_list::link(), os::rtos::internal::waiting_threads_list::link(), os::rtos::internal::terminated_threads_list::link(), os::utils::static_double_list::tail(), and os::utils::static_double_list::uninitialized().

unlink()

void os::utils::static_double_list_links::unlink

(

void

)

Returns

Nothing.

Update the neighbours to point to each other, skipping the node.

For more robustness, to prevent unexpected accesses, the links in the removed node are nullified.

Definition at line 59 of file lists.cpp.

    {
      // Check if not already unlinked.
      if (unlinked ())
        {
          assert (prev_ == nullptr);
#if defined(OS_TRACE_UTILS_LISTS)
          trace::printf ("%s() %p nop\n", __func__, this);
#endif
          return;
        }
 
#if defined(OS_TRACE_UTILS_LISTS)
      trace::printf ("%s() %p \n", __func__, this);
#endif
 
      // Make neighbours point to each other.
      prev_->next_ = next_;
      next_->prev_ = prev_;
 
      // Nullify both pointers in the unlinked node.
      prev_ = nullptr;
      next_ = nullptr;
    }

References next_, prev_, os::trace::printf(), and unlinked().

Referenced by os::rtos::internal::timeout_thread_node::action(), os::rtos::internal::timer_node::action(), and os_rtos_idle_actions().

unlinked()

bool os::utils::static_double_list_links::unlinked ( void  )

inline

Return values

true	The node is not linked.
false	The node is linked to a list.

Definition at line 829 of file lists.h.

    {
      return (next_ == nullptr);
    }

References next_.

Referenced by unlink().

Member Data Documentation

next_

static_double_list_links* os::utils::static_double_list_links::next_

protected

Definition at line 137 of file lists.h.

Referenced by os::utils::double_list_links::double_list_links(), next(), next(), unlink(), and unlinked().

prev_

static_double_list_links* os::utils::static_double_list_links::prev_

protected

Definition at line 132 of file lists.h.

Referenced by os::utils::double_list_links::double_list_links(), prev(), prev(), and unlink().

---

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

• lists.h
• lists.cpp