Struct UseListHandle

pub struct UseListHandle<T> { /* private fields */ }

State handle for the use_list hook.

Implementations

impl<T> UseListHandle<T>

pub fn current(&self) -> Ref<'_, Vec<T>>

Get immutable ref to the list.

Panics

Panics if the value is currently mutably borrowed

pub fn set(&self, elements: Vec<T>)

Set the list by elements

pub fn insert(&self, index: usize, element: T)

Insert an element at the specified index

Panics

Panics if index > len.

pub fn update(&self, index: usize, element: T)

Update the element at the specified index

pub fn remove(&self, index: usize) -> T

Removes and returns the element at position index within the list, shifting all elements after it to the left.

Panics

Panics if index is out of bounds.

pub fn push(&self, value: T)

Appends an element to the back of a collection.

pub fn pop(&self) -> Option<T>

Removes the last element from a vector and returns it, or None if it is empty.

pub fn retain<F>(&self, f: F)

where F: FnMut(&T) -> bool,

Retains only the elements specified by the predicate.

pub fn reverse(&self)

Reverses the order of elements in the slice, in place.

pub fn append(&self, other: &mut Vec<T>)

Moves all the elements of other into Self, leaving other empty.

pub fn sort(&self)

where T: Ord,

Sorts the list.

pub fn sort_by<F>(&self, compare: F)

where F: FnMut(&T, &T) -> Ordering,

Sorts the list with a comparator function.

pub fn swap(&self, a: usize, b: usize)

Swaps two elements in the list.

pub fn clear(&self)

Clears the list, removing all values.

Trait Implementations

impl<T> Clone for UseListHandle<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> PartialEq for UseListHandle<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.