Struct FindMutView 

pub struct FindMutView<'a, T, Idx, K>
where
    T: Ord,
    Idx: LenType,
    K: Kind,
{ /* private fields */ }

Comes from SortedLinkedList::find_mut.

Implementations

impl<T, Idx, K> FindMutView<'_, T, Idx, K>

where T: Ord, Idx: LenType, 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::{Max, SortedLinkedList};
let mut ll: SortedLinkedList<_, Max, 3, u8> = SortedLinkedList::new_u8();

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(), Some(3));
assert_eq!(ll.pop(), Some(1));
assert_eq!(ll.pop(), None);

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::{Max, SortedLinkedList};
let mut ll: SortedLinkedList<_, Max, 3, u8> = SortedLinkedList::new_u8();

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(), Some(1002));
assert_eq!(ll.pop(), Some(3));
assert_eq!(ll.pop(), Some(1));
assert_eq!(ll.pop(), None);

Trait Implementations

impl<T, Idx, K> Deref for FindMutView<'_, T, Idx, K>

where T: Ord, Idx: LenType, K: Kind,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, Idx, K> DerefMut for FindMutView<'_, T, Idx, K>

where T: Ord, Idx: LenType, K: Kind,

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

Mutably dereferences the value.

impl<T, Idx, K> Drop for FindMutView<'_, T, Idx, K>

where T: Ord, Idx: LenType, K: Kind,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.