Struct Vecgrid

pub struct Vecgrid<T> { /* private fields */ }

A dynamically sized two-dimensional vec.

Implementations

impl<T> Vecgrid<T>

pub fn from_rows(rows: Vec<Vec<T>>) -> Result<Self, Error>

Creates a new Vecgrid from a Vec of rows, each of which is a Vec of elements.

Returns an error if the rows are not all the same size.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), rows);

pub fn from_columns(columns: Vec<Vec<T>>) -> Result<Self, Error>

where T: Clone,

Creates a new Vecgrid from a Vec of columns, each of which contains a Vec of elements.

Returns an error if the columns are not all the same size.

Examples

let columns = vec![vec![1, 4], vec![2, 5], vec![3, 6]];
let vecgrid = Vecgrid::from_columns(columns.clone())?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn from_row_major( elements: Vec<T>, num_rows: usize, num_columns: usize, ) -> Result<Self, Error>

Creates a new Vecgrid from the given flat Vec in row major order.

Returns an error if the number of elements in elements is not the product of num_rows and num_columns, i.e. the dimensions do not match.

Examples

let row_major = vec![1, 2, 3, 4, 5, 6];
let vecgrid = Vecgrid::from_row_major(row_major, 2, 3)?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn from_column_major( elements: Vec<T>, num_rows: usize, num_columns: usize, ) -> Result<Self, Error>

where T: Clone,

Creates a new Vecgrid from the given flat Vec in column major order.

Return an error if the number of elements in elements is not the product of num_rows and num_columns, i.e. the dimensions do not match.

Examples

let column_major = vec![1, 4, 2, 5, 3, 6];
let vecgrid = Vecgrid::from_column_major(column_major, 2, 3)?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn filled_with(element: T, num_rows: usize, num_columns: usize) -> Self

where T: Clone,

Creates a new Vecgrid with the specified number of rows and columns that contains element in every location.

Examples

let vecgrid = Vecgrid::filled_with(42, 2, 3);
assert_eq!(vecgrid.as_rows(), vec![vec![42, 42, 42], vec![42, 42, 42]]);

pub fn filled_by_row_major<F>( generator: F, num_rows: usize, num_columns: usize, ) -> Self

where F: FnMut() -> T,

Creates a new Vecgrid with the specified number of rows and columns and fills each element with the result of calling the given function. The function is called once for every location going in row major order.

Examples

let mut counter = 1;
let increment = || {
    let tmp = counter;
    counter += 1;
    tmp
};
let vecgrid = Vecgrid::filled_by_row_major(increment, 2, 3);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn filled_by_column_major<F>( generator: F, num_rows: usize, num_columns: usize, ) -> Self

where F: FnMut() -> T, T: Clone,

Creates a new Vecgrid with the specified number of rows and columns and fills each element with the result of calling the given function. The function is called once for every location going in column major order.

Examples

let mut counter = 1;
let increment = || {
    let tmp = counter;
    counter += 1;
    tmp
};
let vecgrid = Vecgrid::filled_by_column_major(increment, 2, 3);
assert_eq!(vecgrid.as_columns(), vec![vec![1, 2], vec![3, 4], vec![5, 6]]);

pub fn from_iter_row_major<I>( iterator: I, num_rows: usize, num_columns: usize, ) -> Result<Self, Error>

where I: Iterator<Item = T>,

Creates a new Vecgrid with the specified number of rows and columns and fills each element with the elements produced from the provided iterator. If the iterator produces more than enough elements, the remaining are unused. Returns an error if the iterator does not produce enough elements.

The elements are inserted into the vecgrid in row major order.

Examples

let iterator = (1..);
let vecgrid = Vecgrid::from_iter_row_major(iterator, 2, 3)?;
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn from_iter_column_major<I>( iterator: I, num_rows: usize, num_columns: usize, ) -> Result<Self, Error>

where I: Iterator<Item = T>, T: Clone,

Creates a new Vecgrid with the specified number of rows and columns and fills each element with the elements produced from the provided iterator. If the iterator produces more than enough elements, the remaining are unused. Returns an error if the iterator does not produce enough elements.

The elements are inserted into the vecgrid in column major order.

Examples

let iterator = (1..);
let vecgrid = Vecgrid::from_iter_column_major(iterator, 2, 3)?;
assert_eq!(vecgrid.as_rows(), vec![vec![1, 3, 5], vec![2, 4, 6]]);

