Struct dynamic_array::array::Array

pub struct Array<T, Len: Copy + Into<usize> + TryFrom<usize>> { /* fields omitted */ }

A dynamically-allocated array of fixed size.

Example

use dynamic_array::SmallArray;

let mut arr = SmallArray::<u32>::zeroed(9);

assert!(!arr.is_empty());

// can be freely dereferenced
assert_eq!(arr[3], 0);

arr[7] = 8;

assert_eq!(arr[7], 8);

let mut arr2 = arr.clone();

assert_ne!(arr2[3], 4);
arr[2] = 4;
arr[4] = 0xdead;
arr2[3] = 4;
assert_eq!(arr[2], 4);

// can be sliced
assert_eq!(arr[2..5], [4u32, 0, 0xdead]);

// can also be freely iterated
for x in arr.iter_mut() {
    *x += 1;
}

assert_eq!(arr[2], 5);

Implementations

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Array<T, Len>

pub fn zeroed(len: Len) -> Self

Creates a zeroed Array with length len.

pub fn from_raw(raw: *mut T, len: Len) -> Self

Constructs a new Array from a raw pointer.

After calling this function the pointer is owned by the resulting Array.

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

Extracts a slice containing all the elements of self.

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

Extracts a mutable slice containing all the elements of self.

pub fn from_vec(v: Vec<T>) -> Self where
    <Len as TryFrom<usize>>::Error: Debug, 

Constructs a new Array from a given Vec.

Example

use dynamic_array::SmallArray;

let mut v = vec![8,9,10usize];
v.reserve(1000);

let arr = SmallArray::from_vec(v);

assert_eq!(arr.len(), 3);

pub fn into_vec(self) -> Vec<T>

Constructs a Vec from Self.

Example

use dynamic_array::SmallArray;

let arr = SmallArray::<usize>::zeroed(5);

let v: Vec<usize> = arr.into_vec();

assert_eq!(v.len(), 5);
assert_eq!(v[3], 0);

pub fn len(&self) -> Len

The length of the array

Example

use dynamic_array::SmallArray;
let arr = SmallArray::<()>::zeroed(42);

assert_eq!(arr.len(), 42);

pub fn is_empty(&self) -> bool

Trait Implementations

impl<T: Clone, Len: Copy + Into<usize> + TryFrom<usize>> Clone for Array<T, Len>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Len: Copy + Into<usize> + TryFrom<usize>> Debug for Array<T, Len>

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

Formats the value using the given formatter.

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Deref for Array<T, Len>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> DerefMut for Array<T, Len>

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

Mutably dereferences the value.

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> Drop for Array<T, Len>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, Len, I> Index<I> for Array<T, Len> where
    Len: Copy + Into<usize> + TryFrom<usize>,
    I: SliceIndex<[T]>, 

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, Len, I> IndexMut<I> for Array<T, Len> where
    Len: Copy + Into<usize> + TryFrom<usize>,
    I: SliceIndex<[T]>, 

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

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

impl<T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for Array<T, Len>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'t, T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for &'t Array<T, Len>

type Item = &'t T

The type of the elements being iterated over.

type IntoIter = Iter<'t, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'t, T>

Creates an iterator from a value.

impl<'t, T, Len: Copy + Into<usize> + TryFrom<usize>> IntoIterator for &'t mut Array<T, Len>

type Item = &'t mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'t, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'t, T>

Creates an iterator from a value.

impl<T: Send, Len: Copy + Into<usize> + TryFrom<usize>> Send for Array<T, Len>

impl<T: Sync, Len: Copy + Into<usize> + TryFrom<usize>> Sync for Array<T, Len>