vibeio 0.2.8

A high-performance, cross-platform asynchronous runtime for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Timeout future that races an inner future against a duration.

use std::{
    fmt,
    future::Future,
    pin::Pin,
    task::{Context, Poll},
    time::Duration,
};

use super::sleep::Sleep;

/// Error returned when a `timeout` expires.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TimeoutError;

impl fmt::Display for TimeoutError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "operation timed out")
    }
}

impl std::error::Error for TimeoutError {}

/// Timeout future that races the provided future against a timeout duration.
///
/// If the inner future completes first, `Timeout` yields `Ok(T)`.
/// If the timeout elapses first, `Timeout` yields `Err(TimeoutError)` and the
/// inner future is dropped.
pub struct Timeout<F> {
    future: F,
    sleep: Sleep,
    /// If true, the timeout has already fired (and future should be treated as timed out).
    timed_out: bool,
}

impl<F> Timeout<F> {
    /// Create a new `Timeout` future.
    #[inline]
    pub fn new(future: F, duration: Duration) -> Self {
        Self {
            future,
            sleep: Sleep::new(duration),
            timed_out: false,
        }
    }
}

impl<F> Future for Timeout<F>
where
    F: Future,
{
    type Output = Result<F::Output, TimeoutError>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Safety: we don't move the fields out; we only create pinned projections.
        let this = unsafe { self.get_unchecked_mut() };

        if this.timed_out {
            return Poll::Ready(Err(TimeoutError));
        }

        // First, poll the inner future. If it completes, return the value and
        // allow `sleep` to be dropped (which cancels the timer).
        // We need a pinned projection of `future`.
        let mut future_pin = unsafe { Pin::new_unchecked(&mut this.future) };
        match Future::poll(future_pin.as_mut(), cx) {
            Poll::Ready(output) => return Poll::Ready(Ok(output)),
            Poll::Pending => {}
        }

        // Next, poll the timeout sleep. If it is ready, mark timed out and
        // return Err. Otherwise remain Pending.
        let mut sleep_pin = unsafe { Pin::new_unchecked(&mut this.sleep) };
        match sleep_pin.as_mut().poll(cx) {
            Poll::Ready(()) => {
                this.timed_out = true;
                // Dropping `future` happens naturally when this Timeout is dropped
                // by the executor or after we return. Return Err now.
                Poll::Ready(Err(TimeoutError))
            }
            Poll::Pending => Poll::Pending,
        }
    }
}

/// Convenience async function that awaits `future` but returns an error if it
/// does not complete within `duration`.
///
/// Example:
/// ```ignore
/// let res = timeout(Duration::from_secs(1), some_future).await;
/// match res {
///     Ok(v) => { /* completed in time */ }
///     Err(_) => { /* timed out */ }
/// }
/// ```
#[inline]
pub async fn timeout<T>(
    duration: Duration,
    future: impl Future<Output = T>,
) -> Result<T, TimeoutError> {
    Timeout::new(future, duration).await
}