Struct Calc 

pub struct Calc<'m> { /* private fields */ }

One recalculation of one model under one library: the plan made once, the cells evaluated in order, by steps or all at once.

Implementations

impl<'m> Calc<'m>

pub fn new(model: &'m Workbook, library: &'m Library) -> Calc<'m>

The plan over the model: every formula cell’s text read off the grid (a shared formula’s child as its master’s text moved), the graph built from refers, the order found and every cycle named. Nothing is evaluated yet.

pub fn run(model: &'m Workbook, library: &'m Library) -> Calc<'m>

The plan made and every cell evaluated.

pub fn model(&self) -> &'m Workbook

The model.

pub fn library(&self) -> &'m Library

The library.

pub fn plan(&self) -> &Plan

The plan: the order and the cycles.

pub fn cycles(&self) -> &[Vec<(usize, u32, u32)>]

Every cycle, each its cells sorted, the cycles by their first cell.

pub fn formulas(&self) -> usize

How many formula cells the model holds.

pub fn formula(&self, id: (usize, u32, u32)) -> Option<&str>

A formula cell’s text without its =, or None for a value cell.

pub fn formula_cells(&self) -> Vec<(usize, u32, u32)>

Every formula cell, in sheet then row-major order.

pub fn computed(&self, id: (usize, u32, u32)) -> Option<&Computed>

What a formula cell holds, once evaluated; None for a value cell or a cell the steps have not reached.

pub fn step(&mut self, budget: usize) -> Progress

Evaluate the next cells of the order, at most budget of them, 0 meaning every one: SD-34’s step, a budget in cells and never in time, so that the frame’s values are the same whatever the host’s chunking. The cells in a cycle count as done from the start.

pub fn progress(&self) -> Progress

Where the evaluation stands.

pub fn restart(&mut self)

Start the order again, every value forgotten but the cycles’.

pub fn missing_functions(&self) -> Vec<((usize, u32, u32), String)>

The functions the formulas call that the library does not hold, with the first cell calling each, in sheet then row-major order: what the engine’s load refuses by name before the first step.

pub fn spell_cell(&self, id: (usize, u32, u32)) -> String

Sheet!A1 for a cell, the sheet quoted as a reference quotes it.

pub fn first_refusal(&self) -> Option<Refusal>

The first thing that stops the whole grid from being stepped, as a refusal from the catalogue: a cycle, naming the cells that close it (calc-cycle), else the first function the library does not hold, naming the cell that calls it (calc-function-not-computed), else the first formula whose text this version does not read, naming the construct (calc-construct-not-read, KERNEL.22: the “unreadable reference” KERNEL.7’s fifth decision named for an engine’s load); None when every formula can be computed. An engine’s load asks this once; frazaro calc never does, since a workbook is read as it is and each cell says what it can.

Trait Implementations

impl Debug for Calc<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Env for Calc<'_>

fn model(&self) -> &Workbook

The model.

fn here(&self) -> (usize, u32, u32)

The cell being computed.

fn read(&self, id: (usize, u32, u32)) -> Result<Value, Reason>

A cell’s value now: a constant as it stands, a formula’s computed value, Empty for a cell with nothing; a formula not computed is the reason, which propagates.

fn extent(&self, sheet: usize) -> Option<((u32, u32), (u32, u32))>

A sheet’s used rectangle, cached by the caller.

fn name(&self, name: &str, scope: Option<usize>, home: usize) -> Option<&str>

The text of a defined name, resolved as graph::Names::resolve resolves it.

fn dense(&self, _sheet: usize) -> Option<&Dense>

A sheet’s values kept as an array over its extent, when the environment keeps one (KERNEL.20: an engine’s machine, for each .last twin; and since KERNEL.31 for each of its frame’s own sheets its plan reads by a range or a run’s moving cell, while none of their formulas holds a reason): each slot the value a read of its cell answers, or Value::Empty for a cell holding none, which a walk skips as a walk of the cells skips it; so a range of the sheet is walked by index and never cell by cell. None, a sheet walked through its cells, unless an environment says otherwise.

fn enter(&self, _id: (usize, u32, u32))

The cell being computed from now on, told by an evaluation of many cells at once before it computes at each (KERNEL.20, super::vector), so that Env::here answers it: an engine’s machine keeps it as it keeps the cell it evaluates alone. Nothing, unless an environment says otherwise.

impl Values for Calc<'_>

fn computed(&self, id: (usize, u32, u32)) -> Option<&Computed>

fn kept_extent(&self, sheet: usize) -> Option<Option<((u32, u32), (u32, u32))>>

A sheet’s extent where the values keep it (KERNEL.37), so that a view reads its extent row without walking every cell of the sheet: the extent itself, Some(None) for a sheet with no cell, or None to have the view walk the sheet. Calc keeps every sheet’s from its making, and an engine’s machine from its load and every write and frame’s end, for the evaluator (Env::extent).

fn lags(&self, _sheet: usize) -> bool

Whether some of a sheet’s cells hold content newer than the model’s (KERNEL.27): an engine’s machine makes a twin’s cells from its array only when a reader of the twin as a sheet asks, and the record and the plane read such a sheet’s cells through Values::content. No sheet, for any other.

fn content(&self, _id: (usize, u32, u32)) -> Option<Content>

A cell’s content where it is newer than the model’s, on a sheet that Values::lags; None for the model’s own.