Struct RealtimeGenerationState 

pub struct RealtimeGenerationState<M, S, R, C> { /* private fields */ }

Canonical composite state for realtime model generation.

C is the exact completion type returned by a concrete SubmissionBackend. It is carried at the type level so a branch cannot be published using an unrelated completion kind.

Implementations

impl<M, S, R, C> RealtimeGenerationState<M, S, R, C>

where M: SemanticStateTransaction, M::Error: 'static, C: Completion,

pub fn new( model_state: M, schedule: RealtimeSpeechConfig, samplers: Vec<S>, random_state: Option<R>, ) -> Result<Self, RealtimeGenerationTransactionError<M::Error, C::Error>>

Creates canonical state bound to one exact normalized schedule.

pub fn from_parts( model_state: M, schedule: &RealtimeSpeechConfig, schedule_state: RealtimeFrameScheduleState, samplers: Vec<S>, random_state: Option<R>, ) -> Result<Self, RealtimeGenerationTransactionError<M::Error, C::Error>>

Validates and adopts an existing portable schedule state.

This constructor is useful when resuming in-memory state: the state must carry the same complete schedule identity, not merely equal dimensions.

pub const fn model_state(&self) -> &M

Borrows canonical model/cache state.

pub const fn schedule_state(&self) -> &RealtimeFrameScheduleState

Borrows canonical delayed-frame state.

pub fn samplers(&self) -> &[S]

Borrows canonical sampler states in text-plus-depth order.

pub const fn random_state(&self) -> Option<&R>

Borrows canonical backend random state.

pub fn set_random_state(&mut self, random_state: Option<R>)

Replaces backend randomness while the canonical request is idle.

pub fn set_samplers( &mut self, samplers: Vec<S>, ) -> Result<(), RealtimeGenerationTransactionError<M::Error, C::Error>>

Replaces sampler state while the canonical request is idle.

pub fn execute_frame_transition<T>( &mut self, frame: &RealtimeInputFrame, transition: &mut T, ) -> Result<T::Output, RealtimeFrameExecutionError<T::Error, RealtimeGenerationTransactionError<M::Error, C::Error>>>

where S: Clone, R: Clone, T: RealtimeFrameTransition<M::Branch, S, R, C>,

Executes one ingress-dependent transition and publishes every mutable component only after its exact completion succeeds.

pub fn commit_submission_branch<B>( &mut self, branch: RealtimeGenerationBranch<M::Branch, S, R, C>, ) -> Result<(), RealtimeGenerationTransactionError<M::Error, C::Error>>

where B: SubmissionBackend<Completion = C>, S: Clone, R: Clone,

Publishes a branch only after the concrete backend’s exact completion has reported completion and successful waiting.

The backend bound proves that C is a SubmissionBackend::Completion rather than architecture-owned or family-specific completion metadata.

Trait Implementations

impl<M: Debug, S: Debug, R: Debug, C: Debug> Debug for RealtimeGenerationState<M, S, R, C>

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

Formats the value using the given formatter.

impl<M, S, R, C> SemanticStateTransaction for RealtimeGenerationState<M, S, R, C>

where M: SemanticStateTransaction, M::Error: 'static, S: Clone, R: Clone, C: Completion,

type Branch = RealtimeGenerationBranch<<M as SemanticStateTransaction>::Branch, S, R, C>

Transition-local branch.

type Error = RealtimeGenerationTransactionError<<M as SemanticStateTransaction>::Error, <C as Completion>::Error>

State error.

fn branch(&self) -> Result<Self::Branch, Self::Error>

Creates an unpublished branch.

fn commit_branch(&mut self, branch: Self::Branch) -> Result<(), Self::Error>

Publishes a completed branch.

fn discard_branch(branch: Self::Branch) -> Result<(), Self::Error>

Discards an unpublished branch.

fn permits_parallel_branches(&self) -> bool

Whether independent branches may share the current canonical base.