gentrix 0.1.4

A library that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
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

#[derive(Debug)]
pub struct Matrix<T: Clone> {
    matrix: Vec<Vec<Option<T>>>,
}

impl<T: Clone> Matrix<T> {
    pub fn new(size: (usize, usize)) -> Matrix<T> {
        let (m, n) = size;
        let mut matrix: Vec<Vec<Option<T>>> = Vec::new();

        let row = vec![None; n];

        for _ in 0..m {
            matrix.push(row.clone());
        }

        return Matrix::<T> { matrix };
    }

    pub fn get(&mut self, pos: (usize, usize)) -> Option<T> {
        let (m, n) = pos;

        let item = self.matrix[m][n].clone();

        if item.is_some() {
            self.delete(pos).unwrap();
        }

        return item;
    }

    pub fn get_ref(&self, pos: (usize, usize)) -> Option<&T> {
        let (m, n) = pos;

        return self.matrix[m][n].as_ref();
    }

    pub fn get_mut(&mut self, pos: (usize, usize)) -> Option<&mut T> {
        let (m, n) = pos;

        return self.matrix[m][n].as_mut();
    }

    pub fn set(&mut self, item: T, pos: (usize, usize)) -> Result<(), ()> {
        if !self.is_in_bounds((pos.0 as isize, pos.1 as isize)) {
            return Err(());
        }

        let (m, n) = pos;
        self.matrix[m][n] = Some(item);

        return Ok(());
    }

    pub fn delete(&mut self, pos: (usize, usize)) -> Result<(), ()> {
        if !self.is_in_bounds((pos.0 as isize, pos.1 as isize)){
            return Err(());
        }

        let (m, n) = pos;

        self.matrix[m][n] = None;

        return Ok(());
    }

    pub fn clear(&mut self){
        let size = (self.matrix.len(), self.matrix[0].len());
        let new_matrix = Matrix::<T>::new(size);

        self.matrix = new_matrix.matrix;
    }

    pub fn translate(&mut self, from: (usize, usize), dir: (isize, isize)) -> Result<(), ()> {
        let to = (from.0 as isize + dir.0, from.1 as isize + dir.1);

        if !self.is_in_bounds(to) {
            return Err(());
        }

        let to = (to.0 as usize, to.1 as usize);

        let item = self.get_ref(from);
        if item.is_none(){
            return Err(());
        }

        let item = item.unwrap().clone();

        self.delete(from)?;
        self.set(item, to)?;


        return Ok(());
    }

    fn is_in_bounds(&self, pos: (isize, isize)) -> bool {
        if pos.0 < 0 || pos.0 > (self.matrix.len() - 1) as isize {
            return false;
        }

        if pos.1 < 0 || pos.1 > (self.matrix[0].len() - 1) as isize {
            return false;
        }

        return true;
    }
}

impl<T: Clone + Copy> From<Vec<Vec<T>>> for Matrix<T> {
    fn from(items: Vec<Vec<T>>) -> Self {
        let m = items.len();
        let n = items.first().unwrap().len();
        let mut matrix = Matrix::new((m, n));

        for i in 0..m {
            for j in 0..n {
                matrix.set(items[i][j], (i, j)).unwrap();
            }
        }

        return matrix;
    }
}