pub fn num_rows(&self) -> usize

The number of rows.

pub fn num_columns(&self) -> usize

The number of columns.

pub fn num_elements(&self) -> usize

The total number of elements, i.e. the product of num_rows and num_columns.

pub fn row_len(&self) -> usize

The number of elements in each row, i.e. the number of columns.

pub fn column_len(&self) -> usize

The number of elements in each column, i.e. the number of rows.

pub fn get(&self, row: usize, column: usize) -> Option<&T>

Returns a reference to the element at the given row and column if the index is in bounds (wrapped in Some). Returns None if the index is out of bounds.

Examples

let vecgrid = Vecgrid::filled_with(42, 2, 3);
assert_eq!(vecgrid.get(0, 0), Some(&42));
assert_eq!(vecgrid.get(10, 10), None);

pub fn get_row_major(&self, index: usize) -> Option<&T>

Returns a reference to the element at the given index in row major order. Returns None if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_row_major(2), Some(&3));
assert_eq!(vecgrid.get_row_major(4), Some(&5));
assert_eq!(vecgrid.get_row_major(10), None);

pub fn get_column_major(&self, index: usize) -> Option<&T>

Returns a reference to the element at the given index in column major order. Returns None if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_column_major(2), Some(&2));
assert_eq!(vecgrid.get_column_major(4), Some(&3));
assert_eq!(vecgrid.get_column_major(10), None);

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

Returns a mutable reference to the element at the given row and column if the index is in bounds (wrapped in Some). Returns None if the index is out of bounds.

Examples

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);

assert_eq!(vecgrid.get_mut(0, 0), Some(&mut 42));
assert_eq!(vecgrid.get_mut(10, 10), None);

vecgrid.get_mut(0, 0).map(|x| *x = 100);
assert_eq!(vecgrid.get(0, 0), Some(&100));

vecgrid.get_mut(10, 10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);

pub fn get_mut_row_major(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at the given index in row major order. Returns None if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;

assert_eq!(vecgrid.get_mut_row_major(1), Some(&mut 2));
assert_eq!(vecgrid.get_mut_row_major(10), None);

vecgrid.get_mut_row_major(3).map(|x| *x = 100);
assert_eq!(vecgrid.get(1, 0), Some(&100));

vecgrid.get_mut_row_major(10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);

pub fn get_mut_column_major(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at the given index in row major order. Returns None if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;

assert_eq!(vecgrid.get_mut_column_major(1), Some(&mut 4));
assert_eq!(vecgrid.get_mut_column_major(10), None);

vecgrid.get_mut_column_major(4).map(|x| *x = 100);
assert_eq!(vecgrid.get(0, 2), Some(&100));

vecgrid.get_mut_column_major(10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);

pub fn set( &mut self, row: usize, column: usize, element: T, ) -> Result<(), Error>

Changes the element at given row and column to element. Returns Ok(()) if the indices were in bounds and returns an Err otherwise.

Examples

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);

let result = vecgrid.set(0, 0, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(0, 0), Some(&100));

let result = vecgrid.set(10, 20, 200);
assert_eq!(result, Err(Error::IndicesOutOfBounds(10, 20)));

pub fn set_row_major(&mut self, index: usize, element: T) -> Result<(), Error>

Changes the element at the given index to element, in row major order. Returns Ok(()) if the index is in bounds and returns an Err otherwise.

Examples

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);

let result = vecgrid.set_row_major(4, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(1, 1), Some(&100));

let result = vecgrid.set_row_major(10, 200);
assert_eq!(result, Err(Error::IndexOutOfBounds(10)));

pub fn set_column_major( &mut self, index: usize, element: T, ) -> Result<(), Error>

Changes the element at the given index to element, in column major order. Returns Ok(()) if the index is in bounds and returns an Err otherwise.

Examples

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);

let result = vecgrid.set_column_major(4, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(0, 2), Some(&100));

let result = vecgrid.set_column_major(10, 200);
assert_eq!(result, Err(Error::IndexOutOfBounds(10)));

pub fn elements_row_major_iter( &self, ) -> impl DoubleEndedIterator<Item = &T> + Clone

Returns an Iterator over references to all elements in row major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let elements = vec![1, 2, 3, 4, 5, 6];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let row_major = vecgrid.elements_row_major_iter();
assert_eq!(row_major.cloned().collect::<Vec<_>>(), elements);

