grid_trait 0.1.1

2D and 3D grids with combinators.
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

//! 3x3 allocation-free array implementation of Grid2.

use crate::{
    range::Range0To,
    grid2::*,
};
use mint::Vector2;

pub struct Inline3x3Grid<T> {
    array: [[T; 3]; 3],
}

impl<T> Inline3x3Grid<T> {
    pub fn new<I, F>(mut startval: F) -> Self 
    where
        I: From<Vector2<i32>>,
        F: FnMut(I) -> T
    {
        fn xy<I: From<Vector2<i32>>>(x: i32, y: i32) -> I {
            I::from(Vector2 { x, y })
        }
        
        let array = [
            [startval(xy(0, 0)), startval(xy(0, 1)), startval(xy(0, 2))],
            [startval(xy(1, 0)), startval(xy(1, 1)), startval(xy(1, 2))],
            [startval(xy(2, 0)), startval(xy(2, 1)), startval(xy(2, 2))],
        ];
        Inline3x3Grid { array }
    }
    
    
    pub fn broadcast(startval: T) -> Self 
    where
        T: Clone
    {
        Self::new(|_: Vector2<i32>| startval.clone())
    }
}

impl<T> From<[[T; 3]; 3]> for Inline3x3Grid<T> {
    fn from(array: [[T; 3]; 3]) -> Self {
        Inline3x3Grid { array }
    }
}

impl<T> Grid2 for Inline3x3Grid<T> {
    type Item = T;
    type XBound = Range0To;
    type YBound = Range0To;
    
    fn x_bound(&self) -> Range0To {
        Range0To { end: 3 }
    }
    
    fn y_bound(&self) -> Range0To {
        Range0To { end: 3 }
    }
}

impl<T> Grid2Len for Inline3x3Grid<T> {}

impl<T> Grid2Ref for Inline3x3Grid<T> {
    fn idx<I>(&self, coord: I) -> &Self::Item
    where
        I: Into<Vector2<i32>>
    {
        let coord = coord.into();
        &self.array[coord.x as usize][coord.y as usize]
    }
}

impl<T> Grid2Mut for Inline3x3Grid<T> {
    fn midx<I>(&mut self, coord: I) -> &mut Self::Item
    where
        I: Into<Vector2<i32>>
    {
        let coord = coord.into();
        &mut self.array[coord.x as usize][coord.y as usize]
    }
}

impl<T: Clone> Grid2Get for Inline3x3Grid<T> {
    fn get<I: Into<Vector2<i32>>>(&self, coord: I) -> Self::Item 
    { self.idx(coord).clone() }
}

impl<T> Grid2Set for Inline3x3Grid<T> {
    fn set<I: Into<Vector2<i32>>>(&mut self, coord: I, elem: Self::Item) 
    { *self.midx(coord) = elem; }
}