Struct Interval 

pub struct Interval<M> { /* private fields */ }

A source that emits messages periodically. Clones the message on every tick.

Tracing

Every message starts a new trace, thus a new trace id is generated and assigned to the current scope.

Example

use elfo::{time::Interval, messages::ConfigUpdated};

#[message]
struct MyTick;

let interval = ctx.attach(Interval::new(MyTick));
interval.start(ctx.config().period);

while let Some(envelope) = ctx.recv().await {
    msg!(match envelope {
        ConfigUpdated => {
            interval.set_period(ctx.config().period);
        },
        MyTick => {
            tracing::info!("tick!");
        },
    });
}

Implementations

impl<M: Message> Interval<M>

pub fn new(message: M) -> UnattachedSource<Self>

Creates an unattached instance of Interval.

pub fn set_message(&self, message: M)

Replaces a stored message with the provided one.

pub fn set_period(&self, period: Duration)

Configures the period of ticks. Intended to be called on ConfigUpdated.

Does nothing if the timer is not started or the period hasn’t been changed.

Unlike rescheduling (start_* methods), it only adjusts the current period and doesn’t change the time origin. For instance, if we have a configured interval with period = 5s and try to call one of these methods, the difference looks something like this:

set_period(10s): | 5s | 5s | 5s |  # 10s  |   10s   |
start(10s):      | 5s | 5s | 5s |  #   10s   |   10s   |
                                   #
                              called here

Panics

If period is zero.

pub fn start(&self, period: Duration)

Schedules the timer to start emitting ticks every period. The first tick will be emitted also after period.

Reschedules the timer if it’s already started.

Panics

If period is zero.

pub fn start_after(&self, delay: Duration, period: Duration)

Schedules the timer to start emitting ticks every period. The first tick will be emitted after delay.

Reschedules the timer if it’s already started.

Panics

If period is zero.

pub fn start_at(&self, when: Instant, period: Duration)

Available on crate feature unstable only.

Schedules the timer to start emitting ticks every period. The first tick will be emitted at when.

Reschedules the timer if it’s already started.

Panics

If period is zero.

Stability

This method is unstable, because it accepts tokio::time::Instant, which will be replaced in the future to support other runtimes.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn stop(&self)

Stops any ticks. To resume ticks use one of start_* methods.

Note: it doesn’t terminates the source. It means the source is present in the source map until SourceHandle::terminate() is called.

Trait Implementations

impl<M: Message> SourceHandle for Interval<M>

fn is_terminated(&self) -> bool

Returns true if the source has stopped producing messages.

fn terminate_by_ref(&self) -> bool

Terminates the source. Drop is called immediately.

fn terminate(self) -> bool

where Self: Sized,

Terminates the source. Drop is called immediately.