async-rt 0.2.0

A small library designed to utilize async executors through an common API while extending features.
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

use crate::error::TimeoutError;
use crate::{
    AbortableJoinHandle, Executor, ExecutorBlockOn, ExecutorBlocking, ExecutorTimeout, JoinHandle,
};
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;

impl<E> Executor for Arc<E>
where
    E: Executor,
{
    fn runtime_type(&self) -> Option<&'static str> {
        (**self).runtime_type()
    }

    fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        (**self).spawn(future)
    }
}

impl<E> ExecutorBlocking for Arc<E>
where
    E: ExecutorBlocking,
{
    fn spawn_blocking<F, T>(&self, future: F) -> JoinHandle<T>
    where
        F: FnOnce() -> T + Send + 'static,
        T: Send + 'static,
    {
        (**self).spawn_blocking(future)
    }

    fn spawn_blocking_abortable<F, R>(&self, f: F) -> AbortableJoinHandle<R>
    where
        F: FnOnce() -> R + Send + 'static,
        R: Send + 'static,
    {
        (**self).spawn_blocking_abortable(f)
    }
}

impl<E> ExecutorTimeout for Arc<E>
where
    E: ExecutorTimeout,
{
    fn spawn_timeout<F>(
        &self,
        duration: std::time::Duration,
        f: F,
    ) -> JoinHandle<Result<F::Output, TimeoutError>>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        (**self).spawn_timeout(duration, f)
    }

    fn spawn_delay<F>(&self, duration: Duration, f: F) -> JoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        (**self).spawn_delay(duration, f)
    }

    fn spawn_abortable_timeout<F>(
        &self,
        duration: std::time::Duration,
        f: F,
    ) -> AbortableJoinHandle<Result<F::Output, TimeoutError>>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        (**self).spawn_abortable_timeout(duration, f)
    }

    fn spawn_abortable_delay<F>(&self, duration: Duration, f: F) -> AbortableJoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        (**self).spawn_abortable_delay(duration, f)
    }
}

impl<E> ExecutorBlockOn for Arc<E>
where
    E: ExecutorBlockOn,
{
    fn block_on<F: Future>(&self, f: F) -> F::Output {
        (**self).block_on(f)
    }
}