Enum async_timer::Timed

#[must_use = "Timed does nothing unless polled"]pub enum Timed<F, T = PlatformTimer> {
    // some variants omitted
}

Limiter on time to wait for underlying Future

Usage

async fn job() {
}

async fn do_job() {
    let work = unsafe {
        async_timer::Timed::platform_new_unchecked(job(), core::time::Duration::from_secs(1))
    };

    match work.await {
        Ok(_) => println!("I'm done!"),
        //You can retry by polling `expired`
        Err(expired) => println!("Job expired: {}", expired),
    }
}

Implementations

impl<F: Future + Unpin> Timed<F>

pub fn platform_new(inner: F, timeout: Duration) -> Self

Creates new instance using Timer alias.

impl<F: Future> Timed<F>

pub unsafe fn platform_new_unchecked(inner: F, timeout: Duration) -> Self

Creates new instance using Timer alias.

Unsafe version of platform_new that doesn't require Unpin.

impl<F: Future + Unpin, T: Timer> Timed<F, T>

pub fn new(inner: F, timeout: Duration) -> Self

Creates new instance with specified timeout

Requires to specify Timer type (e.g. Timed::<timer::Platform>::new())

impl<F: Future, T: Timer> Timed<F, T>

pub unsafe fn new_unchecked(inner: F, timeout: Duration) -> Self

Creates new instance with specified timeout

Unsafe version of new that doesn't require Unpin.

Requires to specify Timer type (e.g. Timed::<timer::Platform>::new())

Trait Implementations

impl<F: Future, T: Timer> Future for Timed<F, T>

type Output = Result<F::Output, Expired<F, T>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<F: Future + Unpin, T: Timer> Unpin for Timed<F, T>