Struct Array

pub struct Array<Wrapped> { /* private fields */ }

A wrapper for array types that exposes checked APIs only

Implementations

impl<Wrapped> Array<Wrapped>

pub const fn new(array: Wrapped) -> Self

Wraps an array

pub fn into_inner(self) -> Wrapped

Returns the wrapped array

Trait Implementations

impl<T, Wrapped> ArrayAlloc<T> for Array<Wrapped>

where Wrapped: AsRef<[T]> + AsMut<[T]> + CanAlloc<T>,

type Error = <Wrapped as CanAlloc<T>>::Error

An alloc related error

fn alloc_new() -> Result<Self, Self::Error>

Creates a newly allocated instance of Self

fn alloc_clone<Source>(elements: &Source) -> Result<Self, Self::Error>

where Source: ArrayRef<T>, T: Clone,

Clones source into a newly allocated instance of Self

fn grow_with( &mut self, len: usize, init: impl FnMut() -> T, ) -> Result<(), Self::Error>

Grows self to the given capacity if the current length is smaller than len and inits new elements using init

fn grow(&mut self, len: usize) -> Result<(), Self::Error>

where T: Default,

Grows self to the given capacity if the current length is smaller than len and inits new elements using Default

fn shrink(&mut self, len: usize) -> Result<(), Self::Error>

Shrinks self to the given capacity if the current length is larger than len

fn push_front(&mut self, element: T) -> Result<(), Self::Error>

Pushes an element to the front of self

fn push_n_front<Source>(&mut self, elements: &Source) -> Result<(), Self::Error>

where Source: ArrayRef<T>, T: Clone,

Pushes some elements to the front of self

fn push_back(&mut self, element: T) -> Result<(), Self::Error>

Pushes an element to the front of self

fn push_n_back<Source>(&mut self, elements: &Source) -> Result<(), Self::Error>

where Source: ArrayRef<T>, T: Clone,

Pushes some elements to the front of self

fn pop_front(&mut self) -> Result<Option<T>, Self::Error>

Pops an element from the front of self

fn pop_n_front(&mut self, len: usize) -> Result<Option<Self>, Self::Error>

Pops multiple elements from the front of self

fn pop_back(&mut self) -> Result<Option<T>, Self::Error>

Pops an element from the back of self

fn pop_n_back(&mut self, len: usize) -> Result<Option<Self>, Self::Error>

Pops multiple elements from the back of self

impl<T, Wrapped> ArrayMut<T> for Array<Wrapped>

where Wrapped: AsRef<[T]> + AsMut<[T]>,

fn as_slice_mut(&mut self) -> &mut [T]

The underlying element as mutable slice

fn get_mut(&mut self, index: usize) -> Option<&mut T>

Gets a mutable reference to an element

fn get_n_mut<Range>(&mut self, range: Range) -> Option<Array<&mut [T]>>

where Range: RangeBounds<usize>,

Gets a mutable subrange

fn first_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the first element

fn last_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the last element

fn iter_mut(&mut self) -> SliceIterMut<'_, T>

Returns an iterator that mutably references the elements

fn rotate_left(&mut self, count: usize)

Rotates the elements left by count fields

fn rotate_right(&mut self, count: usize)

Rotates the elements right by count fields

fn reverse(&mut self)

Reverses the order of elements in the slice

impl<T, Wrapped> ArrayRef<T> for Array<Wrapped>

where Wrapped: AsRef<[T]>,

fn as_slice(&self) -> &[T]

The underlying elements as slice

fn len(&self) -> usize

The length of the wrapped elements

fn is_empty(&self) -> bool

Whether self is empty or not

fn get(&self, index: usize) -> Option<&T>

Gets an element

fn get_n<Range>(&self, range: Range) -> Option<Array<&[T]>>

where Range: RangeBounds<usize>,

Gets a subrange

fn first(&self) -> Option<&T>

Returns a reference to the first element

fn last(&self) -> Option<&T>

Returns a reference to the last element

fn iter(&self) -> SliceIter<'_, T>

Returns an iterator that references the elements

fn clone_to<Source>(&self, dest: &mut Source) -> Result<(), BufferTooSmall>

where Source: ArrayMut<T>, T: Clone,

Clones self to target

impl<Wrapped> AsRef<Array<Wrapped>> for Array<Wrapped>

fn as_ref(&self) -> &Array<Wrapped>

Converts this type into a shared reference of the (usually inferred) input type.

impl<Wrapped> Clone for Array<Wrapped>

where Wrapped: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Wrapped> Debug for Array<Wrapped>

where Wrapped: Debug,

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

Formats the value using the given formatter.

impl<Wrapped> Default for Array<Wrapped>

where Wrapped: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Wrapped> Hash for Array<Wrapped>

where Wrapped: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Wrapped> IntoIterator for Array<Wrapped>

where Wrapped: IntoIterator,

type Item = <Wrapped as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <Wrapped as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Wrapped> Ord for Array<Wrapped>

where Wrapped: Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Wrapped> PartialEq for Array<Wrapped>

where Wrapped: 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.

impl<Wrapped> PartialOrd for Array<Wrapped>

where Wrapped: PartialOrd,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Wrapped> Copy for Array<Wrapped>

where Wrapped: Copy,

impl<Wrapped> Eq for Array<Wrapped>

where Wrapped: Eq,