Struct SafeArray

pub struct SafeArray<E, L, P>
where
    P: SafeArrayPtr<E, L>,
{ /* private fields */ }

Safe, generic interface to BaseArray.

Uses length information to guarrantee memory safety, and excludes operations that cannot be performed safely from its API.

Trait Implementations

impl<E, L, P> Clone for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>, E: Clone, L: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, L, P> Container for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn len(&self) -> usize

Get the size of the container.

impl<E, L, P> CopyMap<usize, E> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn get(&self, key: usize) -> Option<&E>

Get a reference to a value from this map.

fn get_mut(&mut self, key: usize) -> Option<&mut E>

Get a mutable reference to a value from this map.

fn insert(&mut self, key: usize, value: E) -> Option<E>

Inserts a key-value pair into the map.

impl<E, L, P> Debug for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>, E: Debug, L: Debug,

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

Formats the value using the given formatter.

impl<E, L, P> DefaultLabelledArray<E, L> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>, E: Default,

fn with_len(label: L, len: usize) -> Self

Create a new array, initialized to default values.

impl<E, L, P> Drop for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn drop(&mut self)

Executes the destructor for this type.

impl<E, L, P> Index<usize> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

type Output = E

The returned type after indexing.

fn index(&self, idx: usize) -> &E

Performs the indexing (container[index]) operation.

impl<E, L, P> IndexMut<usize> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn index_mut(&mut self, idx: usize) -> &mut E

Performs the mutable indexing (container[index]) operation.

impl<'a, E, L, P> IntoIterator for &'a SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

type Item = &'a E

The type of the elements being iterated over.

type IntoIter = Iter<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, E, L, P> IntoIterator for &'a mut SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

type Item = &'a mut E

The type of the elements being iterated over.

type IntoIter = IterMut<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E, L, P> IntoIterator for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

type Item = E

The type of the elements being iterated over.

type IntoIter = BaseArrayIter<E, L, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E, L, P> LabelledArray<E, L> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn with_label<F>(label: L, len: usize, func: F) -> Self

where F: FnMut(&mut L, usize) -> E,

Create a new array, with values initialized using a provided function, and label initialized to a provided value.

fn get_label(&self) -> &L

Get a reference to the label.

unsafe fn get_unchecked(&self, idx: usize) -> &E

Get a reference to the element at a specified index. Implementations of this method shouldn’t do any safety checks.

impl<E, L, P> LabelledArrayMut<E, L> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

fn get_label_mut(&mut self) -> &mut L

Get mutable reference to the label.

unsafe fn get_mut_unchecked(&mut self, idx: usize) -> &mut E

Get a mutable reference to the element at a specified index. Implementations of this method shouldn’t do any safety checks.

impl<E, P> MakeArray<E> for SafeArray<E, (), P>

where P: SafeArrayPtr<E, ()>,

fn new<F>(len: usize, func: F) -> Self

where F: FnMut(usize) -> E,

Create a new array, with values initialized using a provided function.

impl<E, L, P> SliceArray<E> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

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

Returns a reference to a slice into the elements of this array.

impl<E, L, P> SliceArrayMut<E> for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>,

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

Returns a mutable reference to a slice into the elements of this array.

impl<E, L, P> Send for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>, E: Send, L: Send,

impl<E, L, P> Sync for SafeArray<E, L, P>

where P: SafeArrayPtr<E, L>, E: Sync, L: Sync,