Struct StackArray2D

pub struct StackArray2D<T: 'static, const N: usize> { /* private fields */ }

Implementations

impl<T, const N: usize> StackArray2D<T, N>

where T: Default + Copy,

pub fn new(b0: RangeInclusive<i32>, b1: RangeInclusive<i32>) -> Self

Trait Implementations

impl<T, const N: usize> ArrayOps<T, [i32; 2]> for StackArray2D<T, N>

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

fn offset(&self, index: [i32; 2]) -> usize

fn first(&self) -> &T

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

fn subarray(&self, index: I) -> &[T]

fn iter(&self) -> impl Iterator<Item = &T>

fn subscript(&self, index: I) -> i32

impl<T, const N: usize> ArrayOpsMut<T, [i32; 2]> for StackArray2D<T, N>

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

fn first_mut(&mut self) -> &mut T

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

fn subarray_mut(&mut self, index: I) -> &mut [T]

fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

fn get_disjoint_mut<const N: usize>( &mut self, indices: [I; N], ) -> Result<[&mut T; N], GetDisjointMutError>

fn get_disjoint_slices_mut<const N: usize>( &mut self, indices: [I; N], ) -> Result<[&mut [T]; N], GetDisjointMutError>

Get slices starting at the given indices, each as large as possible without overlapping.

impl<T, const N: usize> Index<[i32; 2]> for StackArray2D<T, N>

type Output = T

The returned type after indexing.

fn index(&self, index: [i32; 2]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<[i32; 2]> for StackArray2D<T, N>

fn index_mut(&mut self, index: [i32; 2]) -> &mut Self::Output

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