grixy 0.6.0

Zero-cost 2D grids for embedded systems and graphics
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#[cfg(feature = "alloc")]
extern crate alloc;

use crate::{buf::GridBuf, core::Pos, ops::layout};

#[cfg(feature = "alloc")]
impl<T, L> GridBuf<T, alloc::vec::Vec<T>, L>
where
    T: Clone + Default,
    L: layout::LinearLayout,
{
    /// 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
    ///
    /// ```rust
    /// 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(&mut self, new_width: usize, new_height: usize) {
        if new_width == self.width && new_height == self.height {
            return;
        }

        let copy_w = self.width.min(new_width);
        let copy_h = self.height.min(new_height);
        let mut new_buf = alloc::vec![T::default(); new_width * new_height];

        for row in 0..copy_h {
            for col in 0..copy_w {
                let src_pos = Pos::new(col, row);
                let dst_idx = L::pos_to_index(src_pos, new_width);
                let src_idx = L::pos_to_index(src_pos, self.width);
                new_buf[dst_idx] = self.buffer[src_idx].clone();
            }
        }

        self.buffer = new_buf;
        self.width = new_width;
        self.height = new_height;
    }

    /// Resizes the grid, filling new cells with `value` instead of `Default`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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
    /// ```
    pub fn resize_filled(&mut self, new_width: usize, new_height: usize, value: T) {
        if new_width == self.width && new_height == self.height {
            return;
        }

        let copy_w = self.width.min(new_width);
        let copy_h = self.height.min(new_height);
        let mut new_buf = alloc::vec![value; new_width * new_height];

        for row in 0..copy_h {
            for col in 0..copy_w {
                let src_pos = Pos::new(col, row);
                let dst_idx = L::pos_to_index(src_pos, new_width);
                let src_idx = L::pos_to_index(src_pos, self.width);
                new_buf[dst_idx] = self.buffer[src_idx].clone();
            }
        }

        self.buffer = new_buf;
        self.width = new_width;
        self.height = new_height;
    }
}

#[cfg(test)]
#[cfg(feature = "alloc")]
mod tests {
    extern crate alloc;

    #[allow(unused_imports)]
    use crate::ops::{ExactSizeGrid as _, GridRead as _};
    use crate::{buf::GridBuf, core::Pos, ops::layout::RowMajor};

    #[test]
    fn resize_grow() {
        let mut grid = GridBuf::<_, _, RowMajor>::new_filled(2, 2, 1u8);
        grid[Pos::new(0, 0)] = 99;
        grid.resize(4, 4);

        assert_eq!(grid.width(), 4);
        assert_eq!(grid.height(), 4);
        assert_eq!(grid.get(Pos::new(0, 0)), Some(&99)); // preserved
        assert_eq!(grid.get(Pos::new(1, 1)), Some(&1)); // preserved
        assert_eq!(grid.get(Pos::new(3, 3)), Some(&0)); // new, default
    }

    #[test]
    fn resize_shrink() {
        let mut grid = GridBuf::<_, _, RowMajor>::new_filled(4, 4, 1u8);
        grid[Pos::new(3, 3)] = 99;
        grid.resize(2, 2);

        assert_eq!(grid.width(), 2);
        assert_eq!(grid.height(), 2);
        assert_eq!(grid.get(Pos::new(0, 0)), Some(&1)); // preserved
        assert_eq!(grid.get(Pos::new(1, 1)), Some(&1)); // preserved
        assert_eq!(grid.get(Pos::new(3, 3)), None); // out of bounds
    }

    #[test]
    fn resize_same_size() {
        let mut grid = GridBuf::<_, _, RowMajor>::new_filled(3, 3, 1u8);
        grid[Pos::new(0, 0)] = 99;
        grid.resize(3, 3);

        assert_eq!(grid.get(Pos::new(0, 0)), Some(&99)); // unchanged
        assert_eq!(grid.width(), 3);
        assert_eq!(grid.height(), 3);
    }

    #[test]
    fn resize_grow_width_shrink_height() {
        let mut grid = GridBuf::<_, _, RowMajor>::new_filled(3, 3, 1u8);
        grid[Pos::new(2, 2)] = 99;
        grid.resize(5, 2);

        assert_eq!(grid.width(), 5);
        assert_eq!(grid.height(), 2);
        assert_eq!(grid.get(Pos::new(2, 2)), None); // out of bounds (height shrunk)
        assert_eq!(grid.get(Pos::new(4, 1)), Some(&0)); // new, default
    }

    #[test]
    fn resize_filled_grow() {
        let mut grid = GridBuf::<_, _, RowMajor>::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
    }
}