Struct lat::Grid

pub struct Grid<T> { /* private fields */ }

Implementations

impl<T: Default + Clone> Grid<T>

pub fn from_defaults(width: usize, height: usize) -> Self

impl<T> Grid<T>

pub fn from_fn( width: usize, height: usize, fun: &mut impl FnMut(usize, usize) -> T ) -> Self

pub fn width(&self) -> usize

pub fn height(&self) -> usize

pub fn map_once<U, F>(self, mapper: F) -> Grid<U>where F: FnMut(T) -> U,

pub fn map<U, F>(&self, mapper: F) -> Grid<U>where F: FnMut(&T) -> U,

impl<T: Clone> Grid<T>

pub fn map_mut<F>(&mut self, mapper: F) -> &mut Grid<T>where F: FnMut(T) -> T,

pub fn map_with_neighbors<U, F>(&self, mapper: F, default: T) -> Grid<U>where F: FnMut(&[[T; 3]; 3]) -> U, U: Default,

Trait Implementations

impl<'a, R: 'static, T: Add<&'a R>> Add<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Add<&'a R>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Grid<R>) -> Self::Output

Performs the + operation.

impl<'a, R, T: AddAssign<&'a R>> AddAssign<&'a Grid<R>> for Grid<T>

fn add_assign(&mut self, rhs: &'a Grid<R>)

Performs the += operation.

impl<'a, R: 'static, T: BitAnd<&'a R>> BitAnd<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as BitAnd<&'a R>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Grid<R>) -> Self::Output

Performs the & operation.

impl<'a, R, T: BitAndAssign<&'a R>> BitAndAssign<&'a Grid<R>> for Grid<T>

fn bitand_assign(&mut self, rhs: &'a Grid<R>)

Performs the &= operation.

impl<'a, R: 'static, T: BitOr<&'a R>> BitOr<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as BitOr<&'a R>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Grid<R>) -> Self::Output

Performs the | operation.

impl<'a, R, T: BitOrAssign<&'a R>> BitOrAssign<&'a Grid<R>> for Grid<T>

fn bitor_assign(&mut self, rhs: &'a Grid<R>)

Performs the |= operation.

impl<'a, R: 'static, T: BitXor<&'a R>> BitXor<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as BitXor<&'a R>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Grid<R>) -> Self::Output

Performs the ^ operation.

impl<'a, R, T: BitXorAssign<&'a R>> BitXorAssign<&'a Grid<R>> for Grid<T>

fn bitxor_assign(&mut self, rhs: &'a Grid<R>)

Performs the ^= operation.

impl<'a, R: 'static, T: Div<&'a R>> Div<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Div<&'a R>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Grid<R>) -> Self::Output

Performs the / operation.

impl<'a, R, T: DivAssign<&'a R>> DivAssign<&'a Grid<R>> for Grid<T>

fn div_assign(&mut self, rhs: &'a Grid<R>)

Performs the /= operation.

impl<T> Index<(usize, usize)> for Grid<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<(usize, usize)> for Grid<T>

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

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

impl<'a, R: 'static, T: Mul<&'a R>> Mul<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Mul<&'a R>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Grid<R>) -> Self::Output

Performs the * operation.

impl<'a, R, T: MulAssign<&'a R>> MulAssign<&'a Grid<R>> for Grid<T>

fn mul_assign(&mut self, rhs: &'a Grid<R>)

Performs the *= operation.

impl<'a, T: Neg> Neg for Grid<T>

type Output = Grid<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T: Not> Not for Grid<T>

type Output = Grid<<T as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, R: 'static, T: Rem<&'a R>> Rem<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Rem<&'a R>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Grid<R>) -> Self::Output

Performs the % operation.

impl<'a, R, T: RemAssign<&'a R>> RemAssign<&'a Grid<R>> for Grid<T>

fn rem_assign(&mut self, rhs: &'a Grid<R>)

Performs the %= operation.

impl<'a, R: 'static, T: Shl<&'a R>> Shl<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Shl<&'a R>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a Grid<R>) -> Self::Output

Performs the << operation.

impl<'a, R, T: ShlAssign<&'a R>> ShlAssign<&'a Grid<R>> for Grid<T>

fn shl_assign(&mut self, rhs: &'a Grid<R>)

Performs the <<= operation.

impl<'a, R: 'static, T: Shr<&'a R>> Shr<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Shr<&'a R>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a Grid<R>) -> Self::Output

Performs the >> operation.

impl<'a, R, T: ShrAssign<&'a R>> ShrAssign<&'a Grid<R>> for Grid<T>

fn shr_assign(&mut self, rhs: &'a Grid<R>)

Performs the >>= operation.

impl<'a, R: 'static, T: Sub<&'a R>> Sub<&'a Grid<R>> for Grid<T>

type Output = Grid<<T as Sub<&'a R>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Grid<R>) -> Self::Output

Performs the - operation.

impl<'a, R, T: SubAssign<&'a R>> SubAssign<&'a Grid<R>> for Grid<T>

fn sub_assign(&mut self, rhs: &'a Grid<R>)

Performs the -= operation.