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
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use logisheets_base::Addr;
use logisheets_base::CellValue;
use logisheets_base::EphemeralId;
use logisheets_base::SheetId;
use logisheets_base::TextId;
use logisheets_base::cube_value::CubeValue;
use logisheets_base::matrix_value::MatrixValue;
use logisheets_parser::ast;

#[derive(Debug, Clone)]
pub enum CalcVertex {
    Value(CalcValue),
    Reference(CalcReference),
    Union(Vec<Box<CalcVertex>>), // comma operator
    Ephemeral((SheetId, EphemeralId)),
}

impl CalcVertex {
    pub fn from_error(e: ast::Error) -> Self {
        CalcVertex::Value(CalcValue::Scalar(Value::Error(e)))
    }

    pub fn from_number(n: f64) -> Self {
        CalcVertex::Value(CalcValue::Scalar(Value::Number(n)))
    }

    pub fn from_string(s: String) -> Self {
        CalcVertex::Value(CalcValue::Scalar(Value::Text(s)))
    }

    pub fn from_bool(b: bool) -> Self {
        CalcVertex::Value(CalcValue::Scalar(Value::Boolean(b)))
    }

    pub fn from_text(t: String) -> Self {
        CalcVertex::Value(CalcValue::Scalar(Value::Text(t)))
    }
}

#[derive(Debug, Clone)]
pub enum CalcValue {
    Scalar(Value),
    Range(MatrixValue<Value>),
    Cube(CubeValue<Value>),
    Union(Vec<Box<CalcValue>>), // comma operator
}

impl CalcValue {
    /// The text a custom (async) function receives for this argument. Its
    /// arguments cross to the host as plain strings, so only a scalar has a
    /// representation: a range, 3D range or union is `Err(#VALUE!)`.
    pub fn to_async_arg(self) -> Result<String, ast::Error> {
        Ok(match self {
            CalcValue::Scalar(v) => match v {
                Value::Blank => String::from(""),
                Value::Number(n) => super::number_text::number_to_text(n),
                Value::Text(t) => t,
                Value::Boolean(b) => {
                    if b {
                        String::from("TRUE")
                    } else {
                        String::from("FALSE")
                    }
                }
                Value::Error(e) => e.get_err_str().to_string(),
            },
            CalcValue::Range(_) | CalcValue::Cube(_) | CalcValue::Union(_) => {
                return Err(ast::Error::Value);
            }
        })
    }
}

#[derive(Debug, Clone)]
pub enum Value {
    Blank,
    Number(f64),
    Text(String),
    Boolean(bool),
    Error(ast::Error),
}

impl Default for Value {
    fn default() -> Self {
        Value::Blank
    }
}

impl Value {
    pub fn from_ast_value(v: &ast::Value) -> Self {
        match v {
            ast::Value::Blank => Value::Blank,
            ast::Value::Number(f) => Value::Number(f.clone()),
            ast::Value::Text(s) => Value::Text(s.clone()),
            ast::Value::Boolean(b) => Value::Boolean(b.clone()),
            ast::Value::Error(e) => Value::Error(e.clone()),
        }
    }

    pub fn from_cell_value<F>(v: CellValue, fetcher: &F) -> Self
    where
        F: Fn(&TextId) -> Option<String>,
    {
        match v {
            CellValue::Blank => Value::Blank,
            CellValue::Boolean(b) => Value::Boolean(b),
            CellValue::Error(e) => Value::Error(ast::Error::from_err_str(&e.to_string())),
            CellValue::String(tid) => Value::Text(fetcher(&tid).unwrap_or(String::from(""))),
            CellValue::Number(f) => Value::Number(f),
            // Text like any other. This `todo!()` was unreachable while
            // inline strings never loaded; the moment they did, any formula
            // reading a label written that way brought the process down.
            CellValue::InlineStr(rst) => Value::Text(rst.plain_text()),
            CellValue::FormulaStr(s) => Value::Text(s),
        }
    }
}

#[derive(Debug, Clone)]
pub struct CalcReference {
    pub from_sheet: Option<SheetId>,
    pub sheet: SheetId,
    pub reference: Reference,
}

#[derive(Debug, Clone)]
pub enum Reference {
    Addr(Addr),
    ColumnRange(ColRange),
    RowRange(RowRange),
    Range(Addr, Addr),
}

#[derive(Debug, Clone)]
pub struct ColRange {
    pub start: usize,
    pub end: usize,
}

#[derive(Debug, Clone)]
pub struct RowRange {
    pub start: usize,
    pub end: usize,
}