Struct ReceiveTimeout 

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

Infallible fold invoked for the accepted inactivity generation.

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

A pure one-notification-per-idle-period receive timeout.

Only successful user communications are activity. Timer, peer, child, worker, and shutdown interpreter events compose through this wrapper but never rearm it. A matching timeout invokes the infallible reaction and consumes the live generation. If that reaction continues, the timeout remains unarmed until another successful continuing user communication. Ordinary delegated transitions retain the wrapped error type.

Implementations

impl<B: Behavior> ReceiveTimeout<B>

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

Wrap inner with a relative inactivity timeout.

Initialization and each successful continuing user fold stage a fresh timer generation. Interpreter events do not reset inactivity.

Trait Implementations

impl<B, A, Ph, Sends, Br> Behavior for ReceiveTimeout<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, ) -> Result<Actions<BehaviorAddr<B>, <B as Behavior>::Ph, SendLayer<InterpreterRequests<ScheduleAfter>, <B as Behavior>::Sends>, <B as Behavior>::Birth>, Self::Error>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> Result<Actions<BehaviorAddr<B>, <B as Behavior>::Ph, SendLayer<InterpreterRequests<ScheduleAfter>, <B as Behavior>::Sends>, <B as Behavior>::Birth>, Self::Error>

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 ReceiveTimeout<B>

type Base = <B as BehaviorBase>::Base

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

impl<B> StashStatus for ReceiveTimeout<B>

where B: Behavior + StashStatus,

fn stashed_messages(&self) -> usize