formualizer-workbook 0.5.6

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
85
86
87
88
89
90
91
92
93
94

use std::sync::{Arc, RwLock};

use crate::{RangeAddress, Workbook};
use formualizer_common::LiteralValue;
use std::collections::BTreeMap;

/// A bindings-friendly worksheet handle backed by an Arc<RwLock<Workbook>>.
/// For native Rust, prefer borrowing APIs on `Workbook` directly for better ergonomics.
#[derive(Clone)]
pub struct WorksheetHandle {
    wb: Arc<RwLock<Workbook>>,
    name: Arc<str>,
}

impl WorksheetHandle {
    pub fn new(wb: Arc<RwLock<Workbook>>, name: impl Into<Arc<str>>) -> Self {
        Self {
            wb,
            name: name.into(),
        }
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn get_value(&self, row: u32, col: u32) -> Option<LiteralValue> {
        self.wb
            .read()
            .ok()
            .and_then(|w| w.get_value(&self.name, row, col))
    }
    pub fn get_formula(&self, row: u32, col: u32) -> Option<String> {
        self.wb
            .read()
            .ok()
            .and_then(|w| w.get_formula(&self.name, row, col))
    }
    pub fn set_value(&self, row: u32, col: u32, v: LiteralValue) -> Result<(), crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .set_value(&self.name, row, col, v)
    }
    pub fn set_formula(&self, row: u32, col: u32, f: &str) -> Result<(), crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .set_formula(&self.name, row, col, f)
    }
    pub fn set_values(
        &self,
        start_row: u32,
        start_col: u32,
        rows: &[Vec<LiteralValue>],
    ) -> Result<(), crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .set_values(&self.name, start_row, start_col, rows)
    }
    pub fn set_formulas(
        &self,
        start_row: u32,
        start_col: u32,
        rows: &[Vec<String>],
    ) -> Result<(), crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .set_formulas(&self.name, start_row, start_col, rows)
    }
    pub fn read_range(&self, addr: &RangeAddress) -> Vec<Vec<LiteralValue>> {
        self.wb
            .read()
            .map(|w| w.read_range(addr))
            .unwrap_or_default()
    }
    pub fn write_range(
        &self,
        cells: BTreeMap<(u32, u32), crate::traits::CellData>,
    ) -> Result<(), crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .write_range(&self.name, (1, 1), cells)
    }
    pub fn evaluate_cell(&self, row: u32, col: u32) -> Result<LiteralValue, crate::IoError> {
        self.wb
            .write()
            .map_err(|_| crate::IoError::Io(std::io::Error::other("lock")))?
            .evaluate_cell(&self.name, row, col)
    }
}