Struct Array

pub struct Array<T>
where
    T: Copy + Sized,
{ /* private fields */ }

Implementations

impl<T> Array<T>

where T: Copy + Sized,

pub fn capacity(&self) -> usize

pub fn extend(&mut self, new_capacity: usize)

pub fn extend_by(&mut self, additional_capacity: usize)

pub fn as_ptr(&self) -> *const T

pub fn as_mut_ptr(&mut self) -> *mut T

pub fn new(capacity: usize) -> Self

pub fn new_default_bytes(capacity: usize, default: u8) -> Self

pub fn new_with_default(capacity: usize, default: T) -> Self

where T: Copy,

pub fn fill(&mut self, value: T)

where T: Copy,

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

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

pub fn iter_range(&self, start: usize, end: usize) -> ArrayIterator<'_, T>

pub fn iter_range_mut( &mut self, start: usize, end: usize, ) -> ArrayIteratorMut<'_, T>

pub unsafe fn iter_range_mut_unchecked( &mut self, start: usize, end: usize, ) -> ArrayIteratorMut<'static, T>

Extremely unsafe as it bypasses lifetime checks. Use if you know what you are doing. This is good for cases where you need dynamically retrieve multiple mutable iterators to chunks of non-overlapping data.

pub fn from_vec(vec: Vec<T>) -> Self

Copies the contents of the vector into the array.

pub fn from_slice(slice: &[T]) -> Self

Copies the contents of the slice into the array.

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

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn split_at(&mut self, index: usize) -> (&[T], &[T])

pub fn split_at_mut(&mut self, index: usize) -> (&mut [T], &mut [T])

pub fn split_into_parts(&self, parts: usize) -> Array<&[T]>

pub fn split_into_parts_mut(&mut self, parts: usize) -> Vec<&mut [T]>

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

pub unsafe fn index_unchecked_mut(&mut self, index: usize) -> &mut T

Trait Implementations

impl<T> Clone for Array<T>

where T: Copy + Sized,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Drop for Array<T>

where T: Copy + Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Index<usize> for Array<T>

where T: Copy + Sized,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Array<T>

where T: Copy + Sized,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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