Struct GridBuf 

pub struct GridBuf<T, B, L> { /* private fields */ }

Available on crate feature buffer only.

A 2-dimensional grid implemented by a linear data buffer.

Layout

The grid is stored in a linear buffer, with elements accessed in an order defined by Layout.

Implementations

impl<T, B, L> GridBuf<T, B, L>

where B: AsRef<[T]>, L: LinearLayout,

pub fn from_buffer(buffer: B, width: usize) -> Self

Returns a grid from an existing buffer with a given width in columns.

The height is inferred from the buffer length and width.

Any data type that can be represented as a slice can be used as the buffer type, including arrays, slices, and vectors.

Panics

This panics if the buffer length is not a multiple of the width.

Example

use grixy::prelude::*;

let buffer = vec![1, 2, 3, 4, 5, 6];
let grid = GridBuf::<_, _, RowMajor>::from_buffer(buffer, 3);

assert_eq!(grid.get(Pos::new(0, 0)), Some(&1));
assert_eq!(grid.get(Pos::new(1, 0)), Some(&2));
assert_eq!(grid.get(Pos::new(2, 1)), Some(&6));
assert_eq!(grid.get(Pos::new(3, 1)), None); // Out of bounds

impl<T> GridBuf<T, Vec<T>, RowMajor>

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

where T: Copy + Default,

Available on crate feature alloc only.

Creates a new grid with the specified width and height, filled with a default value.

This creates a grid with a row-major layout; see new_filled_with_layout to customize.

Example

use grixy::prelude::*;

let grid = GridBuf::<u8, _, _>::new(3, 3);
assert_eq!(grid.get(Pos::new(0, 0)), Some(&0));
assert_eq!(grid.get(Pos::new(2, 2)), Some(&0));
assert_eq!(grid.get(Pos::new(3, 3)), None); // Out of bounds

pub fn new_filled(width: usize, height: usize, value: T) -> Self

where T: Copy,

Available on crate feature alloc only.

Creates a new grid with the specified width and height, filled with a specified value.

This creates a grid with a row-major layout; see new_filled_with_layout to customize.

Example

use grixy::prelude::*;

let grid = GridBuf::new_filled(5, 4, 42);

assert_eq!(grid.get(Pos::new(0, 0)), Some(&42));
assert_eq!(grid.get(Pos::new(4, 3)), Some(&42));
assert_eq!(grid.get(Pos::new(5, 3)), None); // Out of bounds

impl<T, L> GridBuf<T, Vec<T>, L>

where L: LinearLayout,

pub fn new_filled_with_layout(width: usize, height: usize, value: T) -> Self

where T: Copy, L: LinearLayout,

Available on crate feature alloc only.

Creates a new grid with the specified width and height, filled with a default value.

The layout is specified by the type parameter L, allowing for different memory layouts.

Example

impl<T, L> GridBuf<T, Vec<T>, L>

where T: Clone + Default, L: LinearLayout,

pub fn resize(&mut self, new_width: usize, new_height: usize)

Available on crate feature alloc only.

Resizes the grid to the new dimensions.

Content in the overlap between the old and new dimensions is preserved. New cells are initialized to T::default().

If both dimensions shrink, excess cells are dropped.

Examples

use grixy::prelude::*;

let mut grid = GridBuf::new_filled(4, 4, 1u8);
grid[Pos::new(0, 0)] = 99;
grid.resize(6, 6);

assert_eq!(grid.get(Pos::new(0, 0)), Some(&99)); // preserved
assert_eq!(grid.get(Pos::new(5, 5)), Some(&0));  // new, default

pub fn resize_filled(&mut self, new_width: usize, new_height: usize, value: T)

Available on crate feature alloc only.

Resizes the grid, filling new cells with value instead of Default.

Examples

use grixy::prelude::*;

let mut grid = GridBuf::new_filled(2, 2, 1u8);
grid.resize_filled(4, 4, 42);

assert_eq!(grid.get(Pos::new(0, 0)), Some(&1));  // preserved
assert_eq!(grid.get(Pos::new(3, 3)), Some(&42)); // new, filled with 42

impl<T, B, L> GridBuf<T, B, L>

where L: LinearLayout,

pub fn into_inner(self) -> (B, usize, usize)

Consumes the GridBuf, returning the underlying buffer, width, and height.

pub fn get_mut(&mut self, pos: Pos) -> Option<&mut T>

