Struct OccState 

struct OccState {
    payload: Vec<(Row, Diff)>,
    pending: Vec<(Row, Timestamp, Diff)>,
    split: Option<Timestamp>,
    current_upper: Option<Timestamp>,
    retry_count: usize,
    byte_size: u64,
}

Accumulated state for the OCC loop in run_occ_loop.

Every diff the subscribe ever sent is kept, split at Self::split. The split only rises, so each diff crosses it once.

Fields

payload: Vec<(Row, Diff)>

Consolidated net diffs from strictly below Self::split.

pending: Vec<(Row, Timestamp, Diff)>

Diffs at or above Self::split, consolidated by (row, timestamp).

split: Option<Timestamp>

Where the last fold split the diffs, None before the first one.

current_upper: Option<Timestamp>

Timestamp of the last progress message, which certifies that no diff will arrive below it.

retry_count: usize

byte_size: u64

Row bytes held in payload and pending together, which is what the max_result_size check measures. pending is consolidated by (row, timestamp), so a row touched at several timestamps occupies several entries until a rising split folds them together, and the count can exceed the size of the payload that eventually goes out.

Implementations

impl OccState

fn new() -> Self

fn fold_below(&mut self, split: Timestamp)

Raises the split to split, moving the diffs below it into the payload.

Lowering it is a bug: the payload is consolidated and never re-split, so the diffs above a lowered split would stay in it. We clamp to the old split, which keeps the payload’s contract intact.

fn fold_all(&mut self)

Moves every accumulated diff into the payload, whatever its timestamp.

Only valid once the subscribe has run to completion, where the diffs are frontier-independent and no split separates them.

fn fold(&mut self, split: Option<Timestamp>)

Moves the diffs below split, or all of them when it is None, into the payload, consolidates both halves, and recomputes byte_size.

fn is_empty(&self) -> bool

Whether nothing has been accumulated on either side of the split.