Struct checked_array::Array

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

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::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>

Performs the conversion.

impl<Wrapped> Clone for Array<Wrapped> where
    Wrapped: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Wrapped> Copy for Array<Wrapped> where
    Wrapped: Copy, 

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> Eq for Array<Wrapped> where
    Wrapped: Eq, 

impl<Wrapped> Hash for Array<Wrapped> where
    Wrapped: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<Wrapped> IntoIterator for Array<Wrapped> where
    Wrapped: IntoIterator, 

type Item = Wrapped::Item

The type of the elements being iterated over.

type IntoIter = Wrapped::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.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<Wrapped> PartialEq<Array<Wrapped>> for Array<Wrapped> where
    Wrapped: PartialEq, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Wrapped> PartialOrd<Array<Wrapped>> 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.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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