Struct ValueHistory 

pub struct ValueHistory<V, T, D> { /* private fields */ }

A loaded, time-ordered replay of one key’s (value, time, diff) edits, with meet-advanced buffer collapse — the shared machinery under the cursor reduce, the int_proxy tactics, and the common helpers. Its local contract: after advance_buffer_by(meet) with the meet of the un-replayed times, the buffer is consolidated and replay cost stays linear in edits rather than quadratic.

Implementations

impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: Semigroup> ValueHistory<V, T, D>

pub fn new() -> Self

An empty history, to be loaded.

pub fn clear(&mut self)

Discards all loaded state (capacity retained).

pub fn load_iter( &mut self, edits: impl Iterator<Item = (V, T, D)>, advance_by: Option<&T>, )

Loads edits from a plain iterator (grouped by consecutive value — the presentation order), advancing each time by advance_by if supplied, then organizes. This is the cursor-free ingestion path: the int_proxy tactics present (value_id, time, diff) runs directly rather than through a Cursor, and share this machinery instead of re-implementing it. Ungrouped input is still correct, only less compact.

impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + Semigroup> ValueHistory<V, T, D>

pub fn time(&self) -> Option<&T>

The next (least) un-replayed time.

pub fn meet(&self) -> Option<&T>

The meet of all un-replayed times.

pub fn edit(&self) -> Option<(V, &T, &D)>

The next un-replayed edit, as (value, time, diff).

pub fn buffer(&self) -> &[((V, T), D)]

The buffered (stepped-in, advanced, consolidated) edits.

pub fn step(&mut self)

Move the next edit into the buffer.

pub fn step_while_time_is(&mut self, time: &T) -> bool

Step edits while the next time equals time; true iff any did.

pub fn step_through(&mut self, time: &T)

Step edits while the next time is <= time in the TOTAL order (a superset of the partially-ordered downset; readers filter the buffer by less_equal themselves).

pub fn advance_buffer_by(&mut self, meet: &T)

Advance buffered times by meet and consolidate — the collapse that keeps replay linear.

pub fn is_done(&self) -> bool

True when every edit has been replayed.