Struct ReceiveTimeout 

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

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

Only successful user communications are activity. Timer, peer, child, worker, and shutdown service events compose through this wrapper but never rearm it. A matching timeout consumes the live generation before invoking the reaction; if that reaction continues, the timeout remains unarmed until another successful continuing user communication.

Implementations

impl<B: Behavior> ReceiveTimeout<B>

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

pub fn inner(&self) -> &B

Trait Implementations

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

where A: Address, Sends: SendAlgebra, Br: BirthMode, B: Behavior<Addr = A, Ph = Ph, Sends = Sends, Birth = Br>, B::Event: TimeEvent,

type Addr = A

type Msg = <B as Behavior>::Msg

type Event = TimedEvent<<B as Behavior>::Event>

type Sends = ReceiveTimeoutSends<Sends>

type Ph = Ph

type Error = ReceiveTimeoutError<<B as Behavior>::Error>

type Birth = Br

fn init(&mut self) -> Result<ReceiveTimeoutActions<B>, Self::Error>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, event: Self::Event, ) -> Result<ReceiveTimeoutActions<B>, Self::Error>

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

fn receive( &mut self, from: Self::Addr, message: Self::Msg, ) -> BehaviorActed<Self>

where Self: Sized,

Fold one user communication through the composed protocol.

fn on<Input>(&mut self, input: Input) -> BehaviorActed<Self>

where Self: Sized, Self::Event: EventInput<Input>,

Inject one supported semantic input and fold it through this behavior.