fusio 0.6.0

Fusio provides lean, minimal cost abstraction and extensible Read / Write trait to multiple storage on multiple poll-based / completion-based async runtime.
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
120

use std::error::Error;
#[cfg(not(feature = "no-send"))]
use std::future::Future;

use fusio_core::{MaybeSend, MaybeSendFuture, MaybeSync};
use tokio::runtime::Handle;

#[cfg(not(feature = "no-send"))]
use super::Executor;
use super::{JoinHandle, Mutex, RwLock, Timer};

impl<R: MaybeSend> JoinHandle<R> for tokio::task::JoinHandle<R> {
    async fn join(self) -> Result<R, Box<dyn Error + Send + Sync>> {
        self.await
            .map_err(|e| Box::new(e) as Box<dyn Error + Send + Sync>)
    }
}

impl<T: MaybeSend + MaybeSync> Mutex<T> for tokio::sync::Mutex<T> {
    type Guard<'a>
        = tokio::sync::MutexGuard<'a, T>
    where
        T: 'a;

    async fn lock(&self) -> Self::Guard<'_> {
        ::tokio::sync::Mutex::lock(self).await
    }
}

impl<T: MaybeSend + MaybeSync> RwLock<T> for tokio::sync::RwLock<T> {
    type ReadGuard<'a>
        = tokio::sync::RwLockReadGuard<'a, T>
    where
        T: 'a;
    type WriteGuard<'a>
        = tokio::sync::RwLockWriteGuard<'a, T>
    where
        T: 'a;

    async fn read(&self) -> Self::ReadGuard<'_> {
        ::tokio::sync::RwLock::read(self).await
    }

    async fn write(&self) -> Self::WriteGuard<'_> {
        ::tokio::sync::RwLock::write(self).await
    }
}

#[derive(Clone)]
pub struct TokioExecutor {
    #[cfg_attr(feature = "no-send", allow(dead_code))]
    handle: Handle,
}

impl Default for TokioExecutor {
    fn default() -> Self {
        Self {
            handle: Handle::current(),
        }
    }
}

#[cfg(not(feature = "no-send"))]
impl Executor for TokioExecutor {
    type JoinHandle<R>
        = tokio::task::JoinHandle<R>
    where
        R: MaybeSend;

    type Mutex<T>
        = tokio::sync::Mutex<T>
    where
        T: MaybeSend + MaybeSync;

    type RwLock<T>
        = tokio::sync::RwLock<T>
    where
        T: MaybeSend + MaybeSync;

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

    fn mutex<T>(value: T) -> Self::Mutex<T>
    where
        T: MaybeSend + MaybeSync,
    {
        tokio::sync::Mutex::new(value)
    }

    fn rw_lock<T>(value: T) -> Self::RwLock<T>
    where
        T: MaybeSend + MaybeSync,
    {
        tokio::sync::RwLock::new(value)
    }
}

impl Timer for TokioExecutor {
    fn sleep(
        &self,
        dur: std::time::Duration,
    ) -> std::pin::Pin<Box<dyn MaybeSendFuture<Output = ()>>> {
        Box::pin(async move {
            tokio::time::sleep(dur).await;
        })
    }

    fn now(&self) -> std::time::Instant {
        std::time::Instant::now()
    }

    fn system_time(&self) -> std::time::SystemTime {
        std::time::SystemTime::now()
    }
}