Struct ValueGrid 

pub struct ValueGrid<T: Value> { /* private fields */ }

A 2D grid of values.

The memory layout is the one the display expects in crate::Commands.

This structure can be used with any type that implements the Value trait. You can also use the concrete type aliases provided in this crate, e.g. crate::CharGrid and crate::ByteGrid.

Implementations

impl ValueGrid<Brightness>

pub fn saturating_load(width: usize, height: usize, data: &[u8]) -> Option<Self>

Like Self::load, but ignoring any out-of-range brightness values

impl ValueGrid<char>

pub fn wrap_str(width: usize, text: &str) -> Self

Loads a CharGrid with the specified width from the provided text, wrapping to as many rows as needed.

The passed rows are extended with ‘\0’ if needed.

returns: CharGrid that contains a copy of the provided data.

Examples

let grid = CharGrid::wrap_str(2, "abc\ndef");

impl ValueGrid<u8>

pub fn load_ascii( value: &str, width: usize, wrap: bool, ) -> Result<Self, InvalidCharError>

Load an ASCII-only &str into a Cp437Grid of specified width.

Panics

• for width == 0
• on empty strings

impl<T: Value> ValueGrid<T>

pub fn new(width: usize, height: usize) -> Self

Creates a new ValueGrid with the specified dimensions.

Arguments

• width: size in x-direction
• height: size in y-direction

returns: ValueGrid initialized to default value.

pub fn load(width: usize, height: usize, data: &[T]) -> Option<Self>

Loads a ValueGrid with the specified dimensions from the provided data.

returns: ValueGrid that contains a copy of the provided data, or None if the dimensions do not match the data size.

pub fn from_vec(width: usize, data: Vec<T>) -> Option<Self>

Creates a ValueGrid with the specified width from the provided data, wrapping to as many rows as needed, without copying the vec.

returns: ValueGrid that contains the provided data, or None if the data size is not divisible by the width.

Examples

let grid = ValueGrid::from_vec(2, vec![0, 1, 2, 3, 4, 5]).unwrap();

pub fn iter(&self) -> impl Iterator<Item = &T>

Iterate over all cells in ValueGrid.

Order is equivalent to the following loop:

for y in 0..grid.height() {
    for x in 0..grid.width() {
        grid.get(x, y);
    }
}

pub fn iter_rows(&self) -> impl Iterator<Item = Iter<'_, T>>

Iterate over all rows in ValueGrid top to bottom.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

The iterator yields all cells from top left to bottom right.

pub fn get_ref_mut(&mut self, x: usize, y: usize) -> &mut T

Get a mutable reference to the current value at the specified position.

Arguments

• x and y: position of the cell

Panics

When accessing x or y out of bounds.

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

Get a mutable reference to the current value at the specified position if position is in bounds.

Arguments

• x and y: position of the cell

returns: Reference to cell or None

pub fn map<TConverted, F>(&self, f: F) -> ValueGrid<TConverted>

where TConverted: Value, F: Fn(T) -> TConverted,

Convert between ValueGrid types.

See also Iterator::map.

Examples

Use logic written for u8s and then convert to Brightness values for sending in a Command.

let mut grid: ByteGrid = ByteGrid::new(TILE_WIDTH, TILE_HEIGHT);
foo(&mut grid);
let grid: BrightnessGrid = grid.map(Brightness::saturating_from);
let command = BrightnessGridCommand { origin: Origin::ZERO, grid };

pub fn enumerate(&self) -> impl Iterator<Item = (usize, usize, T)> + use<'_, T>

Enumerates all values in the grid.

pub fn window( &self, xs: impl RangeBounds<usize>, ys: impl RangeBounds<usize>, ) -> Option<Window<'_, T, Self>>

Creates a window into the grid.

Returns None in case the window does not fit.

pub fn window_mut( &mut self, xs: impl RangeBounds<usize>, ys: impl RangeBounds<usize>, ) -> Option<WindowMut<'_, T, Self>>

Creates a mutable window into the grid.

Returns None in case the window does not fit.

Trait Implementations

impl<T: Clone + Value> Clone for ValueGrid<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Value> DataRef<T> for ValueGrid<T>

fn data_ref_mut(&mut self) -> &mut [T]

Get the underlying byte rows mutable

fn data_ref(&self) -> &[T]

Get the underlying byte rows read only

impl<T: Debug + Value> Debug for ValueGrid<T>

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

Formats the value using the given formatter.

impl<T: Value, G: Grid<T>> From<&G> for ValueGrid<T>

