Struct async_timer::Timed

pub struct Timed<'a, F, T = Platform> { /* private fields */ }

Limiter on time to wait for underlying Future

Usage

async fn job() {
}

async fn do_job() {
    let mut job = job();
    let job = unsafe {
        core::pin::Pin::new_unchecked(&mut job)
    };
    let work = unsafe {
        async_timer::Timed::platform_new(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<'a, F: Future> Timed<'a, F>

pub fn platform_new(fut: Pin<&'a mut F>, timeout: Duration) -> Self

Creates new instance using Timer alias.

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

pub fn new(fut: Pin<&'a mut 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<'a, F: Future, T: Timer> Future for Timed<'a, F, T>

type Output = Result<<F as Future>::Output, Expired<'a, 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.