Struct bern_kernel::mem::linked_list::LinkedList

pub struct LinkedList<T> { /* private fields */ }

A doubly-linked list owning its nodes.

Based on std::collections::LinkedList and https://rust-unofficial.github.io/too-many-lists.

Examples

Create a new list:

let mut list_a = LinkedList::new();
let mut list_b = LinkedList::new();

Add element to the end of a list with an allocator:

static ALLOCATOR: Bump = unsafe { Bump::new(NonNull::new_unchecked(0x2001E000 as *mut u8), 5_000) };
list_a.emplace_back(MyStruct { id: 42 }, &ALLOCATOR);
list_a.emplace_back(MyStruct { id: 54 }, &ALLOCATOR);

Nodes in the same list can be allocated in different memory sections.

Move an element from one to another list:

let node = list_a.pop_front();
list_a.push_back(node);

Implementations

impl<T> LinkedList<T>

pub const fn new() -> Self

Create an empty list

pub fn emplace_back(
    &self,
    element: T,
    alloc: &'static dyn Allocator
) -> Result<(), AllocError>

Allocate a new element and move it to the end of the list

Note: This fails when we’re out of memory

pub fn push_back(&self, node: Box<Node<T>>)

Insert a node at the end on the list

pub fn pop_front(&self) -> Option<Box<Node<T>>>

Remove and return the first node from the list if there is any

pub fn insert(&self, node: NonNull<Node<T>>, new_node: Box<Node<T>>)

Insert a node exactly before a given node

Note: prefer Self::insert_when() if possible

pub fn insert_when(&self, node: Box<Node<T>>, criteria: impl Fn(&T, &T) -> bool)

Insert a node before the first succeeding match given a comparison criteria.

Example

Insert task pausing before the element where the next wake-up time next_wut() is larger than the one of pausing.

/* create and populate list */
let pausing: Task = /* omitted */;
tasks_sleeping.insert_when(
    pausing,
    |pausing, task| {
        pausing.next_wut() > task.next_wut()
    });

pub fn front(&self) -> Option<&T>

Get a reference to the first value of the list if there is a node

pub fn back(&self) -> Option<&T>

Get a reference to last value of the list if there is a node

pub fn len(&self) -> usize

Get the current length of the list

pub fn iter(&self) -> Iter<'_, T>

Provides a forward iterator.

pub fn iter_mut(&self) -> IterMut<'_, T>

Provides a forward iterator with mutable references.

pub fn cursor_front_mut(&self) -> Cursor<'_, T>

Provides a cursor with editing operation at the front element.

Trait Implementations

impl<T: Debug> Debug for LinkedList<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.