Struct simple_grid::Grid

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

A two-dimensional array, indexed with x-and-y-coordinates (columns and rows).

Implementations

impl<T> Grid<T>

pub fn new(width: usize, height: usize, data: Vec<T>) -> Self

Construct a new Grid.

Panics

• If width * height != data.len()

Example

// construct a 2x3 (width x height) grid of chars
let grid = Grid::new(2, 3, "abcdef".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d
// e f

pub fn width(&self) -> usize

Returns the width (number of columns) of the grid.

pub fn height(&self) -> usize

Returns the height (number of rows) of the grid.

pub fn area(&self) -> usize

Returns the area (number of columns * number of rows) of the grid.

pub fn get<I>(&self, idx: I) -> Option<&T> where
    GridIndex: From<I>, 

Attempts to get a reference to the element at idx.

Returns None if idx is out of bounds.

pub fn get_mut<I>(&mut self, idx: I) -> Option<&mut T> where
    GridIndex: From<I>, 

Attempts to get a mutable reference to the element at idx

Returns None if idx is out of bounds

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

Return an iterator over the cells in the grid.

Goes from left->right, top->bottom.

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

Return an iterator over the columns in the row with index row.

Panics

• If row >= self.height()

Example

let grid = Grid::new(10, 10, (1..=100).collect());
let items_in_row_2: Vec<u32> = grid.row_iter(2).cloned().collect();
assert_eq!(items_in_row_2, vec![21, 22, 23, 24, 25, 26, 27, 28, 29, 30]);

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

Return an iterator over the rows in the column with index column.

Panics

• If column >= self.width()

Example

let grid = Grid::new(10, 10, (1..=100).collect());
let items_in_column_2: Vec<u32> = grid.column_iter(2).cloned().collect();
assert_eq!(items_in_column_2, vec![3, 13, 23, 33, 43, 53, 63, 73, 83, 93]);

pub fn insert_row(&mut self, row: usize, row_contents: Vec<T>)

Insert a row at index row, shifting all other rows downward (row n becomes row n+1 and so on).

Panics

• If row_contents.is_empty()
• If row_contents.len() != self.width()
• If row >= self.height()

Example

let mut grid = Grid::new(2, 2, "abcd".chars().collect());
grid.insert_row(1, "xx".chars().collect());
assert_eq!(grid, Grid::new(2, 3, "abxxcd".chars().collect()));
println!("{}", grid);
// prints:
// a b
// x x
// c d

pub fn remove_row(&mut self, row: usize)

Remove row at row, shifting all rows with higher indices "upward" (row n becomes row n-1).

Panics

• If row >= self.height()

Example

let mut grid = Grid::new(2, 2, "abcd".chars().collect());
grid.remove_row(1);
assert_eq!(grid, Grid::new(2, 1, "ab".chars().collect()));
println!("{}", grid);
// prints:
// a b

pub fn insert_column(&mut self, column: usize, column_contents: Vec<T>)

Insert a column at index column, shifting all other columns to the right (column n becomes column n+1 and so on).

Panics

• If column_contents.is_empty()
• If column_contents.len() != self.height()
• If column >= self.width()

Example

let mut grid = Grid::new(2, 2, "abcd".chars().collect());
grid.insert_column(1, "xx".chars().collect());
assert_eq!(grid, Grid::new(3, 2, "axbcxd".chars().collect()));
println!("{}", grid);
// prints:
// a x b
// c x d

pub fn remove_column(&mut self, column: usize)

Remove column at column, shifting all columns with higher indices "left" (column n becomes column n-1).

Panics

• If column >= self.width()

Example

let mut grid = Grid::new(2, 2, "abcd".chars().collect());
grid.remove_column(1);
assert_eq!(grid, Grid::new(1, 2, "ac".chars().collect()));
println!("{}", grid);
// prints:
// a
// c

impl<T> Grid<T> where
    T: Clone, 

pub fn rotate_cw(&self) -> Self

Rotate the grid clockwise 90 degrees, cloning the data into a new grid.

Example

let grid = Grid::new(2, 2, "abcd".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d

let cw = grid.rotate_cw();
assert_eq!(cw, Grid::new(2, 2, "cadb".chars().collect()));
println!("{}", cw);
// prints:
// c a
// d b

pub fn rotate_ccw(&self) -> Self

Rotate the grid counter-clockwise 90 degrees, cloning the data into a new grid.

Example

let grid = Grid::new(2, 2, "abcd".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d

let ccw = grid.rotate_ccw();
assert_eq!(ccw, Grid::new(2, 2, "bdac".chars().collect()));
println!("{}", ccw);
// prints:
// b d
// a c

pub fn flip_horizontally(&self) -> Self

Flip the grid horizontally, so that the first column becomes the last.

Example

let grid = Grid::new(2, 2, "abcd".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d

let hori = grid.flip_horizontally();
assert_eq!(hori, Grid::new(2, 2, "badc".chars().collect()));
println!("{}", hori);
// prints:
// b a
// d c

pub fn flip_vertically(&self) -> Self

Flip the grid vertically, so that the first row becomes the last.

Example

let grid = Grid::new(2, 2, "abcd".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d

let vert = grid.flip_vertically();
assert_eq!(vert, Grid::new(2, 2, "cdab".chars().collect()));
println!("{}", vert);
// prints:
// c d
// a b

pub fn transpose(&self) -> Self

Transpose the grid along the diagonal, so that cells at index (x, y) end up at index (y, x).

Example

let grid = Grid::new(2, 3, "abcdef".chars().collect());
println!("{}", grid);
// prints:
// a b
// c d
// e f

let transposed = grid.transpose();
assert_eq!(transposed, Grid::new(3, 2, "acebdf".chars().collect()));
println!("{}", transposed);
// prints:
// a c e
// b d f

impl<T> Grid<T> where
    T: Default, 

pub fn new_default(width: usize, height: usize) -> Grid<T>

Create a grid filled with default values.

impl<T> Grid<T> where
    T: PartialEq, 

pub fn contains(&self, value: &T) -> bool

Returns true if the grid contains some element equal to value.

Example

let grid = Grid::new(2, 2, "abcd".chars().collect());
assert!(grid.contains(&'a'));
assert!(!grid.contains(&'e'));

Trait Implementations

impl<T: Clone> Clone for Grid<T>

pub fn clone(&self) -> Grid<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Grid<T>

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

Formats the value using the given formatter.

impl<T> Display for Grid<T> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Grid<T>

impl<T: Hash> Hash for Grid<T>

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, I> Index<I> for Grid<T> where
    GridIndex: From<I>, 

type Output = T

The returned type after indexing.

pub fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I> IndexMut<I> for Grid<T> where
    GridIndex: From<I>, 

pub fn index_mut(&mut self, index: I) -> &mut Self::Output

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

impl<T> IntoIterator for Grid<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for Grid<T>

pub fn cmp(&self, other: &Grid<T>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<Grid<T>> for Grid<T>

pub fn eq(&self, other: &Grid<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Grid<T>) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Grid<T>> for Grid<T>

pub fn partial_cmp(&self, other: &Grid<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Grid<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Grid<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Grid<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Grid<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> StructuralEq for Grid<T>

impl<T> StructuralPartialEq for Grid<T>