serviceless 0.5.1

An simple actor model in rust, like actix
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

use crate::runtime::Runtime;
use async_trait::async_trait;
use tokio::task::JoinSet;

use super::{
    Error, TokioOneshotReceiver, TokioOneshotSender, TokioSpawner, TokioUnboundedReceiver,
    TokioUnboundedSender,
};

pub struct TokioRuntime;

#[async_trait]
impl Runtime for TokioRuntime {
    type Error = Error;

    type UnboundedSender<T>
        = TokioUnboundedSender<T>
    where
        T: Send;
    type UnboundedReceiver<T>
        = TokioUnboundedReceiver<T>
    where
        T: Send;

    fn unbounded<T>() -> (Self::UnboundedSender<T>, Self::UnboundedReceiver<T>)
    where
        T: Send,
    {
        let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
        (
            TokioUnboundedSender { sender },
            TokioUnboundedReceiver { receiver },
        )
    }

    type OneshotSender<T>
        = TokioOneshotSender<T>
    where
        T: Send;
    type OneshotReceiver<T>
        = TokioOneshotReceiver<T>
    where
        T: Send;

    fn oneshot<T>() -> (Self::OneshotSender<T>, Self::OneshotReceiver<T>)
    where
        T: Send,
    {
        let (sender, receiver) = tokio::sync::oneshot::channel();
        (
            TokioOneshotSender { sender },
            TokioOneshotReceiver { receiver },
        )
    }

    type Spawner<T>
        = TokioSpawner<T>
    where
        T: Send + 'static;

    fn spawner<T>() -> Self::Spawner<T>
    where
        T: Send + 'static,
    {
        TokioSpawner {
            tasks: JoinSet::new(),
        }
    }
}