pub fn elements_row_major_iter_mut( &mut self, ) -> impl DoubleEndedIterator<Item = &mut T>

Returns an Iterator over mutable references to all elements in row major order.

Examples

   let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
   let elements = vec![1, 2, 3, 4, 5, 6];
   let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
   let row_major = vecgrid.elements_row_major_iter_mut();
   for (i, val) in row_major
       .map(|val| {
           *val += 1;
           val
       })
       .enumerate()
   {
       assert_eq!(*val, elements[i] + 1);
   }

pub fn elements_column_major_iter( &self, ) -> impl DoubleEndedIterator<Item = &T> + Clone

Returns an Iterator over references to all elements in column major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let elements = vec![1, 4, 2, 5, 3, 6];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let column_major = vecgrid.elements_column_major_iter();
assert_eq!(column_major.cloned().collect::<Vec<_>>(), elements);

pub fn elements_column_major_iter_mut( &mut self, ) -> impl DoubleEndedIterator<Item = &mut T>

Returns an Iterator over mutable references to all elements in column major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let elements = vec![1, 4, 7, 2, 5, 8, 3, 6, 9];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let column_major = vecgrid.elements_column_major_iter_mut();
for (i, val) in column_major
    .map(|val| {
        *val += 1;
        val
    })
    .enumerate()
{
    assert_eq!(*val, elements[i] + 1);
}

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

Returns an Iterator over references to all elements in the given row. Returns an error if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut row_iter = vecgrid.row_iter(1)?;
assert_eq!(row_iter.next(), Some(&4));
assert_eq!(row_iter.next(), Some(&5));
assert_eq!(row_iter.next(), Some(&6));
assert_eq!(row_iter.next(), None);

pub fn row_iter_mut( &mut self, row_index: usize, ) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>

Returns an Iterator over mutable references to all elements in the given row. Returns an error if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut row_iter = vecgrid.row_iter_mut(1)?;
assert_eq!(row_iter.next(), Some(&mut 4));
assert_eq!(row_iter.next(), Some(&mut 5));
assert_eq!(row_iter.next(), Some(&mut 6));
assert_eq!(row_iter.next(), None);

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

Returns an Iterator over references to all elements in the given column. Returns an error if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut column_iter = vecgrid.column_iter(1)?;
assert_eq!(column_iter.next(), Some(&2));
assert_eq!(column_iter.next(), Some(&5));
assert_eq!(column_iter.next(), None);

pub fn column_iter_mut( &mut self, column_index: usize, ) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>

Returns an Iterator over mutable references to all elements in the given column. Returns an error if the index is out of bounds.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut column_iter = vecgrid.column_iter_mut(1)?;
assert_eq!(column_iter.next(), Some(&mut 2));
assert_eq!(column_iter.next(), Some(&mut 5));
assert_eq!(column_iter.next(), None);

pub fn rows_iter( &self, ) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone

Returns an Iterator over all rows. Each Item is itself another Iterator over references to the elements in that row.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
for row_iter in vecgrid.rows_iter() {
    for element in row_iter {
        print!("{} ", element);
    }
    println!();
}

let mut rows_iter = vecgrid.rows_iter();

let mut first_row_iter = rows_iter.next().unwrap();
assert_eq!(first_row_iter.next(), Some(&1));
assert_eq!(first_row_iter.next(), Some(&2));
assert_eq!(first_row_iter.next(), Some(&3));
assert_eq!(first_row_iter.next(), None);

let mut second_row_iter = rows_iter.next().unwrap();
assert_eq!(second_row_iter.next(), Some(&4));
assert_eq!(second_row_iter.next(), Some(&5));
assert_eq!(second_row_iter.next(), Some(&6));
assert_eq!(second_row_iter.next(), None);

assert!(rows_iter.next().is_none());

pub fn rows_iter_mut( &mut self, ) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>

Returns an Iterator over all rows. Each Item is itself another Iterator over mutable references to the elements in that row.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
for row_iter in vecgrid.rows_iter() {
    for element in row_iter {
        print!("{} ", element);
    }
    println!();
}

let mut rows_iter = vecgrid.rows_iter_mut();

