Struct OneShot 

pub struct OneShot<B: Behavior> { /* private fields */ }

Infallible fold invoked for the one accepted timer generation.

fn fallible(_: &mut App) -> behavior::BehaviorActed<App> { Ok(behavior::Actions::cont()) }
let _ = behavior_actors::OneShot::new(App, behavior_actors::TimerId(1), std::time::Duration::ZERO, fallible);

Notify a wrapped behavior once after a relative delay.

Initialization first preserves the wrapped initialization actions, then emits one generation-tagged ScheduleAfter request. A matching elapsed event is consumed exactly once and folds on_elapsed; stale and duplicate generations are inert unless the wrapped event sum independently accepts them. Reaction sends, creations, and termination are preserved. Reactions are infallible because they receive mutable access to the wrapped behavior; ordinary delegated transitions retain the wrapped error type. The timer never rearms. Generation exhaustion disables scheduling without affecting the wrapped fold. These timer and ordering rules are Bombay policy; sleeping and clock interpretation belong to bombay-timers.

Implementations

impl<B: Behavior> OneShot<B>

pub fn new( inner: B, id: TimerId, after: Duration, on_elapsed: TimedReaction<B>, ) -> Self

Construct a relative one-shot wrapper definition.

Trait Implementations

impl<B, A, Ph, Sends, Br> Behavior for OneShot<B>

where A: Address, Sends: SendEffects + SendsFor<B::Event>, Br: BirthMode, B: Behavior<Ph = Ph, Sends = Sends, Birth = Br>, B::Protocol: Protocol<Addr = A>,

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = EventLayer<TimerElapsed, <B as Behavior>::Event>

type Sends = SendLayer<InterpreterRequests<ScheduleAfter>, Sends>

type Ph = Ph

type Error = <B as Behavior>::Error

type Birth = Br

fn init(&mut self, _: InitializationTurn) -> BehaviorActed<Self>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<B: Behavior + BehaviorBase> BehaviorBase for OneShot<B>

type Base = <B as BehaviorBase>::Base

fn base(&self) -> &Self::Base