Struct crossbus::delayer::Delayer

pub struct Delayer<A: Actor> { /* private fields */ }

send a delayed message with condition and get executed once the condition satisfied.

Implementations

impl<A: Actor> Delayer<A>

pub fn handle(&self) -> Handle

get the handle of the Delayer

pub fn state(&self) -> DelayerState

get the state

pub fn set_state(&mut self, state: DelayerState)

set the state

pub fn from_duration<T: Timing + 'static>( message: A::Message, delay: Duration ) -> Self

Available on crate feature time only.

deliver the message with specified delay duration

feature time must be enabled and the Timing implementation is required with which the actor can know the time

NOTE that the delayed duration is NO LESS than delay you specified, and is within minor deviation

pub fn instant(message: A::Message) -> Self

instantly deliver the message to its destination, and it nearly takes no time and it can be used as Messager

pub unsafe fn repeat<T: Timing + 'static>( message: A::Message, duration: Option<Duration>, repeats: Option<usize> ) -> Self

Available on crate feature time only.

periodically deliver the message to its destination,

feature time must be enabled and the Timing implementation is required with which the actor can know the time

pub fn from_fn<F>(message: Option<A::Message>, delay: F) -> Selfwhere F: FnMut(&mut A, &mut Context<A>, &mut CoreContext<'_>) -> Poll<Indicator<A::Message>> + 'static + Unpin,

use a function/Clousre as condition to deliver the message

Trait Implementations

impl<A> Future<A> for Delayer<A>where A: Actor + Delaying<A>, A::Message: Message, Self: Unpin,

type Output = ()

the returned type of value when the future polled successfully

fn poll( self: Pin<&mut Self>, act: &mut A, ctx: &mut Context<A>, cx: &mut CoreContext<'_> ) -> Poll<Self::Output>

fn downcast_ref(&self) -> Option<&dyn Any>

fn downcast_mut(self: Pin<&mut Self>) -> Option<Pin<&mut dyn Any>>