lakka 0.1.0

Simple actors with macros
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

use std::{future::Future, pin::Pin, time::Duration};

use crate::{ActorError, Channel};

#[derive(Debug, Clone)]
pub struct IntervalMessage<T> {
    pub msg: T,
    pub counter: u32,
}

impl<T> IntervalMessage<T> {
    pub fn new(msg: T) -> Self {
        Self { msg, counter: 0 }
    }
}

pub struct Intervaller<Variant, Message: Clone> {
    variant: fn(IntervalMessage<Message>) -> Variant,
    msg: Message,
    counter: u32,
    interval: tokio::time::Interval,
    tick_limit: Option<u32>,
}

impl<Variant, Message: Clone> Intervaller<Variant, Message> {
    pub fn new(
        interval: Duration,
        variant: fn(IntervalMessage<Message>) -> Variant,
        msg: Message,
    ) -> Self {
        Self::new_with_limit(interval, variant, msg, None)
    }

    pub fn new_with_limit(
        interval: Duration,
        variant: fn(IntervalMessage<Message>) -> Variant,
        msg: Message,
        tick_limit: Option<u32>,
    ) -> Self {
        let interval = tokio::time::interval(interval);
        Self {
            interval,
            variant,
            msg,
            tick_limit,
            counter: 0,
        }
    }

    pub fn construct(&self) -> Variant {
        let msg = IntervalMessage {
            msg: self.msg.clone(),
            counter: self.counter,
        };

        (self.variant)(msg)
    }
}

impl<Variant, Message: Clone + Send> Channel<Variant> for Intervaller<Variant, Message> {
    fn recv(&mut self) -> Pin<Box<dyn Future<Output = Result<Variant, ActorError>> + Send + '_>> {
        Box::pin(async move {
            if self.tick_limit.map(|limit| self.counter > limit).is_some() {
                return Err(ActorError::ActorClosed);
            }

            let _ = self.interval.tick().await;
            let msg = self.construct();
            self.counter += 1;

            Ok(msg)
        })
    }
}

#[tokio::test]
async fn test() {
    #[derive(Debug, Clone, PartialEq)]
    pub struct Keke(u32);

    pub enum Test {
        Asd(IntervalMessage<Keke>),
    }

    let asd = Intervaller::new(Duration::from_secs(1), Test::Asd, Keke(15));
    let enummi = asd.construct();
    let Test::Asd(IntervalMessage { msg, .. }) = enummi;
    assert_eq!(msg, Keke(15))
}