let mut first_row_iter = rows_iter.next().unwrap();
assert_eq!(first_row_iter.next(), Some(&mut 1));
assert_eq!(first_row_iter.next(), Some(&mut 2));
assert_eq!(first_row_iter.next(), Some(&mut 3));
assert_eq!(first_row_iter.next(), None);

let mut second_row_iter = rows_iter.next().unwrap();
assert_eq!(second_row_iter.next(), Some(&mut 4));
assert_eq!(second_row_iter.next(), Some(&mut 5));
assert_eq!(second_row_iter.next(), Some(&mut 6));
assert_eq!(second_row_iter.next(), None);

assert!(rows_iter.next().is_none());

pub fn columns_iter( &self, ) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone

Returns an Iterator over all columns. Each Item is itself another Iterator over references to the elements in that column.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
for column_iter in vecgrid.columns_iter() {
    for element in column_iter {
        print!("{} ", element);
    }
    println!();
}

let mut columns_iter = vecgrid.columns_iter();

let mut first_column_iter = columns_iter.next().unwrap();
assert_eq!(first_column_iter.next(), Some(&1));
assert_eq!(first_column_iter.next(), Some(&4));
assert_eq!(first_column_iter.next(), None);

let mut second_column_iter = columns_iter.next().unwrap();
assert_eq!(second_column_iter.next(), Some(&2));
assert_eq!(second_column_iter.next(), Some(&5));
assert_eq!(second_column_iter.next(), None);

let mut third_column_iter = columns_iter.next().unwrap();
assert_eq!(third_column_iter.next(), Some(&3));
assert_eq!(third_column_iter.next(), Some(&6));
assert_eq!(third_column_iter.next(), None);

assert!(columns_iter.next().is_none());

pub fn columns_iter_mut( &mut self, ) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>

Returns an Iterator over all columns. Each Item is itself another Iterator over mutable references to the elements in that column.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
for column_iter in vecgrid.columns_iter_mut() {
    for element in column_iter {
        print!("{} ", element);
    }
    println!();
}

let mut columns_iter = vecgrid.columns_iter_mut();

let mut first_column_iter = columns_iter.next().unwrap();
assert_eq!(first_column_iter.next(), Some(&mut 1));
assert_eq!(first_column_iter.next(), Some(&mut 4));
assert_eq!(first_column_iter.next(), None);

let mut second_column_iter = columns_iter.next().unwrap();
assert_eq!(second_column_iter.next(), Some(&mut 2));
assert_eq!(second_column_iter.next(), Some(&mut 5));
assert_eq!(second_column_iter.next(), None);

let mut third_column_iter = columns_iter.next().unwrap();
assert_eq!(third_column_iter.next(), Some(&mut 3));
assert_eq!(third_column_iter.next(), Some(&mut 6));
assert_eq!(third_column_iter.next(), None);

assert!(columns_iter.next().is_none());

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

where T: Clone,

Collects the Vecgrid into a Vec of rows, each of which contains a Vec of elements.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.as_rows(), rows);

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

where T: Clone,

Collects the Vecgrid into a Vec of columns, each of which contains a Vec of elements.

Examples

let columns = vec![vec![1, 4], vec![2, 5], vec![3, 6]];
let vecgrid = Vecgrid::from_columns(columns.clone())?;
assert_eq!(vecgrid.as_columns(), columns);

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

where T: Clone,

Collects the Vecgrid into a Vec of elements in row major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.as_row_major(), vec![1, 2, 3, 4, 5, 6]);

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

where T: Clone,

Collects the Vecgrid into a Vec of elements in column major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.as_column_major(), vec![1, 4, 2, 5, 3, 6]);

pub fn indices_row_major( &self, ) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone

Returns the indices of the vecgrid in row major order. Each index is a tuple of usize.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let indices_row_major = vecgrid.indices_row_major().collect::<Vec<_>>();
assert_eq!(
    indices_row_major,
    vec![(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
);

pub fn indices_column_major( &self, ) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone

Returns the indices of the vecgrid in column major order. Each index is a tuple of usize.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let indices_column_major = vecgrid.indices_column_major().collect::<Vec<_>>();
assert_eq!(
    indices_column_major,
    vec![(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)]
);

pub fn enumerate_row_major( &self, ) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone

Iterate through the vecgrid in row major order along with the corresponding indices. Each index is a tuple of usize.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]]; let vecgrid = Vecgrid::from_rows(rows.clone())?; let enumerate_row_major = vecgrid.enumerate_row_major().collect::<Vec<_>>(); assert_eq!( enumerate_row_major, vec![ ((0, 0), &1), ((0, 1), &2), ((0, 2), &3), ((1, 0), &4), ((1, 1), &5), ((1, 2), &6) ] );

