logisheets_controller 1.16.1

Core spreadsheet engine for LogiSheets: formula evaluation, dependency tracking, and undo/redo.
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

use imbl::hashmap::HashMap;
use logisheets_base::{ExtBookId, NameId};

/// Ids for defined names.
///
/// Names are case-insensitive, as in Excel: `=tax` and `=TAX` reach the same
/// id. The key is stored upper-cased and the spelling people see lives in
/// `display` — first the spelling a formula happened to use, then the one the
/// name was defined with.
#[derive(Debug, Clone)]
pub struct NameIdManager {
    pub next_available: NameId,
    pub ids: HashMap<(ExtBookId, String), NameId>,
    pub display: HashMap<NameId, (ExtBookId, String)>,
}

fn key(book: ExtBookId, name: &str) -> (ExtBookId, String) {
    (book, name.to_uppercase())
}

impl NameIdManager {
    pub fn new(start: NameId) -> Self {
        NameIdManager {
            next_available: start,
            ids: HashMap::new(),
            display: HashMap::new(),
        }
    }

    pub fn get_id(&mut self, value: &(ExtBookId, String)) -> NameId {
        let k = key(value.0, &value.1);
        if let Some(id) = self.ids.get(&k) {
            return *id;
        }
        let id = self.next_available;
        self.next_available += 1;
        self.ids.insert(k, id);
        self.display.insert(id, value.clone());
        id
    }

    /// The id of an already-known name, without registering it.
    pub fn find_id(&self, book: ExtBookId, name: &str) -> Option<NameId> {
        self.ids.get(&key(book, name)).copied()
    }

    pub fn get_string(&self, id: &NameId) -> Option<(ExtBookId, String)> {
        self.display.get(id).cloned()
    }

    /// Make `name` the spelling shown for `id` (case changes only).
    pub fn set_display(&mut self, id: NameId, name: &str) {
        if let Some((book, _)) = self.display.get(&id).cloned() {
            self.display.insert(id, (book, name.to_string()));
        }
    }

    /// Point `new_name` at `id` and stop resolving `old_name`. Formulas hold
    /// the id, so they follow the rename without being rewritten.
    pub fn rename(&mut self, id: NameId, book: ExtBookId, old_name: &str, new_name: &str) {
        self.ids.remove(&key(book, old_name));
        self.ids.insert(key(book, new_name), id);
        self.display.insert(id, (book, new_name.to_string()));
    }
}