where B: AsMut<[T]>, L: LinearLayout,

Returns a mutable reference to the element at pos, or None if out of bounds.

Trait Implementations

impl<T, B, L> AsMut<[T]> for GridBuf<T, B, L>

where B: AsMut<[T]>, L: LinearLayout,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, B, L> AsRef<[T]> for GridBuf<T, B, L>

where B: AsRef<[T]>, L: LinearLayout,

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone, B: Clone, L: Clone> Clone for GridBuf<T, B, L>

fn clone(&self) -> GridBuf<T, B, L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, B: Debug, L: Debug> Debug for GridBuf<T, B, L>

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

Formats the value using the given formatter.

impl<'de, T, L> Deserialize<'de> for GridBuf<T, Vec<T>, L>

where T: Deserialize<'de> + Default + Copy, L: LinearLayout,

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T, B, L> Display for GridBuf<T, B, L>

where T: Display + Default + PartialEq, B: AsRef<[T]>, L: LinearLayout,

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

Formats the value using the given formatter.

impl<T: Eq, B: Eq, L: Eq> Eq for GridBuf<T, B, L>

impl<T, B, L> ExactSizeGrid for GridBuf<T, B, L>

where L: LinearLayout,

fn width(&self) -> usize

Returns the width of the grid, in columns.

fn height(&self) -> usize

Returns the height of the grid, in rows.

fn size(&self) -> Size

Returns the exact size of the grid.

fn contains(&self, pos: Pos) -> bool

Returns whether the given position is valid for this grid.

impl<T, B, L> GridBase for GridBuf<T, B, L>

where L: LinearLayout,

fn size_hint(&self) -> (Size, Option<Size>)

Returns the size of the grid, if known.

fn trim_rect(&self, rect: Rect) -> Rect

Returns the given rectangle, trimmed to fit within the grid’s size.

impl<T, B, L> GridReadUnchecked for GridBuf<T, B, L>

where B: AsRef<[T]>, L: LinearLayout,

type Element<'a> = &'a T where Self: 'a

The type of elements in the grid.

type Layout = L

The layout of the grid, which determines how elements are stored and accessed.

unsafe fn get_unchecked(&self, pos: Pos) -> Self::Element<'_>

Returns an element, without doing bounds checking.

unsafe fn iter_rect_unchecked( &self, bounds: Rect, ) -> impl Iterator<Item = Self::Element<'_>>

Returns an iterator over elements in a rectangular region of the grid.

impl<T, B, L> GridWriteUnchecked for GridBuf<T, B, L>

where B: AsMut<[T]>, L: LinearLayout,

type Element = T

The type of elements in the grid.

type Layout = L

The type of layout used for the grid.

unsafe fn set_unchecked(&mut self, pos: Pos, value: Self::Element)

Sets the element at a specified position without bounds checking.

unsafe fn fill_rect_iter_unchecked( &mut self, bounds: Rect, iter: impl IntoIterator<Item = Self::Element>, )

Sets elements within a rectangular region of the grid without bounds checking.

unsafe fn fill_rect_solid_unchecked( &mut self, bounds: Rect, value: Self::Element, )

where Self::Element: Copy,

Fills a rectangular region of the grid with a single value without bounds checking.

unsafe fn fill_rect_unchecked( &mut self, dst: Rect, f: impl FnMut(Pos) -> Self::Element, )

Sets elements within a rectangular region of the grid without bounds checking.

impl<T, B, L> Index<Pos<usize>> for GridBuf<T, B, L>

where L: LinearLayout, B: AsRef<[T]>,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, B, L> IndexMut<Pos<usize>> for GridBuf<T, B, L>

where L: LinearLayout, B: AsRef<[T]> + AsMut<[T]>,

fn index_mut(&mut self, index: Pos) -> &mut Self::Output

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

impl<T: PartialEq, B: PartialEq, L: PartialEq> PartialEq for GridBuf<T, B, L>

fn eq(&self, other: &GridBuf<T, B, L>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, B, L> Serialize for GridBuf<T, B, L>

where T: Serialize, B: AsRef<[T]>, L: LinearLayout,

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: PartialEq, B: PartialEq, L: PartialEq> StructuralPartialEq for GridBuf<T, B, L>

impl<T, B, L> TrustedSizeGrid for GridBuf<T, B, L>

where L: LinearLayout,