Struct heph::timer::Deadline

pub struct Deadline<Fut, RT: Access> { /* fields omitted */ }

A Future that wraps another future setting a deadline for it.

When this future is polled it first checks if the deadline has passed, if so it returns Poll::Ready(Err(DeadlinePassed.into())). Otherwise this will poll the future it wraps.

Notes

This type can also be created using Timer::wrap, this is useful when dealing with lifetime issue, e.g. when calling actor::Context::receive_next and wrapping that in a Deadline.

Examples

Setting a timeout for a future.

use std::io;
use std::time::Duration;

use heph::actor;
use heph::rt::ThreadSafe;
use heph::timer::Deadline;

async fn actor(mut ctx: actor::Context<String, ThreadSafe>) {
    // `OtherFuture` is a type that implements `Future`.
    let future = IoFuture;
    // Create our deadline.
    let deadline_future = Deadline::after(&mut ctx, Duration::from_millis(100), future);

    // Now we await the results.
    let result = deadline_future.await;
    // However the other future is rather slow, so the timeout will pass.
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::TimedOut);
}

Implementations

impl<Fut, RT: Access> Deadline<Fut, RT>

pub fn at<M>(
    ctx: &mut Context<M, RT>,
    deadline: Instant,
    future: Fut
) -> Deadline<Fut, RT> where
    RT: Clone, 

Create a new Deadline.

pub fn after<M>(
    ctx: &mut Context<M, RT>,
    timeout: Duration,
    future: Fut
) -> Deadline<Fut, RT> where
    RT: Clone, 

Create a new deadline based on a timeout.

Same as calling Deadline::at(&mut ctx, Instant::now() + timeout, future).

pub const fn deadline(&self) -> Instant

Returns the deadline set for this Deadline.

pub fn has_passed(&self) -> bool

Returns true if the deadline has passed.

pub const fn get_ref(&self) -> &Fut

Returns a reference to the wrapped future.

pub fn get_mut(&mut self) -> &mut Fut

Returns a mutable reference to the wrapped future.

pub fn into_inner(self) -> Fut

Returns the wrapped future.

Trait Implementations

impl<Fut, RT: Access> Bound<RT> for Deadline<Fut, RT>

type Error = Error

Error type used in bind_to.

fn bind_to<M>(&mut self, ctx: &mut Context<M, RT>) -> Result<()>

Bind a type to the Actor that owns the ctx.

impl<Fut: Debug, RT: Debug + Access> Debug for Deadline<Fut, RT>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Fut, RT: Access> Drop for Deadline<Fut, RT>

fn drop(&mut self)

Executes the destructor for this type.

impl<Fut, RT: Access, T, E> Future for Deadline<Fut, RT> where
    Fut: Future<Output = Result<T, E>>,
    E: From<DeadlinePassed>, 

type Output = Result<T, E>

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<Fut: Unpin, RT: Access> Unpin for Deadline<Fut, RT>