Struct das_grid::Grid

pub struct Grid<T: Copy + Clone> { /* fields omitted */ }

Stores the grid values and the cells The grid itself representation is a flatten vector which is transformed for 2D representation when called by the user

The cells are internally manage by a Vec<T>

So to create a grid with 4x4 (collums and rows)

let grid = das_grid::Grid::new(4, 4, 0);
assert_eq!(grid.size(), 16);

Or if you like let’s say a Tetris style grid

let grid = das_grid::Grid::new(10, 20, 0);

// And it will have 200 cells!
assert_eq!(grid.size(), 200);

Implementations

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

pub fn new(width: i32, height: i32, value: T) -> Self where
    T: Clone + Copy + Display, 

Creates a grid of size rows x columns with default value passed on the third parameter For example this will generate a 2x2 grid of value 1:

let grid = das_grid::Grid::new(2, 2, 1);
assert_eq!(grid.size(), 4);

pub fn set(&mut self, index: (i32, i32), value: &T) -> Result<(), OutOfGridErr> where
    T: Copy, 

Sets a given value to the position (x, y)

Be careful if the value is out of the bounds of grid it will return an error with the type of OutOfGridErr

let mut grid = das_grid::Grid::new(2, 2, 1);
assert!(grid.set((0, 0), &1).is_ok());

pub fn get_mut(&mut self, index: (i32, i32)) -> Result<&mut T, OutOfGridErr>

Gets a give value to the position (x, y) as mutable

Be careful if the value is out of the bounds of grid it will return an error with the type of OutOfGridErr

let mut grid = das_grid::Grid::new(2, 2, 1);
let mut v = grid.get_mut((0, 0)).expect("cannnot get pos at (0, 0)");
*v = 50;
assert_eq!(grid.get((0, 0)).unwrap_or(&0), &50);

pub fn get(&self, index: (i32, i32)) -> Result<&T, OutOfGridErr>

Gets a give value to the position (x, y)

Be careful if the value is out of the bounds of grid it will return an error with the type of OutOfGridErr

let grid = das_grid::Grid::new(2, 2, 1);
let v = grid.get((0, 0));
assert_eq!(v, Ok(&1));

pub fn mov(
    &mut self,
    index: (i32, i32),
    dest: (i32, i32)
) -> Result<(), OutOfGridErr>

Moves a given value from position (x, y) to destiny position (x, y)

Be careful if the value is out of the bounds of grid it will return an error with the type of OutOfGridErr

let mut grid = das_grid::Grid::new(2, 2, 1);
assert_eq!(grid.mov((0, 0), (1, 1)), Ok(()));

pub fn mov_to(
    &mut self,
    index: (i32, i32),
    direction: MoveDirection
) -> Result<(), OutOfGridErr>

Moves a given value from position (x, y) to another position based on the direction

The directions can be Left, Right, Top, Down:

• DasGrid::MoveDirection::Left, translates to (-1, 0)
• DasGrid::MoveDirection::Right, translates to (1, 0)
• DasGrid::MoveDirection::Top, translates to (0, -1)
• DasGrid::MoveDirection::Down, translates to (0, 1)

Be careful if the value is out of the bounds of grid it will return an error with the type of OutOfGridErr

let mut grid = das_grid::Grid::new(2, 2, 1);
assert_eq!(grid.mov_to((0, 0), das_grid::MoveDirection::Right), Ok(()));

pub fn size(&self) -> usize

Get the size of grid based on cells length

For instance a 10x10 grid will return the size of 100

let mut grid = das_grid::Grid::new(2, 2, 1);
assert_eq!(grid.size(), 4);

pub fn width(&self) -> i32

The width of the grid

let mut grid = das_grid::Grid::new(3, 2, 1);
assert_eq!(grid.width(), 3);

pub fn height(&self) -> i32

The height of the grid

let mut grid = das_grid::Grid::new(3, 2, 1);
assert_eq!(grid.height(), 2);

pub fn enumerate(&self) -> Vec<(i32, i32)>

Returns the grid as a tuple of (x, y)

let mut grid = das_grid::Grid::new(3, 2, 1);
for (x, y) in grid.enumerate() {
    println!("x {} y {}", x, y);
}

Trait Implementations

impl<T: Copy + Clone + Display> Debug for Grid<T>

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

Formats the value using the given formatter.

impl<T: Copy + Clone> Display for Grid<T>

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

Formats the value using the given formatter.

impl<T: Copy + Clone> Index<(i32, i32)> for Grid<T>

type Output = T

The returned type after indexing.

fn index(&self, index: (i32, i32)) -> &T

Performs the indexing (container[index]) operation.

impl<T: Copy + Clone> IndexMut<(i32, i32)> for Grid<T>

fn index_mut(&mut self, index: (i32, i32)) -> &mut T

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

impl<'a, T: Copy + Clone> IntoIterator for &'a Grid<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: Copy + Clone> IntoIterator for &'a mut Grid<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.