Trait sized_chunks::ring_buffer::ArrayMut

source · [−]
pub trait ArrayMut: Array + IndexMut<usize> {
    fn get_mut(&mut self, index: usize) -> Option<&mut Self::Output> { ... }
    fn first_mut(&mut self) -> Option<&mut Self::Output> { ... }
    fn last_mut(&mut self) -> Option<&mut Self::Output> { ... }
    fn set(&mut self, index: usize, value: Self::Output) -> Option<Self::Output>
    where
        Self::Output: Sized,
    { ... }
    fn swap(&mut self, index1: usize, index2: usize)
    where
        Self::Output: Sized,
    { ... }
    fn map_pair<F, A>(&mut self, index1: usize, index2: usize, f: F) -> A
    where
        F: FnMut(&mut Self::Output, &mut Self::Output) -> A,
    { ... }
    fn sort_unstable(&mut self)
    where
        Self::Output: Ord,
        Self::Output: Sized,
    { ... }
    fn sort_unstable_by<F>(&mut self, compare: F)
    where
        F: FnMut(&Self::Output, &Self::Output) -> Ordering,
        Self::Output: Sized,
    { ... }
    fn sort_unstable_by_key<F, K>(&mut self, extract: F)
    where
        F: FnMut(&Self::Output) -> K,
        K: Ord,
        Self::Output: Sized,
    { ... }
}
Expand description

Trait for arrays with mutable indexes.

Provided Methods

Get a mutable reference to the element at the given index.

Get a mutable reference to the first element in the array.

Get a mutable reference to the last element in the array.

Set the value of the element at the given index.

Returns the previous value, or None if the index is out of bounds.

Swap the elements at two indexes.

Get mutable references to the elements at two indexes and call a function on them.

This provides a safe way to get two mutable references into an array at the same time, which would normally be disallowed by the borrow checker.

Sort the elements of the array.

Sort the elements of the array using a comparator function.

Sort the elements of the array using a key extractor function.

Implementations on Foreign Types

Implementors