Struct board::Vec2d

pub struct Vec2d<T: Clone> { /* fields omitted */ }

Implementations

impl<T: Clone> Vec2d<T>

pub fn new(
    default: T,
    width: usize,
    height: usize
) -> Result<Vec2d<T>, Vec2dError>

Create a new Vec2d

Examples

let board = board::Vec2d::new('a', 2, 3).unwrap();
assert_eq!(board.tiles(), &vec!['a','a','a','a','a','a']);
assert_eq!(board.width(), 2);
assert_eq!(board.height(), 3);

pub fn new_from_vec(input: Vec<T>, width: usize) -> Result<Vec2d<T>, Vec2dError>

Create a new Vec2d from an existing Vec. Moves the original vec into a Vec2d without copying/cloning.

Examples

let vec = vec!['a','b','c','d'];
let board = board::Vec2d::new_from_vec(vec, 2).unwrap();
assert_eq!(board[(1,0)], 'b');
let vec = vec!['a','b','c','d'];
let board = board::Vec2d::new_from_vec(vec, 3);
assert!(board.is_err());

pub fn for_each_tile<F: FnMut(&mut T)>(&mut self, fun: F)

Apply a function to each tile in Vec2d

Examples

let mut board = board::Vec2d::new('a', 2, 3).unwrap();
board.for_each_tile(|tile| *tile = 'b' );
assert_eq!(board.tiles(), &vec!['b','b','b','b','b','b']);

pub fn tiles(&self) -> &Vec<T>

Get a &Vec<Tile> of the Vec2d<Tile>

pub fn height(&self) -> usize

Get the height of the Vec2d

pub fn width(&self) -> usize

Get the width of the Vec2d

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

Get an Option<&Tile> at (x, y)

Examples

let mut board = board::Vec2d::new('a', 2, 3).unwrap();
assert_eq!(board.get(0, 0), Some(&'a'));
assert_eq!(board.get(1, 2), Some(&'a'));
assert_eq!(board.get(2, 2), None);

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

Get an Option<&mut Tile> at (x, y)

Examples

let mut board = board::Vec2d::new('a', 2, 3).unwrap();
assert_eq!(board.get_mut(0, 0), Some(&mut 'a'));
assert_eq!(board.get_mut(1, 2), Some(&mut 'a'));
assert_eq!(board.get_mut(2, 2), None);

pub fn get_row(&self, y: usize) -> Option<&[T]>

pub fn get_row_mut(&mut self, y: usize) -> Option<&mut [T]>

pub fn iter_xy(
    &self
) -> impl Iterator<Item = (usize, impl Iterator<Item = usize>)>

Get an iterator over all (x, y) values: Iterator<Item = (usize, Iterator<Item = usize>)>

Examples

let board = board::Vec2d::new('a', 2, 3).unwrap();
for (x, row) in board.iter_xy() {
    for y in row {
        assert_eq!(board[(x, y)], 'a')
    }
}

pub fn iter_rows(&self) -> impl Iterator<Item = &[T]>

pub fn iter_rows_mut(&mut self) -> impl Iterator<Item = &mut [T]>

pub fn iter_with_pos<'a>(&'a self) -> impl Iterator<Item = (Pos, &T)>

Iterate over: ((x, y), &Tile)

Examples

let board = board::Vec2d::new(&'a', 2, 2).unwrap();
assert!(
    board.clone().iter_with_pos()
    .all(|((x, y), tile)| board[(x, y)] == *tile )
);

pub fn iter_with_pos_mut<'a>(
    &'a mut self
) -> impl Iterator<Item = (Pos, &'a mut T)>

Iterate over: ((x, y), &mut Tile)

Examples

let board = board::Vec2d::new(&'a', 2, 2).unwrap();
assert!(
    board.clone().iter_with_pos()
    .all(|((x, y), tile)| board[(x, y)] == *tile )
);

pub fn to_vec(self) -> Vec<T>

Consumes self to return the original Vec

Examples

let vec = vec!['a','b','c','d'];
let board = board::Vec2d::new_from_vec(vec.clone(), 2).unwrap();
let new_vec = board.to_vec();
assert_eq!(vec, new_vec);

Trait Implementations

impl<T: Clone> Clone for Vec2d<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone> Debug for Vec2d<T>

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

Formats the value using the given formatter.

impl<'de, T: Clone> Deserialize<'de> for Vec2d<T> where
    T: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Eq + Clone> Eq for Vec2d<T>

impl<T: Hash + Clone> Hash for Vec2d<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: Clone> Index<(usize, usize)> for Vec2d<T>

type Output = T

The returned type after indexing.

pub fn index(&self, (x, y): Pos) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Clone> IndexMut<(usize, usize)> for Vec2d<T>

pub fn index_mut(&mut self, (x, y): Pos) -> &mut Self::Output

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

impl<T: PartialEq + Clone> PartialEq<Vec2d<T>> for Vec2d<T>

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

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

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

This method tests for !=.

impl<T: Clone> Serialize for Vec2d<T> where
    T: Serialize, 

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: Clone> StructuralEq for Vec2d<T>

impl<T: Clone> StructuralPartialEq for Vec2d<T>