formualizer-workbook 0.6.0

Ergonomic workbook API over the Formualizer engine (sheets, loaders, staging, 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

use crate::IoError;
use formualizer_eval::engine::WorkbookLoadLimits;

pub(crate) fn use_sparse_initial_ingest(
    rows: u32,
    cols: u32,
    populated_cells: usize,
    limits: &WorkbookLoadLimits,
) -> bool {
    if rows == 0 || cols == 0 {
        return false;
    }

    let logical_cells = u64::from(rows) * u64::from(cols);
    let populated = populated_cells.max(1) as u64;
    let sparse_limit = populated.saturating_mul(limits.max_sparse_cell_ratio);

    logical_cells > sparse_limit
        && (logical_cells >= limits.sparse_sheet_cell_threshold
            || logical_cells > limits.max_sheet_logical_cells)
}

pub(crate) fn enforce_sheet_dimension_limits(
    backend: &str,
    sheet: &str,
    rows: u32,
    cols: u32,
    limits: &WorkbookLoadLimits,
) -> Result<(), IoError> {
    if rows == 0 || cols == 0 {
        return Ok(());
    }

    if rows > limits.max_sheet_rows {
        return Err(IoError::load_budget_exceeded(
            backend,
            sheet,
            format!(
                "sheet has {rows} rows, which exceeds the configured row budget of {}",
                limits.max_sheet_rows
            ),
        ));
    }

    if cols > limits.max_sheet_cols {
        return Err(IoError::load_budget_exceeded(
            backend,
            sheet,
            format!(
                "sheet has {cols} columns, which exceeds the configured column budget of {}",
                limits.max_sheet_cols
            ),
        ));
    }

    Ok(())
}

pub(crate) fn enforce_sheet_load_limits(
    backend: &str,
    sheet: &str,
    rows: u32,
    cols: u32,
    populated_cells: usize,
    limits: &WorkbookLoadLimits,
) -> Result<(), IoError> {
    enforce_sheet_dimension_limits(backend, sheet, rows, cols, limits)?;

    let logical_cells = u64::from(rows) * u64::from(cols);
    if !use_sparse_initial_ingest(rows, cols, populated_cells, limits)
        && logical_cells > limits.max_sheet_logical_cells
    {
        return Err(IoError::load_budget_exceeded(
            backend,
            sheet,
            format!(
                "sheet logical rectangle {rows}x{cols} ({logical_cells} cells) exceeds the configured logical-cell budget of {}",
                limits.max_sheet_logical_cells
            ),
        ));
    }

    Ok(())
}