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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

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

impl<L, R> Executor for Either<L, R>
where
    L: Executor,
    R: Executor,
{
    fn runtime_type(&self) -> Option<&'static str> {
        match self {
            Either::Left(l) => l.runtime_type(),
            Either::Right(r) => r.runtime_type(),
        }
    }

    fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        match self {
            Either::Left(l) => l.spawn(future),
            Either::Right(r) => r.spawn(future),
        }
    }
}

impl<L, R> ExecutorBlocking for Either<L, R>
where
    L: ExecutorBlocking,
    R: ExecutorBlocking,
{
    fn spawn_blocking<F, T>(&self, f: F) -> JoinHandle<T>
    where
        F: FnOnce() -> T + Send + 'static,
        T: Send + 'static,
    {
        match self {
            Either::Left(l) => l.spawn_blocking(f),
            Either::Right(r) => r.spawn_blocking(f),
        }
    }
}

impl<L, R> ExecutorTimeout for Either<L, R>
where
    L: ExecutorTimeout,
    R: ExecutorTimeout,
{
    fn spawn_timeout<F>(
        &self,
        duration: Duration,
        f: F,
    ) -> JoinHandle<Result<F::Output, TimeoutError>>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        match self {
            Either::Left(l) => l.spawn_timeout(duration, f),
            Either::Right(r) => r.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,
    {
        match self {
            Either::Left(l) => l.spawn_delay(duration, f),
            Either::Right(r) => r.spawn_delay(duration, f),
        }
    }

    fn spawn_abortable_timeout<F>(
        &self,
        duration: Duration,
        f: F,
    ) -> AbortableJoinHandle<Result<F::Output, TimeoutError>>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static,
    {
        match self {
            Either::Left(l) => l.spawn_abortable_timeout(duration, f),
            Either::Right(r) => r.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,
    {
        match self {
            Either::Left(l) => l.spawn_abortable_delay(duration, f),
            Either::Right(r) => r.spawn_abortable_delay(duration, f),
        }
    }
}

impl<L, R> ExecutorBlockOn for Either<L, R>
where
    L: ExecutorBlockOn,
    R: ExecutorBlockOn,
{
    fn block_on<F: Future>(&self, f: F) -> F::Output {
        match self {
            Either::Left(l) => l.block_on(f),
            Either::Right(r) => r.block_on(f),
        }
    }
}