yaaral 0.5.3

yet another async runtime abstraction library
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
105
106
107
108

//! Extension for time.

use std::{fmt::Debug, time::Duration};

#[cfg(feature = "bevy_runtime_018")]
use bevy_tasks_018 as bevy_tasks;

/// Default timeout error
#[derive(Debug)]
pub struct Elapsed;

/// Interface related to time
pub trait TimeInterface {
    /// Error type for timeout.
    type Elapsed: Debug;

    /// Sleep for the given duration.
    fn sleep(duration: Duration) -> impl Future<Output = ()> + Send;

    /// Wait for the future to complete, return an error if the future does not complete before the given duration.
    fn timeout<T>(
        duration: Duration,
        future: impl Future<Output = T> + Send,
    ) -> impl Future<Output = Result<T, Self::Elapsed>> + Send;
}

#[cfg(any(feature = "futures_runtime", feature = "bevy_runtime"))]
async fn futures_impl<T, RT: TimeInterface>(
    duration: Duration,
    future: impl Future<Output = T> + Send,
) -> Result<T, Elapsed> {
    let sleep = RT::sleep(duration);
    futures::pin_mut!(sleep);
    futures::pin_mut!(future);
    match futures::future::select(sleep, future).await {
        futures::future::Either::Left(_) => Err(Elapsed),
        futures::future::Either::Right((v, _)) => Ok(v),
    }
}

#[cfg(feature = "futures_runtime")]
impl TimeInterface for crate::futures::Runtime {
    type Elapsed = Elapsed;
    async fn sleep(duration: std::time::Duration) {
        async_io::Timer::after(duration).await;
    }
    fn timeout<T>(
        duration: Duration,
        future: impl Future<Output = T> + Send,
    ) -> impl Future<Output = Result<T, Self::Elapsed>> + Send {
        futures_impl::<T, Self>(duration, future)
    }
}

#[cfg(feature = "tokio_runtime")]
impl TimeInterface for crate::tokio::Runtime {
    type Elapsed = tokio::time::error::Elapsed;
    fn sleep(duration: std::time::Duration) -> impl Future<Output = ()> + Send {
        tokio::time::sleep(duration)
    }
    fn timeout<T>(
        duration: Duration,
        future: impl Future<Output = T> + Send,
    ) -> impl Future<Output = Result<T, Self::Elapsed>> + Send {
        tokio::time::timeout(duration, future)
    }
}

#[cfg(any(feature = "bevy_runtime", feature = "bevy_runtime_018"))]
impl<TP> TimeInterface for crate::bevy::Runtime<TP>
where
    TP: std::ops::Deref<Target = bevy_tasks::TaskPool> + Sync + 'static,
{
    type Elapsed = Elapsed;
    async fn sleep(duration: std::time::Duration) {
        async_io::Timer::after(duration).await;
    }
    fn timeout<T>(
        duration: Duration,
        future: impl Future<Output = T> + Send,
    ) -> impl Future<Output = Result<T, Self::Elapsed>> + Send {
        futures_impl::<T, Self>(duration, future)
    }
}

#[cfg(test)]
mod test {
    use crate::common;

    use super::TimeInterface;
    use crate::{Config, CreationInterface};

    fn test_full_runtime<RT: CreationInterface + TimeInterface>() {
        let rt = RT::new(Config::new().prefix("test")).unwrap();
        common::test_sleep(&rt);
        common::test_timeout(&rt);
    }
    #[cfg(feature = "futures_runtime")]
    #[test]
    fn test_futures() {
        test_full_runtime::<crate::futures::Runtime>();
    }
    #[cfg(feature = "tokio_runtime")]
    #[test]
    fn test_tokio() {
        test_full_runtime::<crate::tokio::Runtime>();
    }
}