# Struct heapless::sorted_linked_list::FindMut

source ·

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

Expand description

Comes from `SortedLinkedList::find_mut`.

## Implementations§

source §

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

source

#### 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(()));

source

#### 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§

source §

### 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.
source §

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

Dereferences the value.
source §

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

source §

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

Mutably dereferences the value.
source §

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

source §

#### fn drop(&mut self)

Executes the destructor for this type. Read more

## Auto Trait Implementations§

§

### impl<'a, T, Idx, K, const N: usize> RefUnwindSafe for FindMut<'a, T, Idx, K, N>where Idx: RefUnwindSafe, K: RefUnwindSafe, T: RefUnwindSafe,

§

### impl<'a, T, Idx, K, const N: usize> Send for FindMut<'a, T, Idx, K, N>where Idx: Send, K: Send, T: Send,

§

### impl<'a, T, Idx, K, const N: usize> Sync for FindMut<'a, T, Idx, K, N>where Idx: Sync, K: Sync, T: Sync,

§

### impl<'a, T, Idx, K, const N: usize> Unpin for FindMut<'a, T, Idx, K, N>where Idx: Unpin,

§

### impl<'a, T, Idx, K, const N: usize> !UnwindSafe for FindMut<'a, T, Idx, K, N>

## Blanket Implementations§

§

### impl<T> Any for Twhere T: 'static + ?Sized,

§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T> Borrow<T> for Twhere T: ?Sized,

§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

### impl<T> From<T> for T

§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T, U> Into<U> for Twhere U: From<T>,

§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `[From]<T> for U` chooses to do.

§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.