logisheets_controller 0.7.0

the core of LogiSheets
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

pub mod ctx;
pub mod diff;

use std::collections::{HashMap, HashSet, VecDeque};

use logisheets_base::{CellId, SheetId};

use crate::{controller::status::Status, edit_action::PayloadsAction};

use self::diff::{convert_payloads_to_sheet_diff, Diff, SheetDiff};

const HISTORY_SIZE: usize = 50;

/// VersionManager records the history of a workbook and the payloads. It can help
/// users find out the minimal updates at a certain version.
#[derive(Debug, Default)]
pub struct VersionManager {
    version: u32,
    undo_stack: VecDeque<Status>,
    redo_stack: VecDeque<Status>,
    diff_undo_stack: VecDeque<HashMap<SheetId, SheetDiff>>,
    diff_redo_stack: VecDeque<HashMap<SheetId, SheetDiff>>,
    current_status: Status,
    current_diffs: HashMap<SheetId, SheetDiff>,
}

impl VersionManager {
    pub fn version(&self) -> u32 {
        self.version
    }

    pub fn record(
        &mut self,
        mut status: Status,
        processes: PayloadsAction,
        updated_cells: HashSet<(SheetId, CellId)>,
    ) {
        let diffs = convert_payloads_to_sheet_diff(&mut status, processes, updated_cells);
        self.add_status(status, diffs);
        self.version += 1;
    }

    fn add_status(&mut self, current: Status, sheet_diff: HashMap<SheetId, SheetDiff>) {
        self.redo_stack.clear();
        self.diff_redo_stack.clear();

        if self.undo_stack.len() >= HISTORY_SIZE {
            self.undo_stack.pop_front();
            self.diff_undo_stack.pop_front();
        }

        let mut current = current;
        let mut sheet_diff = sheet_diff;

        std::mem::swap(&mut current, &mut self.current_status);
        std::mem::swap(&mut sheet_diff, &mut self.current_diffs);

        self.undo_stack.push_back(current);
        self.diff_undo_stack.push_back(sheet_diff);
    }

    pub fn undo(&mut self) -> Option<Status> {
        let mut status = self.undo_stack.pop_back()?;
        let mut payloads = self.diff_undo_stack.pop_back()?;

        std::mem::swap(&mut status, &mut self.current_status);
        std::mem::swap(&mut payloads, &mut self.current_diffs);

        self.redo_stack.push_back(status.clone());
        self.diff_redo_stack.push_back(payloads);

        Some(status)
    }

    pub fn redo(&mut self) -> Option<Status> {
        let mut status = self.redo_stack.pop_back()?;
        let mut payloads = self.diff_redo_stack.pop_back()?;

        std::mem::swap(&mut status, &mut self.current_status);
        std::mem::swap(&mut payloads, &mut self.current_diffs);

        self.undo_stack.push_back(status.clone());
        self.diff_undo_stack.push_back(payloads);

        Some(status)
    }

    // `None` means that users can not update the workbook to the latest one incremently.
    pub fn get_sheet_diffs_from_version(&self, sheet: SheetId, version: u32) -> Option<SheetDiff> {
        if version > self.version {
            return None;
        }

        if self.version - HISTORY_SIZE as u32 >= version {
            return None;
        }

        let start_idx = if self.version >= 50 {
            HISTORY_SIZE - 1 + (version - self.version) as usize
        } else {
            version as usize
        };

        let mut result: HashSet<Diff> = HashSet::new();

        for i in start_idx..self.undo_stack.len() {
            let sheet_diffs = self.diff_undo_stack.get(i)?;
            if let Some(diff) = sheet_diffs.get(&sheet) {
                if diff.diff_unavailable() {
                    return None;
                }
                result.extend(diff.data.clone())
            }
        }

        Some(SheetDiff { data: result })
    }
}