Struct SnapshotHook 

pub struct SnapshotHook<T, S = OnProcess> { /* private fields */ }

A hook handle controlling a snapshot operator over a singleton of T. S is the handle’s scope.

A decision for a snapshot hook picks which buffered version of the state the next tick execution observes. See hydro_lang::sim::hooks for the decisions offered.

Implementations

impl<T, Scope: ScriptableHookScope> SnapshotHook<T, Scope>

pub fn reveal(&self, value: T) -> DecisionFuture

where T: Serialize + DeserializeOwned,

Available on crate feature sim only.

Scripts the next tick execution to observe the buffered version equal to value: scans forward from the currently-revealed version through the buffered ones and releases the first equal version, skipping over earlier versions.

This is a combined assertion and release, and the recommended way to script snapshots: a script written with positional decisions breaks silently when the program changes how often the state updates, while reveal(value) names the state it means and any mis-synchronization fails loudly at the reveal.

pub fn reveal_next(&self) -> DecisionFuture

where T: Serialize + DeserializeOwned,

Available on crate feature sim only.

Scripts the next tick execution to observe the next buffered version.

pub fn reveal_latest(&self) -> DecisionFuture

where T: Serialize + DeserializeOwned,

Available on crate feature sim only.

Scripts the next tick execution to observe the newest version that has arrived by the time the tick fires. Under fuzzing, which version is newest co-varies with the schedule being explored; use Self::reveal to name it exactly.

pub fn keep(&self) -> DecisionFuture

where T: Serialize + DeserializeOwned,

Available on crate feature sim only.

Scripts the next tick execution to observe the previously revealed version again.

pub fn pause(&self)

Available on crate feature sim only.

Declares that buffering at this operator is intended: while paused, the hook is exempt from the missing-decision error, never causes its tick to run, and — if its tick runs anyway because other hooks feed it — contributes its “nothing new” behavior each time. Scripting any decision implicitly resumes the hook.

A pause takes its place in the script like everything else: requested while a decision is still pending, the hold begins once that decision has been consumed.

pub fn resume(&self)

Available on crate feature sim only.

Ends a Self::pause (and clears Self::auto_pause mode).

pub fn auto_pause(&self)

Available on crate feature sim only.

Sets a standing mode where this hook only ever acts when scripted: it holds immediately, and every scripted decision leaves a fresh hold in place behind it.

This deliberately opts out of the forgotten-hook protection: if the test forgets a step, the operator silently holds its data instead of failing. The one auto_pause() line at the top of a test is the reviewer-visible marker that this hook’s timing is entirely script-driven, missed steps and all.

pub async fn pause_while<Fut: Future>(&self, body: Fut) -> Fut::Output

Available on crate feature sim only.

Pauses the hook exactly for the duration of body (resuming even on panic), so a bracketed buffering phase cannot leak a paused hook.

pub fn pause_until( &self, predicate: impl Fn(&SnapshotStatus) -> bool + Unpin, ) -> PauseUntilFuture<SnapshotStatus, impl Fn(&SnapshotStatus) -> bool + Unpin>

Available on crate feature sim only.

Pauses the hook and returns a future that resolves once the hook’s pending-input status satisfies predicate — a synchronization point for scripts where the right decision is not knowable upfront. The status is read on demand at every scheduling point. After the future resolves, the hook is unpaused; the ordinary missing-decision error applies from there on.

pub fn pause_until_versions( &self, n: usize, ) -> PauseUntilFuture<SnapshotStatus, impl Fn(&SnapshotStatus) -> bool + Unpin>

Available on crate feature sim only.

Pauses the hook and returns a future that resolves once at least n newer versions are buffered; see Self::pause_until.

impl<T, C> SnapshotHook<T, OnCluster<C>>

pub fn on(&self, member_id: u32) -> SnapshotHook<T, OnMember<C>>

Selects one cluster member’s instance of the hooked operator, returning an OnMember-scoped handle with the full scripting API.

Each member’s instance is scripted independently: handle.on(0).release(2) scripts member 0’s next batch and says nothing about the other members, each of which needs its own decision (or pause) when it holds buffered input. A member ID outside the cluster’s sizing is reported when the scripting call is awaited.

Trait Implementations

impl<T, S> Clone for SnapshotHook<T, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, S> Copy for SnapshotHook<T, S>

impl<T, S> Debug for SnapshotHook<T, S>

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

Formats the value using the given formatter.

impl<T, S: BindableHookScope> SimHook for SnapshotHook<T, S>

where T: Clone + PartialEq + Serialize + DeserializeOwned,

fn create(next_id: &mut dyn FnMut() -> usize) -> Self

Creates every handle in this value, allocating fresh IDs via next_id.