Struct gridly_grids::VecGrid

pub struct VecGrid<T> { /* fields omitted */ }

A grid that stores its elements in a Vec<T>, in row-major order.

Methods

impl<T> VecGrid<T>

pub fn new_fill_with(
    dimensions: impl VectorLike,
    gen: impl Fn() -> T
) -> Option<Self>

Create a new VecGrid, filled with elements by repeatedly calling a function. The function is called once per cell in an unspecified order; use [new_with] if you want to have per-cell initialization logic.

Returns the grid, or None if the dimensions were invalid.

Example:

use gridly_grids::VecGrid;
use gridly::prelude::*;

let grid = VecGrid::new_fill_with((Rows(2), Columns(2)), || "Hello, World!".to_string()).unwrap();
assert_eq!(grid[(1, 0)], "Hello, World!")

See also [new] for filling a grid with a type's [default] value, and [new_fill] for filling a grid with a clone of a value.

pub fn new_with(
    dimensions: impl VectorLike,
    gen: impl FnMut(&Location) -> T
) -> Option<Self>

Create a new VecGrid by calling a function with the location of each cell in the grid, storing the return value of that function in that cell.

The function is called once per cell in an unspecified order; users should not rely on it being called in row-major order.

Returns the grid, or None if the dimensions were invalid.

Example:

use gridly_grids::VecGrid;
use gridly::prelude::*;

let grid = VecGrid::new_with((Rows(2), Columns(2)), |loc| loc.row.0 + loc.column.0).unwrap();
assert_eq!(grid.get((0, 0)), Ok(&0));
assert_eq!(grid.get((0, 1)), Ok(&1));
assert_eq!(grid.get((1, 0)), Ok(&1));
assert_eq!(grid.get((1, 1)), Ok(&2));
assert!(grid.get((1, 2)).is_err());

pub fn fill_with(&mut self, gen: impl Fn() -> T)

Fill every cell in the grid with the values produced by repeatedly calling gen. Called in an unspecified order.

Example

use gridly_grids::VecGrid;
use gridly::prelude::*;

let mut grid: VecGrid<isize> = VecGrid::new((Rows(2), Columns(2))).unwrap();

grid.fill_with(|| 3);
assert_eq!(grid.get((0, 0)), Ok(&3));
assert_eq!(grid.get((0, 1)), Ok(&3));
assert_eq!(grid.get((1, 0)), Ok(&3));
assert_eq!(grid.get((1, 1)), Ok(&3));
assert!(grid.get((1, 2)).is_err());

impl<T: Default> VecGrid<T>

pub fn new(dimensions: impl VectorLike) -> Option<Self>

Create a new VecGrid filled with the default value of T in each cell

Example

use gridly_grids::VecGrid;
use gridly::prelude::*;

let grid: VecGrid<isize> = VecGrid::new((Rows(2), Columns(2))).unwrap();
assert_eq!(grid.get((0, 0)), Ok(&0));
assert_eq!(grid.get((0, 1)), Ok(&0));
assert_eq!(grid.get((1, 0)), Ok(&0));
assert_eq!(grid.get((1, 1)), Ok(&0));
assert!(grid.get((1, 2)).is_err());

pub fn clear(&mut self)

Replace all the cells in the grid with the default value

Example

use gridly_grids::VecGrid;
use gridly::prelude::*;

let mut grid = VecGrid::new_fill((Rows(2), Columns(2)), &5).unwrap();
grid.clear();
assert_eq!(grid.get((0, 0)), Ok(&0));
assert_eq!(grid.get((0, 1)), Ok(&0));
assert_eq!(grid.get((1, 0)), Ok(&0));
assert_eq!(grid.get((1, 1)), Ok(&0));
assert!(grid.get((1, 2)).is_err());

impl<T: Clone> VecGrid<T>

pub fn new_fill(dimensions: impl VectorLike, value: &T) -> Option<Self>

Create a new VecGrid filled with clones of value

Example

use gridly_grids::VecGrid;
use gridly::prelude::*;

let grid = VecGrid::new_fill((Rows(2), Columns(2)), &"Hello").unwrap();
assert_eq!(grid.get((0, 0)), Ok(&"Hello"));
assert_eq!(grid.get((0, 1)), Ok(&"Hello"));
assert_eq!(grid.get((1, 0)), Ok(&"Hello"));
assert_eq!(grid.get((1, 1)), Ok(&"Hello"));
assert!(grid.get((1, 2)).is_err());

pub fn fill(&mut self, value: &T)

Fill every element in the grid with clones of value

Example

use gridly_grids::VecGrid;
use gridly::prelude::*;

let mut grid = VecGrid::new((Rows(2), Columns(2))).unwrap();

grid.fill(&"Hello");
assert_eq!(grid.get((0, 0)), Ok(&"Hello"));
assert_eq!(grid.get((0, 1)), Ok(&"Hello"));
assert_eq!(grid.get((1, 0)), Ok(&"Hello"));
assert_eq!(grid.get((1, 1)), Ok(&"Hello"));
assert!(grid.get((1, 2)).is_err());

Trait Implementations

impl<T: Clone> Clone for VecGrid<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, L: LocationLike> Index<L> for VecGrid<T>

type Output = T

The returned type after indexing.

fn index(&self, location: L) -> &T

Performs the indexing (container[index]) operation.

impl<T, L: LocationLike> IndexMut<L> for VecGrid<T>

fn index_mut(&mut self, location: L) -> &mut T

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

impl<T: Debug> Debug for VecGrid<T>

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

Formats the value using the given formatter.

impl<T> BaseGridBounds for VecGrid<T>

fn dimensions(&self) -> Vector

Get the dimensions of the grid, as a [Vector].

fn root(&self) -> Location

Return the root location (ie, the top left) of the grid. For most grids, this is (0, 0), but some grids may include negatively indexed locations, or even offsets. All valid locations have location >= root.

impl<T> BaseGridSetter for VecGrid<T>

unsafe fn replace_unchecked(&mut self, location: &Location, value: T) -> T

unsafe fn set_unchecked(&mut self, location: &Location, value: T)

impl<T> BaseGrid for VecGrid<T>

type Item = T

unsafe fn get_unchecked(&self, location: &Location) -> &T

Get a reference to a cell, without doing bounds checking. Implementors of this method are allowed to assume that bounds checking has already been performed on the location, which means that implementors are allowed to do their own unsafe get operations on the underlying storage, where relevant.

impl<T> BaseGridMut for VecGrid<T>

unsafe fn get_unchecked_mut(&mut self, location: &Location) -> &mut T