# Struct heapless::sorted_linked_list::SortedLinkedList

source ·

    pub struct SortedLinkedList<T, Idx, K, const N: usize>where
        Idx: SortedLinkedListIndex,{ /* private fields */ }

Expand description

The linked list.

## Implementations§

source §

### impl<T, K, const N: usize> SortedLinkedList<T, LinkedIndexU8, K, N>

source

#### pub const fn new_u8() -> Self

Create a new linked list.

source §

### impl<T, K, const N: usize> SortedLinkedList<T, LinkedIndexU16, K, N>

source

#### pub const fn new_u16() -> Self

Create a new linked list.

source §

### impl<T, K, const N: usize> SortedLinkedList<T, LinkedIndexUsize, K, N>

source

#### pub const fn new_usize() -> Self

Create a new linked list.

source §

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

source

#### pub unsafe fn push_unchecked(&mut self, value: T)

Pushes a value onto the list without checking if the list is full.

Complexity is worst-case `O(N)`.

##### Safety

Assumes that the list is not full.

source

#### pub fn push(&mut self, value: T) -> Result<(), T>

Pushes an element to the linked list and sorts it into place.

Complexity is worst-case `O(N)`.

##### Example

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

    // The largest value will always be first
    ll.push(1).unwrap();
    assert_eq!(ll.peek(), Some(&1));

    ll.push(2).unwrap();
    assert_eq!(ll.peek(), Some(&2));

    ll.push(3).unwrap();
    assert_eq!(ll.peek(), Some(&3));

    // This will not fit in the queue.
    assert_eq!(ll.push(4), Err(4));

source

#### pub fn iter(&self) -> Iter<'_, T, Idx, K, N> ⓘ

Get an iterator over the sorted list.

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

    let mut iter = ll.iter();

    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next(), None);

source

#### pub fn find_mut<F>(&mut self, f: F) -> Option<FindMut<'_, T, Idx, K, N>>where F: FnMut(&T) -> bool,

Find an element in the list that can be changed and resorted.

##### 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 += 1000;
    find.finish();

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

source

#### pub fn peek(&self) -> Option<&T>

Peek at the first element.

##### Example

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

    // The largest value will always be first
    ll_max.push(1).unwrap();
    assert_eq!(ll_max.peek(), Some(&1));
    ll_max.push(2).unwrap();
    assert_eq!(ll_max.peek(), Some(&2));
    ll_max.push(3).unwrap();
    assert_eq!(ll_max.peek(), Some(&3));

    let mut ll_min: SortedLinkedList<_, _, Min, 3> = SortedLinkedList::new_usize();

    // The Smallest value will always be first
    ll_min.push(3).unwrap();
    assert_eq!(ll_min.peek(), Some(&3));
    ll_min.push(2).unwrap();
    assert_eq!(ll_min.peek(), Some(&2));
    ll_min.push(1).unwrap();
    assert_eq!(ll_min.peek(), Some(&1));

source

#### pub unsafe fn pop_unchecked(&mut self) -> T

Pop an element from the list without checking so the list is not empty.

##### Safety

Assumes that the list is not empty.

source

#### pub fn pop(&mut self) -> Result<T, ()>

Pops the first element in 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();

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

source

#### pub fn is_full(&self) -> bool

Checks if the linked list is full.

##### Example

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

    assert_eq!(ll.is_full(), false);

    ll.push(1).unwrap();
    assert_eq!(ll.is_full(), false);
    ll.push(2).unwrap();
    assert_eq!(ll.is_full(), false);
    ll.push(3).unwrap();
    assert_eq!(ll.is_full(), true);

source

#### pub fn is_empty(&self) -> bool

Checks if the linked list is empty.

##### Example

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

    assert_eq!(ll.is_empty(), true);

    ll.push(1).unwrap();
    assert_eq!(ll.is_empty(), false);

## Trait Implementations§

source §

### impl<T, Idx, K, const N: usize> Debug for SortedLinkedList<T, Idx, K, N>where T: Ord + Debug, Idx: SortedLinkedListIndex, K: Kind,

source §

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

Formats the value using the given formatter. Read more
source §

### impl<T, Idx, K, const N: usize> Drop for SortedLinkedList<T, Idx, K, N>where Idx: SortedLinkedListIndex,

source §

#### fn drop(&mut self)

Executes the destructor for this type. Read more

## Auto Trait Implementations§

§

### impl<T, Idx, K, const N: usize> RefUnwindSafe for SortedLinkedList<T, Idx, K, N>where Idx: RefUnwindSafe, K: RefUnwindSafe, T: RefUnwindSafe,

§

### impl<T, Idx, K, const N: usize> Send for SortedLinkedList<T, Idx, K, N>where Idx: Send, K: Send, T: Send,

§

### impl<T, Idx, K, const N: usize> Sync for SortedLinkedList<T, Idx, K, N>where Idx: Sync, K: Sync, T: Sync,

§

### impl<T, Idx, K, const N: usize> Unpin for SortedLinkedList<T, Idx, K, N>where Idx: Unpin, K: Unpin, T: Unpin,

§

### impl<T, Idx, K, const N: usize> UnwindSafe for SortedLinkedList<T, Idx, K, N>where Idx: UnwindSafe, K: UnwindSafe, T: UnwindSafe,

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