Struct heapless::sorted_linked_list::FindMut

pub struct FindMut<'a, T, Idx, K, const N: usize>where
    T: Ord,
    Idx: SortedLinkedListIndex,
    K: Kind,{ /* private fields */ }

Comes from SortedLinkedList::find_mut.

Implementations

impl<'a, T, Idx, K, const N: usize> FindMut<'a, T, Idx, K, N>where
    T: Ord,
    Idx: SortedLinkedListIndex,
    K: Kind,

pub fn pop(self) -> T

This will pop the element from the list.

Complexity is worst-case O(1).

Example

use heapless::sorted_linked_list::{SortedLinkedList, Max};
let mut ll: SortedLinkedList<_, _, Max, 3> = SortedLinkedList::new_usize();

ll.push(1).unwrap();
ll.push(2).unwrap();
ll.push(3).unwrap();

// Find a value and update it
let mut find = ll.find_mut(|v| *v == 2).unwrap();
find.pop();

assert_eq!(ll.pop(), Ok(3));
assert_eq!(ll.pop(), Ok(1));
assert_eq!(ll.pop(), Err(()));

pub fn finish(self)

This will resort the element into the correct position in the list if needed. The resorting will only happen if the element has been accessed mutably.

Same as calling drop.

Complexity is worst-case O(N).

Example

use heapless::sorted_linked_list::{SortedLinkedList, Max};
let mut ll: SortedLinkedList<_, _, Max, 3> = SortedLinkedList::new_usize();

ll.push(1).unwrap();
ll.push(2).unwrap();
ll.push(3).unwrap();

let mut find = ll.find_mut(|v| *v == 2).unwrap();
find.finish(); // No resort, we did not access the value.

let mut find = ll.find_mut(|v| *v == 2).unwrap();
*find += 1000;
find.finish(); // Will resort, we accessed (and updated) the value.

assert_eq!(ll.pop(), Ok(1002));
assert_eq!(ll.pop(), Ok(3));
assert_eq!(ll.pop(), Ok(1));
assert_eq!(ll.pop(), Err(()));

Trait Implementations

impl<T, Idx, K, const N: usize> Deref for FindMut<'_, T, Idx, K, N>where
    T: Ord,
    Idx: SortedLinkedListIndex,
    K: Kind,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, Idx, K, const N: usize> DerefMut for FindMut<'_, T, Idx, K, N>where
    T: Ord,
    Idx: SortedLinkedListIndex,
    K: Kind,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, Idx, K, const N: usize> Drop for FindMut<'_, T, Idx, K, N>where
    T: Ord,
    Idx: SortedLinkedListIndex,
    K: Kind,

fn drop(&mut self)

Executes the destructor for this type.