Ok(())

}

pub fn enumerate_column_major( &self, ) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone

Iterate through the vecgrid in column major order along with the corresponding indices. Each index is a tuple of usize.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]]; let vecgrid = Vecgrid::from_rows(rows.clone())?; let enumerate_column_major = vecgrid.enumerate_column_major().collect::<Vec<_>>(); assert_eq!( enumerate_column_major, vec![ ((0, 0), &1), ((1, 0), &4), ((0, 1), &2), ((1, 1), &5), ((0, 2), &3), ((1, 2), &6) ] );

Ok(())

}

pub fn insert_row(&mut self, row: Vec<T>, at: usize) -> Result<(), Error>

Inserts a new row into the vecgrid at the provided index of the row. Guards ensure that the supplied row matches the expected dimensions and that the index is in bound.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2, 3], vec![7, 8, 9]]; let new_row = vec![4, 5, 6]; let result = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.insert_row(new_row, 1)?; assert_eq!(vecgrid.as_rows(), result);

Ok(())

}

pub fn insert_rows(&mut self, rows: Vec<Vec<T>>, at: usize) -> Result<(), Error>

Inserts a slice of rows into the vecgrid at the provided index. Guards ensure that the supplied rows matches the expected dimensions and that the index is in bound.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2], vec![7, 8]]; let new_rows = vec![vec![3, 4], vec![5, 6]]; let result = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.insert_rows(new_row, 1)?; assert_eq!(vecgrid.as_rows(), result);

Ok(())

}

pub fn append_rows(&mut self, rows: Vec<Vec<T>>) -> Result<(), Error>

Appends a vec of rows at the end of the vecgrid. Guards ensure that the supplied rows matches the expected dimensions.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2], vec![3, 4]]; let new_rows = vec![vec![5, 6], vec![7, 8]]; let result = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.append_rows(new_row)?; assert_eq!(vecgrid.as_rows(), result);

Ok(())

}

pub fn remove_row(&mut self, at: usize) -> Result<(), Error>

Removes a row at the provided row index from the vecgrid. Guards ensure that the index is in bound.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let result = vec![vec![1, 2, 3], vec![7, 8, 9]]; let mut vecgrid = Vecgrid::from_rows(rows)?; vecgrid.remove_row(1)?; assert_eq!(vecgrid.as_rows(), result);

Ok(())

}

pub fn remove_rows(&mut self, at: usize, n: usize) -> Result<(), Error>

Removes n consecutive rows at the provided row index from the vecgrid. Guards ensure that the index is in bound.

Examples

use vecgrid::{Vecgrid, Error};

fn main() -> Result<(), Error> {

let rows = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let result = vec![vec![1, 2], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows)?; vecgrid.remove_rows(1, 2)?; assert_eq!(vecgrid.as_rows(), result);

Ok(())

}

Trait Implementations

impl<T: Clone> Clone for Vecgrid<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vecgrid<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Vecgrid<T>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<(usize, usize)> for Vecgrid<T>

fn index(&self, (row, column): (usize, usize)) -> &Self::Output

Returns the element at the given indices, given as (row, column).

Examples

let vecgrid = Vecgrid::filled_with(42, 2, 3);
assert_eq!(vecgrid[(0, 0)], 42);

Panics

Panics if the indices are out of bounds.

let vecgrid = Vecgrid::filled_with(42, 2, 3);
let element = vecgrid[(10, 10)];

type Output = T

The returned type after indexing.

impl<T> IndexMut<(usize, usize)> for Vecgrid<T>

fn index_mut(&mut self, (row, column): (usize, usize)) -> &mut Self::Output

Returns a mutable version of the element at the given indices, given as (row, column).

Examples

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
vecgrid[(0, 0)] = 100;
assert_eq!(vecgrid[(0, 0)], 100);

Panics

Panics if the indices are out of bounds.

let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
vecgrid[(10, 10)] = 7;

impl<T: PartialEq> PartialEq for Vecgrid<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Vecgrid<T>

impl<T> StructuralPartialEq for Vecgrid<T>