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
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

//! Grid wrapping around edges.

use crate::{
    grid2::*,
    range::BoundRange,
};
use mint::Vector2;
use std::ops::RangeFull;


pub struct Grid2Wrapping<G> 
where
    G: Grid2,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    inner: G,
}

impl<G> Grid2Wrapping<G>
where
    G: Grid2,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    pub fn new(inner: G) -> Self {
        Grid2Wrapping {
            inner
        }
    }
    
    pub fn wrap_coord<I>(&self, coord: I) -> I 
    where
        I: From<Vector2<i32>> + Into<Vector2<i32>>
    {
        let Vector2 { mut x, mut y } = coord.into();
        
        let x_start = self.inner.x_bound().lower_inclusive();
        let x_end = self.inner.x_bound().upper_exclusive();
            
        let y_start = self.inner.y_bound().lower_inclusive();
        let y_end = self.inner.y_bound().upper_exclusive();
                
        let x_len = x_end - x_start;
        let y_len = y_end - y_start;
            
        x = ((((x - x_start) % x_len) + x_len) % x_len) + x_start;
        y = ((((y - y_start) % y_len) + y_len) % y_len) + y_start;
        
        I::from(Vector2 { x, y })
    }
}

impl<G> Grid2 for Grid2Wrapping<G>
where
    G: Grid2,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    type Item = <G as Grid2>::Item;
    type XBound = RangeFull;
    type YBound = RangeFull;
    
    fn x_bound(&self) -> RangeFull { RangeFull }
    fn y_bound(&self) -> RangeFull { RangeFull }
}

impl<G> Grid2Get for Grid2Wrapping<G> 
where
    G: Grid2 + Grid2Get,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    fn get<I>(&self, coord: I) -> Self::Item
    where
        I: Into<Vector2<i32>>
    {
        let coord = self.wrap_coord(coord.into());
        self.inner.get(coord)
    }
}

impl<G> Grid2Set for Grid2Wrapping<G> 
where
    G: Grid2 + Grid2Set,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    fn set<I>(&mut self, coord: I, elem: Self::Item)
    where
        I: Into<Vector2<i32>>
    {
        let coord = self.wrap_coord(coord.into());
        self.inner.set(coord, elem);
    }
}

impl<G> Grid2Ref for Grid2Wrapping<G> 
where
    G: Grid2 + Grid2Ref,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    fn idx<I>(&self, coord: I) -> &Self::Item
    where
        I: Into<Vector2<i32>>
    {
        let coord = self.wrap_coord(coord.into());
        self.inner.idx(coord)
    }
}

impl<G> Grid2Mut for Grid2Wrapping<G> 
where
    G: Grid2 + Grid2Mut,
    <G as Grid2>::XBound: BoundRange,
    <G as Grid2>::YBound: BoundRange,
{
    fn midx<I>(&mut self, coord: I) -> &mut Self::Item
    where
        I: Into<Vector2<i32>>
    {
        let coord = self.wrap_coord(coord.into());
        self.inner.midx(coord)
    }
}