dope-runtime 0.2.3

Thin io_uring adaptor with "Manifolds"
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

use std::future::Future;
use std::time::Duration;

pub mod executor;
pub mod launcher;
pub mod runtime;
mod sys;
pub mod time;

cfg_select! {
    target_os = "linux" => {
        pub type DefaultBackend = dope_uring::UringBackend;
    }
    _ => {
        pub type DefaultBackend = dope_kqueue::KqueueBackend;
    }
}

pub type Driver = <DefaultBackend as dope_core::driver::Backend>::Driver;
pub type RuntimeCtx = executor::RuntimeCtx<DefaultBackend>;
pub type ExternalDispatch = dope_core::driver::ExternalDispatch<DefaultBackend>;
pub type JoinHandle<T> = executor::JoinHandle<T>;

#[inline(always)]
pub fn current() -> RuntimeCtx {
    executor::current::<DefaultBackend>()
}

#[inline(always)]
pub fn spawn<F>(fut: F) -> JoinHandle<F::Output>
where
    F: Future + 'static,
    F::Output: 'static,
{
    executor::spawn::<DefaultBackend, F>(fut)
}

#[inline(always)]
pub fn block_on<F: Future>(fut: F) -> F::Output {
    executor::block_on::<DefaultBackend, F>(fut)
}

#[inline(always)]
pub fn install_external(aux: Option<ExternalDispatch>) -> Option<ExternalDispatch> {
    executor::install_external::<DefaultBackend>(aux)
}

#[inline(always)]
pub async fn sleep(duration: Duration) -> std::io::Result<()> {
    time::sleep::<DefaultBackend>(duration).await
}

#[inline(always)]
pub fn timeout<F: Future>(
    duration: Duration,
    fut: F,
) -> impl Future<Output = std::io::Result<F::Output>> {
    time::timeout::<DefaultBackend, F>(duration, fut)
}