karmaio 0.1.0

A modern, fast, share-nothing 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

use std::{
    error::Error,
    fmt::{self, Display},
    future::Future,
    pin::pin,
    task::Poll,
    time::{Duration, Instant},
};

use super::sleep::{sleep, sleep_until};

/// Error returned by [`timeout`] and [`timeout_at`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Elapsed(());

impl Display for Elapsed {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("deadline has elapsed")
    }
}

impl Error for Elapsed {}

/// Require a [`Future`] to complete before the specified duration has elapsed.
///
/// If the future completes before the duration has elapsed, then the completed
/// value is returned. Otherwise, an error is returned and the future is
/// dropped. Dropping submitted completion I/O requests platform cancellation,
/// but forfeits the owned buffer; use [`crate::runtime::FutureExt::with_cancellation`]
/// and await the original future when the buffer must be recovered.
pub async fn timeout<F: Future>(duration: Duration, future: F) -> Result<F::Output, Elapsed> {
    let mut future = pin!(future);
    let mut delay = pin!(sleep(duration));

    std::future::poll_fn(|cx| {
        if let Poll::Ready(output) = future.as_mut().poll(cx) {
            return Poll::Ready(Ok(output));
        }

        if delay.as_mut().poll(cx).is_ready() {
            return Poll::Ready(Err(Elapsed(())));
        }

        Poll::Pending
    })
    .await
}

/// Require a [`Future`] to complete before the specified instant in time.
///
/// If the future completes before the instant is reached, then the completed
/// value is returned. Otherwise, an error is returned and the future is
/// dropped. Dropping submitted completion I/O requests platform cancellation,
/// but forfeits the owned buffer; use [`crate::runtime::FutureExt::with_cancellation`]
/// and await the original future when the buffer must be recovered.
///
/// If `deadline` is in the past, the future is still polled once before  returning [`Elapsed`],
/// giving it a chance to complete synchronously.
pub async fn timeout_at<F: Future>(deadline: Instant, future: F) -> Result<F::Output, Elapsed> {
    let mut future = pin!(future);
    let mut delay = pin!(sleep_until(deadline));

    std::future::poll_fn(|cx| {
        if let Poll::Ready(output) = future.as_mut().poll(cx) {
            return Poll::Ready(Ok(output));
        }

        if delay.as_mut().poll(cx).is_ready() {
            return Poll::Ready(Err(Elapsed(())));
        }

        Poll::Pending
    })
    .await
}