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
use crate::Vec2d;
use std::convert::TryFrom;
pub struct WrappingVec2d<T> {
data: Vec2d<T>,
}
#[allow(non_camel_case_types)]
pub type wsize = isize;
fn get_index(mut val: wsize, num: wsize) -> usize {
while val < 0 { val += num; }
while val >= num { val -= num; }
let conversion = usize::try_from(val);
if conversion.is_err() { panic!("Unable to get array index"); }
conversion.unwrap()
}
impl <T> WrappingVec2d<T> {
pub fn mut_array(&mut self) -> &mut Vec2d<T> {
&mut self.data
}
pub fn array(&self) -> &Vec2d<T> {
&self.data
}
pub fn count_cols(&self) -> wsize {
let cols = self.array().count_cols();
wsize::try_from(cols).unwrap()
}
pub fn count_rows(&self) -> wsize {
let rows = self.array().count_rows();
wsize::try_from(rows).unwrap()
}
pub fn get_col_index(&self, col: wsize) -> usize {
let conversion = wsize::try_from(self.data.count_cols());
if conversion.is_err() { panic!("Too many columns in array to convert to wsize"); }
let n_cols = conversion.unwrap();
get_index(col, n_cols)
}
pub fn get_row_index(&self, row: wsize) -> usize {
let conversion = wsize::try_from(self.data.count_rows());
if conversion.is_err() { panic!("Too many rows in array to convert to wsize"); }
let n_rows = conversion.unwrap();
get_index(row, n_rows)
}
pub fn index<'a>(&'a self, row: wsize, col: wsize) -> &'a T {
let row: usize = self.get_row_index(row);
let col: usize = self.get_col_index(col);
&self.array()[row][col]
}
pub fn index_mut<'a>(&'a mut self, row: wsize, col: wsize) -> &'a mut T {
let row: usize = self.get_row_index(row);
let col: usize = self.get_col_index(col);
&mut self.mut_array()[row][col]
}
}
impl <T: Copy> WrappingVec2d<T> {
pub fn from(width: usize, data: &[T]) -> WrappingVec2d<T> {
WrappingVec2d {
data: Vec2d::from(width, data),
}
}
pub fn from_vec2d(data: Vec2d<T>) -> WrappingVec2d<T> {
WrappingVec2d {
data: data,
}
}
}
mod tests {
use super::*;
type DataType = i32;
#[test]
fn check_array_access() {
let data: [DataType;12] = [1,2,3,4,5,6,7,8,9,10,11,12];
let v: Vec2d<DataType> = Vec2d::from(3, &data);
let mut w: WrappingVec2d<DataType> = WrappingVec2d::from_vec2d(v);
w.mut_array()[3][2] = 99;
assert_eq!(w.mut_array()[3][2], 99);
}
#[test]
fn check_index() {
let data: [DataType;12] = [1,2,3,4,5,6,7,8,9,10,11,12];
let v: Vec2d<DataType> = Vec2d::from(3, &data);
let mut w: WrappingVec2d<DataType> = WrappingVec2d::from_vec2d(v);
*w.index_mut(3,2) = 99;
assert_eq!(*w.index(3,2), 99);
assert_eq!(w.array()[3][2], *w.index(3,2));
}
}