Vecgrid provides a dynamically sized two-dimensional vector. It is more efficient
and is easier to use than a vector of vectors, i.e. Vec<Vec<T>>.
This is beneficial when using a grid-like structure, which is common in image processing, game development, and other situations. Vecgrid cannot be used when rows or columns might have different lengths—all rows and columns must be the same length.
Vecgrid is a fork of the statically-sized two-dimensional array library [Array2D].
This project attemps to extend the upstream project in an opinionated fashion, by adding mutable iterators and dynamic resizing of the inner collection. Here's how that is going:
row_iter_mutcolumn_iter_mutrows_iter_mutcolumns_iter_mutelements_row_major_iter_mutelements_column_major_iter_mutinsert_rowinsert_columninsert_rowsinsert_columnsremove_rowremove columnappend_rowsappend_columnsextend_rowsextend_columnsUpstream code might be refactored along the way to make use of optimizations or to align approaches across the crate. Code deprecated upstream from before the inital release of this crate is dropped, future deprecated upstream code may or may not be deprecated in this crate in kind. A release of a major version of this crate indicates maturity surpassing active tracking of the upstream repository, but until then changes will be synced as they happen.
Vecgrid]Vecgrid]A [Vecgrid] can be created in many different ways. These include:
from_rows] and [from_columns]).from_row_major] and
[from_column_major]).filled_with]).filled_by_row_major] and
[filled_by_column_major]).from_iter_row_major] and [from_iter_column_major]).Vecgrid]Since [Vecgrid]s are dynamically sized, it is possible to extend them:
insert_row],
or providing a mutable slice of rows to [insert_rows].append_rows]... or future additions!Vecgrid][Vecgrid] supports several forms of indexing:
(usize,
usize)], which panics on out-of-bounds accesses.get], [get_mut], and [set] methods, which return an
[Option] or a [Result] on out-of-bounds accesses.get_row_major], [get_mut_row_major], [set_row_major],
[get_column_major], [get_mut_column_major],
[set_column_major]. These perform the same tasks as the non row/column
major methods, but take one index instead of two.[Vecgrid] also supports several forms of iteration. You can iterate
through:
elements_row_major_iter] and [elements_column_major_iter]).elements_row_major_iter_mut] and [elements_column_major_iter_mut]).row_iter] and [column_iter]).row_iter_mut] and [column_iter_mut]).rows_iter] and [columns_iter]).rows_iter_mut] and [columns_iter_mut]).Vecgrid]A [Vecgrid] can be converted back into a [Vec] through several
methods. You can extract the data as:
Vec] of rows or columns (see [as_rows] and [as_columns]).Vec] of elements in either [row major or column major order]
(see [as_row_major] and [as_column_major]).```rust use vecgrid::{Vecgrid, Error};
pub fn main() -> Result<(), Error> { // Create a vecgrid filled with the same element. let prefilled = Vecgrid::filledwith(42, 2, 3); asserteq!(prefilled.numrows(), 2); asserteq!(prefilled.numcolumns(), 3); asserteq!(prefilled[(0, 0)], 42);
// Create a vecgrid from the given rows. You can also use columns
// with the `columns` function
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let from_rows = Vecgrid::from_rows(&rows)?;
assert_eq!(from_rows.num_rows(), 2);
assert_eq!(from_rows.num_columns(), 3);
assert_eq!(from_rows[(1, 1)], 5);
// Create vecgrid from a flat Vec of elements in row major or
// column major order.
let column_major = vec![1, 4, 2, 5, 3, 6];
let from_column_major =
Vecgrid::from_column_major(&column_major, 2, 3)?;
assert_eq!(from_column_major.num_rows(), 2);
assert_eq!(from_column_major.num_columns(), 3);
assert_eq!(from_column_major[(1, 1)], 5);
// Implements `Eq` if the element type does.
assert_eq!(from_rows, from_column_major);
// Index into a vecgrid using a tuple of usize to access or alter
// the vecgrid.
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(&rows)?;
vecgrid[(1, 1)] = 100;
// Convert the vecgrid back into a nested Vec using `as_rows` or
// `as_columns`.
let vecgrid_rows = vecgrid.as_rows();
assert_eq!(vecgrid_rows, vec![vec![1, 2, 3], vec![4, 100, 6]]);
// Convert the vecgrid back into a flat Vec using `as_row_major` or
// `as_column_major`.
let vecgrid_column_major = vecgrid.as_column_major();
assert_eq!(vecgrid_column_major, vec![1, 4, 2, 100, 3, 6]);
// Iterate over a single row or column
println!("First column:");
for element in vecgrid.column_iter(0)? {
println!("{}", element);
}
// Iterate over all rows or columns.
println!("All elements:");
for row_iter in vecgrid.rows_iter() {
for element in row_iter {
print!("{} ", element);
}
println!();
}
Ok(())
}
```
This library is made possible thanks to the excellent groundwork laid down in [Array2D] by author HarrisonMc555, as well as contributor to the upstream project tylerjw. [Array2D] has been published under the MIT license.
License: MIT