use crate::error::EngineError;
use crate::qualified::Prepared;
use crate::resolver::EngineResolver;
use crate::workbook;
use crate::CellId;
use formula_lang::ExcelError;
use sheet_core::{Cell, DependencyGraph, Sheet};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::string::String;
use std::vec::Vec;
pub struct Engine {
sheets: BTreeMap<String, Sheet>,
graphs: BTreeMap<String, DependencyGraph>,
cross_precedents: HashMap<CellId, BTreeSet<CellId>>,
cross_dependents: HashMap<CellId, BTreeSet<CellId>>,
formulas: BTreeMap<CellId, Prepared>,
qualified: BTreeSet<CellId>,
volatile: BTreeSet<CellId>,
values: HashMap<CellId, formula_lang::Value>,
dirty: HashSet<CellId>,
order_cache: Option<Vec<CellId>>,
}
impl Engine {
#[must_use]
pub fn new() -> Self {
Self {
sheets: BTreeMap::new(),
graphs: BTreeMap::new(),
cross_precedents: HashMap::new(),
cross_dependents: HashMap::new(),
formulas: BTreeMap::new(),
qualified: BTreeSet::new(),
volatile: BTreeSet::new(),
values: HashMap::new(),
dirty: HashSet::new(),
order_cache: None,
}
}
}
impl Default for Engine {
fn default() -> Self {
Engine::new()
}
}
impl Engine {
#[must_use]
pub fn sheet_names(&self) -> Vec<String> {
self.sheets.keys().cloned().collect()
}
#[must_use]
pub fn has_sheet(&self, sheet: &str) -> bool {
self.sheets.contains_key(sheet)
}
#[must_use]
pub fn get_value(&self, sheet: &str, row: u32, col: u32) -> Option<formula_lang::Value> {
self.values.get(&(sheet.to_string(), row, col)).cloned()
}
#[must_use]
pub fn volatile_cells(&self) -> Vec<CellId> {
self.volatile.iter().cloned().collect()
}
pub fn set_cell(
&mut self,
sheet: &str,
row: u32,
col: u32,
input: &str,
) -> Result<(), EngineError> {
let input = input.trim();
if input.starts_with('=') {
return self.set_formula(sheet, row, col, input);
}
let (cell, value) = literal(input);
let node = (sheet.to_string(), row, col);
self.unregister_formula(&node);
self.sheets
.entry(node.0.clone())
.or_default()
.set(row, col, cell);
self.values.insert(node.clone(), value);
self.dirty.insert(node);
Ok(())
}
pub fn recalculate(&mut self) -> Result<(), EngineError> {
let order = self.topo();
let mut circular = None;
if order.len() < self.formulas.len() {
let placed: BTreeSet<&CellId> = order.iter().collect();
let leftover: Vec<CellId> = self
.formulas
.keys()
.filter(|n| !placed.contains(*n))
.cloned()
.collect();
circular = Some(workbook::circular_members(self, &leftover));
}
for node in order {
self.evaluate_node(&node);
}
self.dirty.clear();
match circular {
Some(cells) => Err(EngineError::CircularReference(cells)),
None => Ok(()),
}
}
pub fn recalculate_incremental(
&mut self,
edited: &[(String, u32, u32)],
) -> Result<(), EngineError> {
let seeds = self.dirty.iter().cloned().chain(edited.iter().cloned());
let mut work = workbook::dirty_closure(self, seeds);
for v in self.volatile.clone() {
work.insert(v);
}
let order = workbook::topological_order_restricted(self, &work);
let mut circular = None;
let placed: BTreeSet<&CellId> = order.iter().collect();
let leftover: Vec<CellId> = work
.iter()
.filter(|n| self.formulas.contains_key(*n) && !placed.contains(*n))
.cloned()
.collect();
if !leftover.is_empty() {
let members = workbook::circular_members(self, &leftover);
if !members.is_empty() {
circular = Some(members);
}
}
for node in order {
self.evaluate_node(&node);
}
self.dirty.clear();
match circular {
Some(cells) => Err(EngineError::CircularReference(cells)),
None => Ok(()),
}
}
pub fn to_xlsx(&self) -> Result<Vec<u8>, EngineError> {
crate::xlsx_codec::to_xlsx(self)
}
pub fn from_xlsx(data: &[u8]) -> Result<Self, EngineError> {
crate::xlsx_codec::from_xlsx(data)
}
pub(crate) fn sheets_ref(&self) -> &BTreeMap<String, Sheet> {
&self.sheets
}
pub(crate) fn open_sheet(&mut self, sheet: &str) {
self.sheets.entry(sheet.to_string()).or_default();
self.graphs.entry(sheet.to_string()).or_default();
}
pub(crate) fn insert_literal(
&mut self,
sheet: &str,
row: u32,
col: u32,
cell: Cell,
value: formula_lang::Value,
) {
let node = (sheet.to_string(), row, col);
self.unregister_formula(&node);
self.sheets
.entry(node.0.clone())
.or_default()
.set(row, col, cell);
self.values.insert(node, value);
}
pub(crate) fn insert_cached(&mut self, node: CellId, value: formula_lang::Value) {
self.values.insert(node, value);
}
pub(crate) fn register_loaded_formula(
&mut self,
sheet: &str,
row: u32,
col: u32,
text: &str,
) -> Result<(), EngineError> {
self.register_formula(sheet, row, col, text, false)
}
fn topo(&mut self) -> Vec<CellId> {
if let Some(order) = &self.order_cache {
return order.clone();
}
let order = workbook::topological_order(self);
self.order_cache = Some(order.clone());
order
}
pub(crate) fn graph_for(&self, sheet: &str) -> Option<&DependencyGraph> {
self.graphs.get(sheet)
}
pub(crate) fn cross_precedents(&self, node: &CellId) -> Option<&BTreeSet<CellId>> {
self.cross_precedents.get(node)
}
pub(crate) fn cross_dependents(&self, node: &CellId) -> Option<&BTreeSet<CellId>> {
self.cross_dependents.get(node)
}
pub(crate) fn formula_nodes(&self) -> BTreeSet<CellId> {
self.formulas.keys().cloned().collect()
}
pub(crate) fn cached(&self, node: &CellId) -> Option<formula_lang::Value> {
self.values.get(node).cloned()
}
fn set_formula(
&mut self,
sheet: &str,
row: u32,
col: u32,
text: &str,
) -> Result<(), EngineError> {
self.register_formula(sheet, row, col, text, true)
}
fn register_formula(
&mut self,
sheet: &str,
row: u32,
col: u32,
text: &str,
mark_dirty: bool,
) -> Result<(), EngineError> {
let prepared = crate::qualified::prepare(text)?;
let registration = if prepared.stubs.is_empty() {
Some(String::from(text))
} else {
prepared.local_registration_text()
};
let has_stubs = !prepared.stubs.is_empty();
let volatile = prepared.volatile;
let targets: BTreeSet<CellId> = prepared
.stubs
.iter()
.flat_map(|s| {
let sheet = s.target.0.clone();
let base = (s.target.1, s.target.2);
(0..s.rows).flat_map(move |r| {
let sheet = sheet.clone();
(0..s.cols).map(move |c| (sheet.clone(), base.0 + r, base.1 + c))
})
})
.collect();
let node = (sheet.to_string(), row, col);
self.unregister_formula(&node);
let graph = self.graphs.entry(node.0.clone()).or_default();
if let Some(reg) = registration.as_deref() {
graph.add_formula((row, col), reg)?;
}
self.sheets
.entry(node.0.clone())
.or_default()
.set(row, col, Cell::formula(text));
self.formulas.insert(node.clone(), prepared);
if has_stubs {
self.qualified.insert(node.clone());
for t in &targets {
self.cross_dependents
.entry(t.clone())
.or_default()
.insert(node.clone());
}
self.cross_precedents.insert(node.clone(), targets);
}
if volatile {
self.volatile.insert(node.clone());
}
if mark_dirty {
self.dirty.insert(node);
}
self.order_cache = None;
Ok(())
}
fn unregister_formula(&mut self, node: &CellId) {
if self.formulas.remove(node).is_none() {
return;
}
self.order_cache = None;
let (sheet, row, col) = (node.0.clone(), node.1, node.2);
if let Some(graph) = self.graphs.get_mut(&sheet) {
graph.remove_formula((row, col));
}
if let Some(targets) = self.cross_precedents.remove(node) {
for t in targets {
if let Some(readers) = self.cross_dependents.get_mut(&t) {
readers.remove(node);
if readers.is_empty() {
self.cross_dependents.remove(&t);
}
}
}
}
self.qualified.remove(node);
self.volatile.remove(node);
self.values.remove(node);
}
fn evaluate_node(&mut self, node: &CellId) {
let Some(prepared) = self.formulas.get(node) else {
return;
};
let resolver = EngineResolver::new(self, &node.0, prepared);
let evaluated = formula_lang::evaluate(&prepared.expr, &resolver);
let value = match evaluated {
Ok(v) => v,
Err(formula_lang::FormulaError::Eval(e)) => formula_lang::Value::Error(e),
Err(_) => formula_lang::Value::Error(ExcelError::Value),
};
self.values.insert(node.clone(), value);
}
}
impl core::fmt::Debug for Engine {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Engine")
.field("sheets", &self.sheets)
.field("graphs", &self.graphs)
.field("formulas", &self.formulas.keys().collect::<Vec<_>>())
.field("qualified", &self.qualified)
.field("volatile", &self.volatile)
.field("values", &self.values)
.field("dirty", &self.dirty)
.finish_non_exhaustive()
}
}
fn literal(input: &str) -> (Cell, formula_lang::Value) {
if let Some(v) = ExcelError::from_literal(input) {
return (Cell::error(sheet_error(v)), formula_lang::Value::Error(v));
}
match input.to_ascii_uppercase().as_str() {
"TRUE" => return (Cell::boolean(true), formula_lang::Value::Boolean(true)),
"FALSE" => return (Cell::boolean(false), formula_lang::Value::Boolean(false)),
_ => {}
}
if let Some(n) = numeric(input) {
return (Cell::number(n), formula_lang::Value::Number(n));
}
(
Cell::text(String::from(input)),
formula_lang::Value::Text(String::from(input)),
)
}
fn numeric(input: &str) -> Option<f64> {
let first = input.chars().next()?;
if !(first.is_ascii_digit() || first == '+' || first == '-' || first == '.') {
return None;
}
input.parse::<f64>().ok().filter(|v| v.is_finite())
}
fn sheet_error(e: ExcelError) -> sheet_core::ExcelError {
match e {
ExcelError::DivZero => sheet_core::ExcelError::Div0,
ExcelError::NA => sheet_core::ExcelError::Na,
ExcelError::Name => sheet_core::ExcelError::Name,
ExcelError::Null => sheet_core::ExcelError::Null,
ExcelError::Num => sheet_core::ExcelError::Num,
ExcelError::Ref => sheet_core::ExcelError::Ref,
ExcelError::Value => sheet_core::ExcelError::Value,
}
}