Struct Grid2d

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

Implementations

impl<T> Grid2d<T>

where T: Clone + Send + Sync,

pub fn new(cols: usize, rows: usize, fill: T) -> Self

pub fn with_cells(cols: usize, cells: Vec<T>) -> Self

pub fn resize(&mut self, cols: usize, rows: usize, default: T)

pub fn cols(&self) -> usize

pub fn rows(&self) -> usize

pub fn size(&self) -> (usize, usize)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

pub fn cell(&self, col: usize, row: usize) -> Option<&T>

pub fn cell_mut(&mut self, col: usize, row: usize) -> Option<&mut T>

pub fn get(&self, col: usize, row: usize) -> Option<T>

pub fn set(&mut self, col: usize, row: usize, value: T)

pub fn get_col_cells(&self, index: usize) -> Option<Vec<T>>

pub fn get_row_cells(&self, index: usize) -> Option<Vec<T>>

pub fn copy_part(&self, range: Range<(usize, usize)>, result: &mut Self)

where T: Default,

pub fn get_part(&self, range: Range<(usize, usize)>) -> Self

pub fn get_part_seamless(&self, range: Range<(usize, usize)>) -> Self

pub fn get_view(&self, range: Range<(usize, usize)>) -> Grid2d<&T>

pub fn get_view_seamless(&self, range: Range<(usize, usize)>) -> Grid2d<&T>

pub fn copy_sample( &self, (col, row): (usize, usize), margin: usize, result: &mut Self, )

where T: Default,

pub fn sample(&self, (col, row): (usize, usize), margin: usize) -> Self

pub fn sample_seamless(&self, (col, row): (usize, usize), margin: usize) -> Self

pub fn view_sample( &self, (col, row): (usize, usize), margin: usize, ) -> Grid2d<&T>

pub fn view_sample_seamless( &self, (col, row): (usize, usize), margin: usize, ) -> Grid2d<&T>

pub fn map<F, R>(&self, f: F) -> Grid2d<R>

where F: FnMut(usize, usize, &T) -> R, R: Clone + Send + Sync,

pub fn with<F>(&mut self, f: F)

where F: FnMut(usize, usize, &T) -> T,

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

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

pub fn iter_view( &self, range: Range<(usize, usize)>, ) -> impl DoubleEndedIterator<Item = (usize, usize, &T)>

pub fn iter_view_mut( &mut self, range: Range<(usize, usize)>, ) -> impl DoubleEndedIterator<Item = (usize, usize, &mut T)>

pub fn iter_sample( &self, range: Range<(usize, usize)>, margin: usize, ) -> impl DoubleEndedIterator<Item = (usize, usize, Grid2d<&T>)> + '_

pub fn neighbor_sample( &self, (col, row): (usize, usize), ) -> Grid2dNeighborSample<T>

where T: Default + Copy,

pub fn windows( &self, (cols, rows): (usize, usize), ) -> impl DoubleEndedIterator<Item = Grid2d<&T>>

pub fn windows_seamless( &self, (cols, rows): (usize, usize), ) -> impl DoubleEndedIterator<Item = Grid2d<&T>>

pub fn into_inner(self) -> (usize, usize, Vec<T>)

pub fn from_view(view: &Grid2d<&T>) -> Self

pub fn get_common_areas( first_size: (usize, usize), second_size: (usize, usize), second_offset: (usize, usize), ) -> Option<Grid2dCommonAreas>

pub fn access_decoupled<'a>( &'a self, read: &[(usize, usize)], write: &[(usize, usize)], reads: &mut [&'a T], writes: &mut [&'a mut T], ) -> Result<(), Grid2dError>

pub unsafe fn access_decoupled_unsafe<'a>( &'a self, read: &[(usize, usize)], write: &[(usize, usize)], reads: &mut [&'a T], writes: &mut [&'a mut T], ) -> Result<(), Grid2dError>

impl<T> Grid2d<T>

where T: Clone + Send + Sync + PartialEq,

pub fn has_union_with( &self, other: &Self, offset_col: usize, offset_row: usize, ) -> bool

Trait Implementations

impl<T> Add for &Grid2d<T>

where T: Clone + Send + Sync + Add<Output = T>,

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the + operator.

fn add(self, other: &Grid2d<T>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for Grid2d<T>

fn clone(&self) -> Grid2d<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Grid2d<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Grid2d<T>

fn default() -> Grid2d<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Grid2d<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div for &Grid2d<T>

where T: Clone + Send + Sync + Div<Output = T>,

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the / operator.

fn div(self, other: &Grid2d<T>) -> Self::Output

Performs the / operation.

impl<I, T> From<(usize, I)> for Grid2d<T>

where I: Iterator<Item = T>, T: Clone + Send + Sync,

fn from((cols, iter): (usize, I)) -> Self

Converts to this type from the input type.

impl<T> From<Grid2d<T>> for (usize, usize, Vec<T>)

where T: Clone + Send + Sync,

fn from(v: Grid2d<T>) -> Self

Converts to this type from the input type.

impl<T> From<Grid2d<T>> for Vec<T>

fn from(v: Grid2d<T>) -> Self

Converts to this type from the input type.

impl<T> Index<[usize; 2]> for Grid2d<T>

where T: Clone + Send + Sync,

type Output = T

The returned type after indexing.

fn index(&self, [col, row]: [usize; 2]) -> &T

Performs the indexing (container[index]) operation.

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

where T: Clone + Send + Sync,

type Output = T

The returned type after indexing.

fn index(&self, (col, row): (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<[usize; 2]> for Grid2d<T>

where T: Clone + Send + Sync,

fn index_mut(&mut self, [col, row]: [usize; 2]) -> &mut T

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

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

where T: Clone + Send + Sync,

fn index_mut(&mut self, (col, row): (usize, usize)) -> &mut T

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

impl<T> IntoIterator for Grid2d<T>

where T: Clone + Send + Sync,

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> Mul for &Grid2d<T>

where T: Clone + Send + Sync + Mul<Output = T>,

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the * operator.

fn mul(self, other: &Grid2d<T>) -> Self::Output

Performs the * operation.

impl<T> Neg for &Grid2d<T>

where T: Clone + Send + Sync + Neg<Output = T>,

type Output = Grid2d<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> PartialEq for Grid2d<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Grid2d<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub for &Grid2d<T>

where T: Clone + Send + Sync + Sub<Output = T>,

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the - operator.

fn sub(self, other: &Grid2d<T>) -> Self::Output

Performs the - operation.