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

use crate::calc_engine::calculator::calc_vertex::{CalcValue, Value};
use crate::id_manager::BookIdManager;
use im::{HashMap, Vector};
use logisheets_base::{Addr, ExtBookId, SheetId};
use logisheets_parser::ast;

#[derive(Debug, Clone)]
pub struct ExtBooksManager {
    pub book_id_manager: BookIdManager,
    pub books: HashMap<ExtBookId, ExtBook>,
    pub orders: Vector<ExtBookId>,
}

impl ExtBooksManager {
    pub fn new() -> Self {
        ExtBooksManager {
            book_id_manager: BookIdManager::new(0),
            books: HashMap::new(),
            orders: Vector::new(),
        }
    }

    pub fn fetch_book_name(&self, id: &ExtBookId) -> Option<String> {
        self.book_id_manager.get_string(id)
    }

    pub fn fetch_ext_book_id(&mut self, name: &str) -> ExtBookId {
        self.book_id_manager.get_or_register_id(name)
    }

    fn check(&mut self, book_id: ExtBookId, sheet_id: SheetId) {
        if !self.books.contains_key(&book_id) {
            let b = ExtBook::new_with_sheet_id(sheet_id);
            self.orders.push_back(book_id);
            self.books.insert(book_id, b);
            return;
        }
        let book = self.books.get_mut(&book_id).unwrap();
        if book.sheets.iter().find(|s| **s == sheet_id).is_none() {
            book.sheets.push_back(sheet_id);
        }
    }

    pub fn get_addr_range_value(
        &mut self,
        book_id: ExtBookId,
        from_sheet_id: Option<SheetId>,
        sheet_id: SheetId,
        _start: Addr,
        _end: Addr,
    ) -> CalcValue {
        self.check(book_id, sheet_id);
        if let Some(f) = from_sheet_id {
            self.check(book_id, f);
        }
        CalcValue::Scalar(Value::Error(ast::Error::Ref))
    }

    pub fn get_addr_value(
        &mut self,
        book_id: ExtBookId,
        sheet_id: SheetId,
        _addr: Addr,
    ) -> CalcValue {
        self.check(book_id, sheet_id);
        CalcValue::Scalar(Value::Error(ast::Error::Ref))
    }

    pub fn get_row_range_value(
        &mut self,
        book_id: ExtBookId,
        from_sheet_id: Option<SheetId>,
        sheet_id: SheetId,
        _start: usize,
        _end: usize,
    ) -> CalcValue {
        self.check(book_id, sheet_id);
        if let Some(f) = from_sheet_id {
            self.check(book_id, f);
        }
        CalcValue::Scalar(Value::Error(ast::Error::Ref))
    }

    pub fn get_col_range_value(
        &mut self,
        book_id: ExtBookId,
        from_sheet_id: Option<SheetId>,
        sheet_id: SheetId,
        _start: usize,
        _end: usize,
    ) -> CalcValue {
        self.check(book_id, sheet_id);
        if let Some(f) = from_sheet_id {
            self.check(book_id, f);
        }
        CalcValue::Scalar(Value::Error(ast::Error::Ref))
    }
}

#[derive(Debug, Clone)]
pub struct ExtBook {
    pub sheets: Vector<SheetId>,
    // TODO: external name.
    // pub names: Vector<(NameId, String)>,
    pub data_set: HashMap<(SheetId, Addr), Value>,
}

impl ExtBook {
    pub fn new_with_sheet_id(sheet_id: SheetId) -> Self {
        let mut sheets = Vector::new();
        sheets.push_back(sheet_id);
        ExtBook {
            sheets,
            data_set: HashMap::new(),
        }
    }
}