Struct aoc_grid::GridBuf

pub struct GridBuf<Storage, Pos, const DIMS: usize>where
    Pos: GridPos<DIMS>,{ /* private fields */ }

Multi dimensional abstraction over a single dimensional collection

This allows a simple one-dimensional collection to be accessed in a multi-dimensional way. It wraps a backing collection which implements GridStorage, and takes indexes which implement GridPos.

Implementations

impl<Storage, Pos, const DIMS: usize> GridBuf<Storage, Pos, DIMS>where Storage: GridStorage + Clone, Pos: GridPos<DIMS>,

pub fn wrap_range(storage: Storage, start: Pos, end: Pos) -> NumResult<Self>

pub fn wrap_size(storage: Storage, size: Pos) -> Self

impl<Storage, Pos, const DIMS: usize> GridBuf<Storage, Pos, DIMS>where Storage: GridStorage + Clone, Pos: GridPos<DIMS>,

pub fn new_range(start: Pos, end: Pos) -> NumResult<Self>where Storage: FromIterator<Storage::Item>, Storage::Item: Clone + Default,

pub fn new_size(size: Pos) -> Selfwhere Storage: FromIterator<Storage::Item>, Storage::Item: Clone + Default,

impl<Storage, Pos, const DIMS: usize> GridBuf<Storage, Pos, DIMS>where Storage: GridStorage + Clone, Pos: GridPos<DIMS>,

pub fn set_index(&mut self, idx: usize, item: Storage::Item)

pub fn set(&mut self, pos: Pos, item: Storage::Item)

pub fn try_set(&mut self, pos: Pos, item: Storage::Item) -> Option<()>

pub fn translate(&self, offset: Pos) -> NumResult<Self>

impl<Item, Pos, const DIMS: usize> GridBuf<Vec<Item>, Pos, DIMS>where Item: Default, Pos: GridPos<DIMS>,

pub fn reset(&mut self)

impl<Storage, Pos, const DIMS: usize> GridBuf<Storage, Pos, DIMS>where Storage: GridStorageMut + Clone, Pos: GridPos<DIMS>,

pub fn get_ref(&self, pos: Pos) -> Option<&Storage::Item>

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

impl<Storage, Pos> GridBuf<Storage, Pos, 2>where Storage: GridStorage, Storage::Item: Display, Pos: GridPosDisplay,

pub fn display_with_delim<Delim: Display>( &self, delim: Delim, formatter: &mut Formatter<'_> ) -> Result

impl<'inp, Storage, Pos> GridBuf<Storage, Pos, 2>where Pos: GridPosParse, Storage: Clone + FromIterator<Storage::Item> + GridStorage, Storage::Item: Clone + Default + FromParser<'inp>,

pub fn parse_with_delim_and_fn( parser: &mut Parser<'inp>, delim: impl ParseDelimiter, default_fn: impl Fn() -> Storage::Item, parse_fn: impl Fn(&mut Parser<'inp>) -> ParseResult<Storage::Item> + Clone ) -> ParseResult<Self>

pub fn parse_with_delim( parser: &mut Parser<'inp>, default_fn: impl Fn() -> Storage::Item, delim: impl ParseDelimiter ) -> ParseResult<Self>

pub fn parse_with_fn( parser: &mut Parser<'inp>, default_fn: impl Fn() -> Storage::Item, parse_fn: impl Fn(&mut Parser<'inp>) -> ParseResult<Storage::Item> + Clone ) -> ParseResult<Self>

impl<'grd, Storage, Pos, const DIMS: usize> GridBuf<Storage, Pos, DIMS>where Storage: GridStorage + Clone + FromIterator<<Storage as GridStorage>::Item> + 'grd, Storage::Item: Default, &'grd Storage: GridStorageIntoIter, Pos: GridPos<DIMS>,

