gridly_grids 0.5.0

Some basic implementations of gridly grids
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::{convert::TryInto, mem};

use gridly::prelude::*;

/**

A grid backed by stack-allocated arrays.

This grid is in row-major order; see [gridly-adapters](/gridly_adapters) for
a Transpose operator if you need column-major order.
*/
#[derive(Copy)]
pub struct ArrayGrid<T, const R: usize, const C: usize> {
    storage: [[T; C]; R],
}

impl<T, const R: usize, const C: usize> ArrayGrid<T, R, C> {
    #[inline]
    pub fn from_rows(rows: [[T; C]; R]) -> Self {
        Self { storage: rows }
    }

    pub fn new_fill_with(gen: impl Fn() -> T) -> Self {
        Self::from_rows(brownstone::build(move || brownstone::build(&gen)))
    }

    pub fn new_with(gen: impl Fn(Location) -> T) -> Self {
        Self::from_rows(brownstone::build_indexed(|row| {
            brownstone::build_indexed(|column| gen(Location::new(row as isize, column as isize)))
        }))
    }

    /// Fill every cell in the grid with the values produced by repeatedly
    /// calling `gen`. Called in an unspecified order.
    pub fn fill_with(&mut self, gen: impl Fn() -> T) {
        self.storage
            .iter_mut()
            .flat_map(|row| row.iter_mut())
            .for_each(|cell| *cell = gen())
    }
}

impl<T: Default, const R: usize, const C: usize> ArrayGrid<T, R, C> {
    pub fn new() -> Self {
        Self::new_fill_with(T::default)
    }

    pub fn clear(&mut self) {
        self.fill_with(T::default)
    }
}

impl<T: Clone, const R: usize, const C: usize> ArrayGrid<T, R, C> {
    pub fn new_fill(value: &T) -> Self {
        Self::new_fill_with(|| value.clone())
    }

    pub fn fill(&mut self, value: &T) {
        self.fill_with(|| value.clone())
    }
}

impl<T, const R: usize, const C: usize> GridBounds for ArrayGrid<T, R, C> {
    fn dimensions(&self) -> Vector {
        // TODO: Find a way to static assert this.
        Vector {
            rows: Rows(R.try_into().expect("ArrayVec rows out of bounds")),
            columns: Columns(C.try_into().expect("ArrayVec columns out of bounds")),
        }
    }

    #[inline]
    fn root(&self) -> Location {
        Location::zero()
    }
}

impl<T, const R: usize, const C: usize> Grid for ArrayGrid<T, R, C> {
    type Item = T;

    #[inline]
    unsafe fn get_unchecked(&self, location: Location) -> &Self::Item {
        self.storage
            .get_unchecked(location.row.0 as usize)
            .get_unchecked(location.column.0 as usize)
    }
}

impl<T, const R: usize, const C: usize> GridMut for ArrayGrid<T, R, C> {
    #[inline]
    unsafe fn get_unchecked_mut(&mut self, location: Location) -> &mut Self::Item {
        self.storage
            .get_unchecked_mut(location.row.0 as usize)
            .get_unchecked_mut(location.column.0 as usize)
    }
}

impl<T, const R: usize, const C: usize> GridSetter for ArrayGrid<T, R, C> {
    #[inline]
    unsafe fn replace_unchecked(&mut self, location: Location, value: Self::Item) -> Self::Item {
        mem::replace(self.get_unchecked_mut(location), value)
    }

    #[inline]
    unsafe fn set_unchecked(&mut self, location: Location, value: Self::Item) {
        *self.get_unchecked_mut(location) = value
    }
}

impl<T: Default, const R: usize, const C: usize> Default for ArrayGrid<T, R, C> {
    fn default() -> Self {
        Self::from_rows(brownstone::build(|| brownstone::build(T::default)))
    }
}

impl<T: Clone, const R: usize, const C: usize> Clone for ArrayGrid<T, R, C> {
    fn clone(&self) -> Self {
        Self {
            storage: brownstone::build_indexed(|r| {
                brownstone::build_indexed(|c| self.storage[r][c].clone())
            }),
        }
    }

    fn clone_from(&mut self, source: &Self) {
        self.storage
            .iter_mut()
            .zip(&source.storage)
            .flat_map(|(dest_row, src_row)| dest_row.iter_mut().zip(src_row))
            .for_each(|(dest, src)| dest.clone_from(src))
    }
}