Struct DynamicGrid

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

A row-major 2d grid

Implementations

impl<T> DynamicGrid<T>

where T: Default,

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

Create a new grid of the given size, with each cells being initialized with the default value of T

impl<T> DynamicGrid<T>

pub fn new() -> Self

Create a new empty grid

Use Self::push_row to add content

pub fn new_with_capacity(capacity: usize) -> Self

Create a new empty grid with pre-allocated capacity cells

Use Self::push_row to add content

pub fn new_with( width: usize, height: usize, init: impl FnMut(usize, usize) -> T, ) -> Self

Create a new grid of the given size, with each cells being initialized with the given function

pub fn new_from_iter( width: usize, iter: impl IntoIterator<Item = T>, ) -> Result<Self, IncompatibleRowSize>

Create a new grid of the given width and row-major iterator

The given iterator must emits cells by row first, then by column

Errors

Returns IncompatibleRowSize if the number of elements yielded by the iterator is not compaible with the given width

Example

let grid = DynamicGrid::new_from_iter(2, [1, 2, 3, 4]).unwrap();
assert_eq!(grid.get(0, 0), Some(&1));
assert_eq!(grid.get(1, 0), Some(&2));
assert_eq!(grid.get(0, 1), Some(&3));
assert_eq!(grid.get(1, 1), Some(&4));

pub fn push_row( &mut self, row: impl IntoIterator<Item = T>, ) -> Result<(), IncompatibleRowSize>

Push a row to the grid

If the grid is not empty, the row length should match the current width of the grid.

Errors

Returns IncompatibleRowSize if the grid is not empty and the length of the added row does not match the current width of the grid.

pub fn is_empty(&self) -> bool

Returns true if the grid is empty

pub fn width(&self) -> usize

Returns the width of the grid

pub fn height(&self) -> usize

Returns the height of the grid

pub fn get(&self, x: usize, y: usize) -> Option<&T>

Get a reference to the cell at col x and row y

Returns None if x and y are out of bounds

pub fn get_mut(&mut self, x: usize, y: usize) -> Option<&mut T>

Get a mutable reference to the cell at col x and row y

Returns None if x and y are out of bounds

pub fn set(&mut self, x: usize, y: usize, new_value: T) -> Option<T>

Set the new value to the cell at col x and row y and return the old value.

Returns None if x and y are out of bounds

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

Returns an iterator over the cells

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

Returns a mutable iterator over the cells

pub fn cells_with_coords( &self, ) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)>

Returns an iterator over the cells with their corresponding coordinate

pub fn cells_with_coords_mut( &mut self, ) -> impl DoubleEndedIterator<Item = ((usize, usize), &mut T)>

Returns an mutable iterator over the cells with their corresponding coordinate

pub fn cells_in_rect( &self, x: usize, y: usize, width: usize, height: usize, ) -> impl DoubleEndedIterator<Item = &T>

Returns an iterator over the cells in the rectangle that start at col x, row y and of size given by width and height

Example

let grid = DynamicGrid::new_with(5, 5, |x, y| (x, y));
let in_rect: Vec<_> = grid.cells_in_rect(2, 2, 2, 2).copied().collect();
assert_eq!(in_rect, &[(2, 2), (3, 2), (2, 3), (3, 3)]);

pub fn rows(&self) -> impl DoubleEndedIterator<Item = &[T]>

Returns an iterator over the rows

Trait Implementations

impl<T: Clone> Clone for DynamicGrid<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for DynamicGrid<T>

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

Formats the value using the given formatter.

impl<T> Default for DynamicGrid<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PartialEq> PartialEq for DynamicGrid<T>

fn eq(&self, other: &DynamicGrid<T>) -> 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: Eq> Eq for DynamicGrid<T>

impl<T> StructuralPartialEq for DynamicGrid<T>