fn from(grid: &G) -> Self

Converts to this type from the input type.

impl From<&ValueGrid<Brightness>> for ByteGrid

fn from(value: &BrightnessGrid) -> Self

Converts to this type from the input type.

impl From<&ValueGrid<Brightness>> for Vec<u8>

fn from(value: &BrightnessGrid) -> Self

Converts to this type from the input type.

impl<T: Value> From<&ValueGrid<T>> for Vec<T>

fn from(value: &ValueGrid<T>) -> Self

Turn into the underlying Vec<u8> containing the rows of bytes.

impl From<&ValueGrid<char>> for String

fn from(value: &CharGrid) -> Self

Converts a CharGrid into a String.

Rows are separated by ‘\n’.

Examples

let grid = CharGrid::from("ab\ncd");
let string = String::from(grid);
let grid = CharGrid::from(string);

impl From<&ValueGrid<char>> for Cp437Grid

fn from(value: &CharGrid) -> Self

Converts to this type from the input type.

impl From<&ValueGrid<char>> for Vec<u8>

fn from(value: &CharGrid) -> Self

Converts a CharGrid into a Vec<u8>.

Rows are not separated.

Examples

let grid = CharGrid::from("ab\ncd");
let height = grid.height();
let width = grid.width();
let bytes = Vec::<u8>::from(grid);

impl From<&ValueGrid<u8>> for CharGrid

fn from(value: &Cp437Grid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<Brightness>> for BrightnessGridCommand

fn from(grid: BrightnessGrid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<Brightness>> for Vec<u8>

fn from(value: BrightnessGrid) -> Self

Converts to this type from the input type.

impl<T: Value> From<ValueGrid<T>> for Vec<T>

fn from(value: ValueGrid<T>) -> Self

Turn into the underlying Vec<u8> containing the rows of bytes.

impl From<ValueGrid<char>> for CharGridCommand

fn from(grid: CharGrid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<char>> for String

fn from(grid: CharGrid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<char>> for Cp437Grid

fn from(value: CharGrid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<char>> for Vec<u8>

fn from(value: CharGrid) -> Self

See From<&CharGrid>::from.

impl From<ValueGrid<u8>> for Cp437GridCommand

fn from(grid: Cp437Grid) -> Self

Converts to this type from the input type.

impl From<ValueGrid<u8>> for CharGrid

fn from(value: Cp437Grid) -> Self

Converts to this type from the input type.

impl<T: Value> Grid<T> for ValueGrid<T>

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

Get the current value at the specified position if the position is inside of bounds

fn width(&self) -> usize

the size in x-direction

fn height(&self) -> usize

the height in y-direction

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

Get the current value at the specified position

fn is_in_bounds(&self, x: usize, y: usize) -> bool

Checks whether the specified signed position is in grid bounds

fn assert_in_bounds(&self, x: usize, y: usize)

Asserts that the specified unsigned position is in grid bounds.

fn get_row(&self, y: usize) -> Option<Vec<T>>

Copies a row from the grid.

fn get_col(&self, x: usize) -> Option<Vec<T>>

Copies a column from the grid.

impl<T: Value> GridMut<T> for ValueGrid<T>

fn set_optional(&mut self, x: usize, y: usize, value: T) -> bool

Sets the value of the cell at the specified position in the grid.

Arguments

• x and y: position of the cell
• value: the value to write to the cell

Panics

When accessing x or y out of bounds.

fn fill(&mut self, value: T)

Sets all cells in the grid to the specified value

fn set(&mut self, x: usize, y: usize, value: T)

Sets the value at the specified position

fn deref_assign<O: Grid<T>>(&mut self, other: &O)

Fills the grid with the values from the provided grid.

fn set_col(&mut self, x: usize, col: &[T]) -> Result<(), SetValueSeriesError>

Overwrites a column in the grid.

fn set_row(&mut self, y: usize, row: &[T]) -> Result<(), SetValueSeriesError>

Overwrites a row in the grid.

impl<T: Hash + Value> Hash for ValueGrid<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: PartialEq + Value> PartialEq for ValueGrid<T>

fn eq(&self, other: &ValueGrid<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 TryFrom<&ValueGrid<bool>> for Bitmap

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &ValueGrid<bool>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<ValueGrid<u8>> for BrightnessGrid

type Error = u8

The type returned in the event of a conversion error.

fn try_from(value: ByteGrid) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Eq + Value> Eq for ValueGrid<T>

impl<T: Value> StructuralPartialEq for ValueGrid<T>