Struct Array 

pub struct Array<T, const D: usize, A: Allocator = Global> { /* private fields */ }

Implementations

impl<T: Default + Clone, const D: usize> Array<T, D>

pub fn new(size: [usize; D]) -> Self

impl<T: Clone, const D: usize> Array<T, D>

pub fn new_with(size: [usize; D], item: T) -> Self

Examples found in repository

examples/indexing.rs (line 4)

fn main() {
    let mut array = Array::new_with([2, 2], 0);
    array[[0, 0]] = 1;
    array[[1, 0]] = 2;
    array[[0, 1]] = 3;
    array[[1, 1]] = 4;
    for y in 0..2 {
        for x in 0..2 {
            print!("{}", array[[x, y]]);
        }
        println!();
    }
}

examples/iterators.rs (line 4)

fn main() {
    let mut array = Array::new_with([5, 4], 0);
    array
        .iter_mut()
        .filter(|(loc, _)| loc[0] == 1)
        .for_each(|x| {
            println!("{x:?}");
            *x.1 += x.0[1];
        });
    for y in 0..4 {
        for x in 0..5 {
            print!("{}", array[[x, y]]);
        }
        println!();
    }
    assert_eq!(
        array.iter().map(|x| *x.1).collect::<Vec<_>>(),
        vec![0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0]
    )
}

impl<T, const D: usize> Array<T, D>

pub fn new_by<F: Fn() -> T>(size: [usize; D], supplier: F) -> Self

pub fn new_by_enumeration<F: Fn(usize) -> T>( size: [usize; D], supplier: F, ) -> Self

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

Flattens the ND Array into a 1D Array with indexing x + y * size_x + z * size_x * size_y etc. This is a zero-cost operation.

pub fn from_flat(array: Vec<T>, size: [usize; D]) -> Option<Self>

Reinterprets a 1D array as an ND Array with indexing x + y * size_x + z * size_x * size_y etc. This is a zero-cost operation.

impl<'a, T, const D: usize, A: Allocator> Array<T, D, A>

pub fn size(&self) -> [usize; D]

pub fn get(&'a self, loc: [usize; D]) -> Option<&'a T>

pub unsafe fn get_unchecked(&'a self, loc: [usize; D]) -> &'a T

pub fn get_mut(&'a mut self, loc: [usize; D]) -> Option<&'a mut T>

pub unsafe fn get_unchecked_mut(&'a mut self, loc: [usize; D]) -> &'a mut T

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

Examples found in repository

examples/iterators.rs (line 19)

fn main() {
    let mut array = Array::new_with([5, 4], 0);
    array
        .iter_mut()
        .filter(|(loc, _)| loc[0] == 1)
        .for_each(|x| {
            println!("{x:?}");
            *x.1 += x.0[1];
        });
    for y in 0..4 {
        for x in 0..5 {
            print!("{}", array[[x, y]]);
        }
        println!();
    }
    assert_eq!(
        array.iter().map(|x| *x.1).collect::<Vec<_>>(),
        vec![0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0]
    )
}

pub fn iter_mut(&mut self) -> Iter<IterMut<'_, T>, D>

Examples found in repository

examples/iterators.rs (line 6)

fn main() {
    let mut array = Array::new_with([5, 4], 0);
    array
        .iter_mut()
        .filter(|(loc, _)| loc[0] == 1)
        .for_each(|x| {
            println!("{x:?}");
            *x.1 += x.0[1];
        });
    for y in 0..4 {
        for x in 0..5 {
            print!("{}", array[[x, y]]);
        }
        println!();
    }
    assert_eq!(
        array.iter().map(|x| *x.1).collect::<Vec<_>>(),
        vec![0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0]
    )
}

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

Flattens the ND Array into a 1D Array with indexing x + y * size_x + z * size_x * size_y etc. This is a zero-cost operation.

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

Flattens the ND Array into a 1D Array with indexing x + y * size_x + z * size_x * size_y etc. This is a zero-cost operation.

Trait Implementations

impl<'a, T, const D: usize> Accessor<T, [usize; D]> for Array<T, D>

fn get<'b>(&'b self, index: [usize; D]) -> Option<&'b T>

Gets an item out of the array. This maybe be a split array, in which case the operation will take an item out of the vector.

impl<'a, T, const D: usize> AccessorMut<T, [usize; D]> for Array<T, D>

fn get_mut<'b>(&'b mut self, index: [usize; D]) -> Option<&'b mut T>

Gets an item out of the array mutably. This maybe be a split array, in which case the operation will take an item out of the vector.

impl<T: Clone, const D: usize, A: Clone + Allocator> Clone for Array<T, D, A>

fn clone(&self) -> Array<T, D, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const D: usize> Index<[usize; D]> for Array<T, D>

type Output = T

The returned type after indexing.

fn index(&self, index: [usize; D]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const D: usize> IndexMut<[usize; D]> for Array<T, D>

fn index_mut(&mut self, index: [usize; D]) -> &mut T

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

impl<T, const D: usize, V: RawVector<T, D>> SizedVectorArray<T, D, V, [usize; D]> for Array<V, D>

fn ptr(&self) -> *const V

fn ptr_mut(&mut self) -> *mut V

fn len(&self) -> usize

fn convert_index(&self, index: [usize; D]) -> usize

Please make this inline for speed

fn is_empty(&self) -> bool

fn vec_split_fast<'a>(&'a self) -> [FastAccessor<'a, T, D, V, I, Self>; D]

fn vec_split_fast_mut<'a>( &'a mut self, ) -> [FastAccessorMut<'a, T, D, V, I, Self>; D]

impl<T, const D: usize, V: Vector<T, D>> VectorArray<T, D, V, [usize; D]> for Array<V, D>

fn get<'a>(&'a self, index: [usize; D]) -> Option<&'a V>

fn get_mut<'a>(&'a mut self, index: [usize; D]) -> Option<&'a mut V>

fn vec_split_safe<'a>(&'a self) -> [SafeAccessor<'a, T, D, V, I, Self>; D]

fn vec_split_safe_mut<'a>( &'a mut self, ) -> [SafeAccessorMut<'a, T, D, V, I, Self>; D]