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

use crate::{
    grid::records::{ExactRecords, Records, Resizable},
    settings::TableOption,
};

/// Reverse data on the table.
#[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Reverse {
    columns: bool,
}

impl Reverse {
    /// Reverse columns.
    pub const fn columns() -> Self {
        Self { columns: true }
    }

    /// Reverse rows.
    pub const fn rows() -> Self {
        Self { columns: false }
    }
}

impl<R, D, C> TableOption<R, C, D> for Reverse
where
    R: Resizable + Records + ExactRecords,
{
    fn change(self, records: &mut R, _: &mut C, _: &mut D) {
        match self.columns {
            true => reverse_columns(records),
            false => reverse_rows(records),
        }
    }
}

fn reverse_rows<R>(data: &mut R)
where
    R: Resizable + ExactRecords,
{
    let count_rows = data.count_rows();
    if count_rows < 2 {
        return;
    }

    for row in 0..count_rows / 2 {
        data.swap_row(row, count_rows - row - 1);
    }
}

fn reverse_columns<R>(data: &mut R)
where
    R: Resizable + Records,
{
    let count_columns = data.count_columns();
    if count_columns < 2 {
        return;
    }

    for col in 0..count_columns / 2 {
        data.swap_column(col, count_columns - col - 1);
    }
}

#[cfg(test)]
#[cfg(feature = "std")]
mod tests {
    use crate::grid::records::vec_records::VecRecords;

    use super::{reverse_columns, reverse_rows};

    #[test]
    fn test_reverse_rows() {
        assert_eq!(
            rev_rows(vec![vec![0, 1, 2], vec![3, 4, 5], vec![6, 7, 8]]),
            vec![vec![6, 7, 8], vec![3, 4, 5], vec![0, 1, 2]]
        )
    }

    #[test]
    fn test_reverse_columns() {
        assert_eq!(
            rev_cols(vec![vec![0, 1, 2], vec![3, 4, 5], vec![6, 7, 8]]),
            vec![vec![2, 1, 0], vec![5, 4, 3], vec![8, 7, 6]]
        )
    }

    fn rev_rows(mut data: Vec<Vec<usize>>) -> Vec<Vec<usize>> {
        reverse_rows(&mut data);
        data
    }

    fn rev_cols(data: Vec<Vec<usize>>) -> Vec<Vec<usize>> {
        let mut records = VecRecords::new(data);
        reverse_columns(&mut records);

        records.into()
    }
}