Struct bern_kernel::mem::linked_list::LinkedList

pub struct LinkedList<T, P> where
    P: PoolAllocator<Node<T>> + 'static,  { /* fields omitted */ }

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 with ArrayPool allocator:

static POOL: ArrayPool<Node<MyStruct>,16> = ArrayPool::new([None; 16]);
let mut list_a = LinkedList::new(&POOL);
let mut list_b = LinkedList::new(&POOL);

Add element to the end of a list:

list_a.emplace_back(MyStruct { id: 42 });
list_a.emplace_back(MyStruct { id: 54 });

Move an element from one to another list:

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

Implementations

impl<T, P> LinkedList<T, P> where
    P: PoolAllocator<Node<T>> + 'static, 

pub fn new(pool: &'static P) -> Self

Create a new list from an allocator

pub fn emplace_back(&mut self, element: T) -> Result<(), Error>

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(&mut self, node: Box<Node<T>>)

Insert a node at the end on the list

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

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

pub fn insert(&mut self, node: Box<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(
    &mut self,
    node: Box<Node<T>>,
    criteria: impl Fn(&T, &T) -> bool
)

Insert a node before the first failed 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(&mut self) -> Cursor<'_, T, P>

Provides a cursor with editing operation at the front element.

Trait Implementations

impl<T: Debug, P: Debug> Debug for LinkedList<T, P> where
    P: PoolAllocator<Node<T>> + 'static, 

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

Formats the value using the given formatter.