Struct DictateRuntime 

pub(crate) struct DictateRuntime {
    pub(crate) recordings: HashMap<SessionSlot, LiveRecording>,
    pub(crate) finishing: Vec<FinishingTake>,
    pub(crate) set_recording: Option<SetRecording>,
    pub(crate) next_generation: u64,
    pub(crate) stop_pending: Option<(SessionSlot, Option<u64>, Instant)>,
}

Dictation state across every session. Every take is fed by a client’s own frames and holds no device, so several seats can dictate at once; several takes can also be finishing, because a new recording never waits for the previous transcript.

Fields

recordings: HashMap<SessionSlot, LiveRecording>

finishing: Vec<FinishingTake>

set_recording: Option<SetRecording>

next_generation: u64

Handed out with every take’s DictateStarted and echoed on its DictateEnded, so a resolver arriving after a newer take on the same key is recognisably stale. Starts at 1; 0 is the “matches nothing” value refusals carry.

stop_pending: Option<(SessionSlot, Option<u64>, Instant)>

A stop that arrived before the start it answers had registered, stamped on arrival and carrying its initiator so only a start by the same connection honours it. A registration honours it only while it is fresh - the race it exists for is scheduler-scale, so a park older than the window is a stop whose take already resolved (a refusal, a cap self-submit) and must not poison the next attempt.

Implementations

impl DictateRuntime

fn stop_channel_for( &self, key: &SessionSlot, initiator: Option<u64>, ) -> Option<Sender<bool>>

The stop channel to route a DictateStop for key to, if a recording or a submitted take belongs to it AND to the connection that sent the stop: only the take’s own connection can stop it.

pub(crate) fn live_holder(&self) -> Option<String>

The seat holding a live capture, when one is: a recording still capturing, a submitted take still transcribing, or the read-aloud set being recorded. A model swap and a bench are refused while one is, and the refusal names this holder.

pub(crate) fn frame_sink_for( &self, key: &SessionSlot, initiator: Option<u64>, ) -> Option<&FrameSink>

The live take a socket’s frame belongs to, if key has one that the pushing connection started.

The take must be the pushing connection’s own, because a seat’s live take can be another connection’s - decision 3’s own scenario, where a client whose start was refused still has its microphone open for the frames already on the wire. Answering None for a foreign take is what keeps one client’s microphone out of another client’s dictation.

fn take_parked_stop( &mut self, key: &SessionSlot, initiator: Option<u64>, now: Instant, ) -> bool

Consume key’s parked stop, answering whether it still races its start’s registration and should pre-load an abandon. A stale park for the key is consumed without honour; another key’s - or another connection’s - park is left alone.

pub(crate) fn clear_stop_pending( &mut self, key: &SessionSlot, initiator: Option<u64>, )

Drop key’s parked stop, if any: the take it answered has resolved some other way, and a left-behind park would poison the session’s next attempt.

Trait Implementations

impl Default for DictateRuntime

fn default() -> Self

Returns the “default value” for a type.