[−][src]Struct grid::Grid
Stores elements of a certain type in a 2D grid structure.
Uses a rust Vec<T>
type to reference the grid data on the heap.
Also the number of rows and columns are stored in the grid data structure.
The grid data is stored in a row-major memory layout.
Methods
impl<T: Clone> Grid<T>
[src]
pub fn new(rows: usize, cols: usize) -> Grid<T> where
T: Default,
[src]
T: Default,
Init a grid of size rows x columns with default values of the given type. For example this will generate a 2x3 grid of zeros:
use grid::Grid; let grid : Grid<u8> = Grid::new(2,2); assert_eq!(grid[0][0], 0);
pub fn init(rows: usize, cols: usize, data: T) -> Grid<T>
[src]
Init a grid of size rows x columns with the given data element.
pub fn from_vec(vec: Vec<T>, cols: usize) -> Grid<T>
[src]
Returns a grid from a vector with a given column length.
The length of vec
must be a multiple of cols
.
For example:
use grid::Grid; let grid = Grid::from_vec(vec![1,2,3,4,5,6], 3); assert_eq!(grid.size(), (2, 3));
will create a grid with the following layout: [1,2,3] [4,5,6]
This example will fail, because vec.len()
is not a multiple of cols
:
use grid::Grid; Grid::from_vec(vec![1,2,3,4,5], 3);
pub unsafe fn get_unchecked(&self, row: usize, col: usize) -> &T
[src]
Returns a reference to an element, without performing bound checks. Generally not recommended, use with caution! Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.
pub unsafe fn get_unchecked_mut(&mut self, row: usize, col: usize) -> &mut T
[src]
Returns a mutable reference to an element, without performing bound checks. Generally not recommended, use with caution! Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.
pub fn get(&self, row: usize, col: usize) -> Option<&T>
[src]
Access a certain element in the grid. Returns None if an element beyond the grid bounds is tried to be accessed.
pub fn get_mut(&mut self, row: usize, col: usize) -> Option<&mut T>
[src]
Mutable access to a certain element in the grid. Returns None if an element beyond the grid bounds is tried to be accessed.
pub fn size(&self) -> (usize, usize)
[src]
Returns the size of the gird as a two element tuple. First element are the number of rows and the second the columns.
pub fn rows(&self) -> usize
[src]
Returns the number of rows of the grid.
pub fn cols(&self) -> usize
[src]
Returns the number of columns of the grid.
pub fn is_empty(&self) -> bool
[src]
Returns true if the grid contains no elements. For example:
use grid::*; let grid : Grid<u8> = grid![]; assert!(grid.is_empty());
pub fn clear(&mut self)
[src]
Clears the grid.
pub fn iter(&self) -> Iter<T>
[src]
Returns an iterator over the whole grid, starting from the first row and column.
use grid::*; let grid: Grid<u8> = grid![[1,2][3,4]]; let mut iter = grid.iter(); assert_eq!(iter.next(), Some(&1)); assert_eq!(iter.next(), Some(&2)); assert_eq!(iter.next(), Some(&3)); assert_eq!(iter.next(), Some(&4)); assert_eq!(iter.next(), None);
pub fn iter_mut(&mut self) -> IterMut<T>
[src]
Returns an mutable iterator over the whole grid that allows modifying each value.
use grid::*; let mut grid: Grid<u8> = grid![[1,2][3,4]]; let mut iter = grid.iter_mut(); let next = iter.next(); assert_eq!(next, Some(&mut 1)); *next.unwrap() = 10;
pub fn iter_col(&self, col: usize) -> StepBy<Iter<T>>
[src]
Returns an iterator over a column.
Examples
use grid::*; let grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let mut col_iter = grid.iter_col(1); assert_eq!(col_iter.next(), Some(&2)); assert_eq!(col_iter.next(), Some(&4)); assert_eq!(col_iter.next(), None);
Panics
Panics if the col index is out of bounds.
pub fn iter_col_mut(&mut self, col: usize) -> StepBy<IterMut<T>>
[src]
Returns a mutable iterator over a column.
Examples
use grid::*; let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let mut col_iter = grid.iter_col_mut(1); let next = col_iter.next(); assert_eq!(next, Some(&mut 2)); *next.unwrap() = 10; assert_eq!(grid[0][1], 10);
Panics
Panics if the col index is out of bounds.
pub fn iter_row(&self, row: usize) -> Iter<T>
[src]
Returns an iterator over a row.
Examples
use grid::*; let grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let mut col_iter = grid.iter_row(1); assert_eq!(col_iter.next(), Some(&3)); assert_eq!(col_iter.next(), Some(&4)); assert_eq!(col_iter.next(), Some(&5)); assert_eq!(col_iter.next(), None);
Panics
Panics if the row index is out of bounds.
pub fn iter_row_mut(&mut self, row: usize) -> IterMut<T>
[src]
Returns a mutable iterator over a row.
Examples
use grid::*; let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let mut col_iter = grid.iter_row_mut(1); let next = col_iter.next(); *next.unwrap() = 10; assert_eq!(grid[1][0], 10);
Panics
Panics if the row index is out of bounds.
pub fn push_row(&mut self, row: Vec<T>)
[src]
Add a new row to the grid.
Examples
use grid::*; let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let row = vec![6,7,8]; grid.push_row(row); assert_eq!(grid.rows(), 3); assert_eq!(grid[2][0], 6); assert_eq!(grid[2][1], 7); assert_eq!(grid[2][2], 8);
Can also be used to init an empty grid:
use grid::*; let mut grid: Grid<u8> = grid![]; let row = vec![1,2,3]; grid.push_row(row); assert_eq!(grid.size(), (1, 3));
Panics
Panics if the grid is not empty and row.len() != grid.cols()
.
pub fn push_col(&mut self, col: Vec<T>)
[src]
Add a new column to the grid.
Important:
Please note that Grid
uses a Row-Major memory layout. Therefore, the push_col()
operation requires quite a lot of memory shifting and will be significantly slower compared
to a push_row()
operation.
Examples
use grid::*; let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]]; let col = vec![4,6]; grid.push_col(col); assert_eq!(grid.cols(), 4); assert_eq!(grid[0][3], 4); assert_eq!(grid[1][3], 6);
Can also be used to init an empty grid:
use grid::*; let mut grid: Grid<u8> = grid![]; let col = vec![1,2,3]; grid.push_col(col); assert_eq!(grid.size(), (3, 1));
Panics
Panics if the grid is not empty and col.len() != grid.rows()
.
pub fn pop_row(&mut self) -> Option<Vec<T>>
[src]
Removes the last row from a grid and returns it, or None if it is empty.
Examples
use grid::*; let mut grid = grid![[1,2,3][4,5,6]]; assert_eq![grid.pop_row(), Some(vec![4,5,6])]; assert_eq![grid.pop_row(), Some(vec![1,2,3])]; assert_eq![grid.pop_row(), None];
pub fn pop_col(&mut self) -> Option<Vec<T>>
[src]
Removes the last column from a grid and returns it, or None if it is empty.
Note that this operation is much slower than the pop_row()
because the memory layout
of Grid
is row-major and removing a column requires a lot of move operations.
Examples
use grid::*; let mut grid = grid![[1,2,3][4,5,6]]; assert_eq![grid.pop_col(), Some(vec![3,6])]; assert_eq![grid.pop_col(), Some(vec![2,5])]; assert_eq![grid.pop_col(), Some(vec![1,4])]; assert_eq![grid.pop_col(), None];
pub fn insert_row(&mut self, index: usize, row: Vec<T>)
[src]
Insert a new row at the index and shifts all rows after down.
Examples
use grid::*; let mut grid = grid![[1,2,3][4,5,6]]; grid.insert_row(1, vec![7,8,9]); assert_eq!(grid[0], [1,2,3]); assert_eq!(grid[1], [7,8,9]); assert_eq!(grid[2], [4,5,6]); assert_eq!(grid.size(), (3,3))
pub fn insert_col(&mut self, index: usize, col: Vec<T>)
[src]
Insert a new column at the index.
Important! Insertion of columns is a lot slower than the lines insertion. This is because of the memory layout of the grid data structure.
Examples
use grid::*; let mut grid = grid![[1,2,3][4,5,6]]; grid.insert_col(1, vec![9,9]); assert_eq!(grid[0], [1,9,2,3]); assert_eq!(grid[1], [4,9,5,6]); assert_eq!(grid.size(), (2,4))
pub fn flatten(&self) -> &Vec<T>
[src]
Returns a reference to the internal data structure of the grid.
Grid uses a row major layout. All rows are placed right after each other in the vector data structure.
Examples
use grid::*; let grid = grid![[1,2,3][4,5,6]]; let flat = grid.flatten(); assert_eq!(flat, &vec![1,2,3,4,5,6]);
Trait Implementations
impl<T: Clone> Clone for Grid<T>
[src]
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Debug> Debug for Grid<T>
[src]
impl<T: Eq> Eq for Grid<T>
[src]
impl<T: Clone> Index<usize> for Grid<T>
[src]
type Output = [T]
The returned type after indexing.
fn index(&self, idx: usize) -> &Self::Output
[src]
impl<T: Clone> IndexMut<usize> for Grid<T>
[src]
impl<T: Eq> PartialEq<Grid<T>> for Grid<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for Grid<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Grid<T> where
T: Send,
T: Send,
impl<T> Sync for Grid<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Grid<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Grid<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,