pub fn resize(&'grd self, start: Pos, end: Pos) -> NumResult<Self>where <Storage as GridStorage>::Item: Default,

pub fn extend_in_place( &'grd self, amts: [(Pos::Coord, Pos::Coord); DIMS] ) -> NumResult<Self>where <Storage as GridStorage>::Item: Default,

Trait Implementations

impl<Storage: Clone, Pos, const DIMS: usize> Clone for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + Clone,

fn clone(&self) -> GridBuf<Storage, Pos, DIMS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Storage, Pos, const DIMS: usize> Debug for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS>,

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

Formats the value using the given formatter.

impl<Storage, Pos> Display for GridBuf<Storage, Pos, 2>where Storage: GridStorage, Storage::Item: Display, Pos: GridPosDisplay,

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

Formats the value using the given formatter.

impl<'inp, Storage, Pos> FromParser<'inp> for GridBuf<Storage, Pos, 2>where Pos: GridPosParse, Storage: Clone + FromIterator<Storage::Item> + GridStorage, Storage::Item: Clone + Default + FromParser<'inp>,

fn from_parser(parser: &mut Parser<'inp>) -> ParseResult<Self>

fn parse_from_str(input: &'inp str) -> Result<Self, Box<dyn Error, Global>>

fn parse_from_lines( input: &'inp [&'inp str] ) -> Result<Self, Box<dyn Error, Global>>

impl<'grd, Storage, Pos, const DIMS: usize> GridView<Pos, DIMS> for &'grd GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS>, Storage: GridStorage,

type Item = <Storage as GridStorage>::Item

type Cursors = GridCursorIter<Pos, DIMS>

fn start(self) -> Pos

fn end(self) -> Pos

fn size(self) -> Pos

fn get_trusted(self, _native: Pos, idx: usize) -> Storage::Item

fn cursors(self) -> GridCursorIter<Pos, DIMS>

fn len(self) -> usize

fn is_empty(self) -> bool

fn keys(self) -> GridKeysIter<Pos, DIMS>

fn first_key(self) -> Pos

fn last_key(self) -> Pos

fn get(self, pos: Pos) -> Option<Self::Item>

fn get_native(self, native: Pos) -> Option<Self::Item>

fn offset(self, pos: Pos) -> NumResult<GridOffset<Pos, DIMS>>

fn cursor(self, pos: Pos) -> Option<GridCursor<Pos, DIMS>>

fn map<Storage, MapFn, Output>( self, map_fn: MapFn ) -> GridBuf<Storage, Pos, DIMS>where MapFn: FnMut(GridCursor<Pos, DIMS>) -> Output, Storage: Clone + GridStorage + FromIterator<Output>,

fn try_map<Storage, MapFn, Output, Error>( self, map_fn: MapFn ) -> Result<GridBuf<Storage, Pos, DIMS>, Error>where MapFn: FnMut(GridCursor<Pos, DIMS>) -> Result<Output, Error>, Storage: Clone + GridStorage + FromIterator<Output>,

impl<'grd, Storage, Pos, const DIMS: usize> GridViewIter<Pos, DIMS> for &'grd GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS>, Storage: GridStorage, &'grd Storage: GridStorageIntoIter<Item = Self::Item>,

type Values = <&'grd Storage as GridStorageIntoIter>::Iter

fn values(self) -> Self::Values

fn iter(self) -> GridIter<Self::Values, Pos, DIMS>where Self: Copy + Sized,

fn to_buf<Storage>(self) -> GridBuf<Storage, Pos, DIMS>where Storage: Clone + GridStorage + FromIterator<Self::Item>,

impl<Storage: Hash, Pos, const DIMS: usize> Hash for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + Hash,

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<Storage: Ord, Pos, const DIMS: usize> Ord for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + Ord,

fn cmp(&self, other: &GridBuf<Storage, Pos, DIMS>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<Storage: PartialEq, Pos, const DIMS: usize> PartialEq<GridBuf<Storage, Pos, DIMS>> for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + PartialEq,

fn eq(&self, other: &GridBuf<Storage, Pos, DIMS>) -> bool

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

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

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

impl<Storage: PartialOrd, Pos, const DIMS: usize> PartialOrd<GridBuf<Storage, Pos, DIMS>> for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + PartialOrd,

fn partial_cmp(&self, other: &GridBuf<Storage, Pos, DIMS>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Storage: Eq, Pos, const DIMS: usize> Eq for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS> + Eq,

impl<Storage, Pos, const DIMS: usize> StructuralEq for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS>,

impl<Storage, Pos, const DIMS: usize> StructuralPartialEq for GridBuf<Storage, Pos, DIMS>where Pos: GridPos<DIMS>,