hannibal 0.16.3

A small actor library
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

use std::time::Duration;

use hannibal::prelude::*;

#[derive(Debug)]
struct Child(usize);
impl Actor for Child {
    async fn started(&mut self, ctx: &mut Context<Self>) -> hannibal::DynResult<()> {
        println!("{self:?} started");
        ctx.interval_with(|| (), Duration::from_millis(300 + 300 * self.0 as u64));
        Ok(())
    }

    async fn stopped(&mut self, _: &mut Context<Self>) {
        println!("{self:?} stopped");
    }
}

#[derive(Clone, Message)]
struct Hello;
impl Handler<Hello> for Child {
    async fn handle(&mut self, _: &mut Context<Self>, _: Hello) {
        println!("Hello I'm child {}", self.0);
    }
}

impl Handler<Hello> for Root {
    async fn handle(&mut self, ctx: &mut Context<Self>, msg: Hello) {
        println!("Greeting My Children");
        ctx.send_to_children(msg);
    }
}

impl Handler<()> for Child {
    async fn handle(&mut self, _: &mut Context<Self>, _: ()) {
        println!("{self:?} {:>width$}!", "x", width = (self.0 + 1) * 10);
    }
}

#[derive(Clone, Message)]
struct Gc;
impl Handler<Gc> for Root {
    async fn handle(&mut self, ctx: &mut Context<Self>, _: Gc) {
        println!("Garbage Collecting");
        ctx.gc();
    }
}

#[derive(Debug)]
struct Root;
impl Actor for Root {
    async fn started(&mut self, ctx: &mut Context<Self>) -> DynResult<()> {
        println!("{self:?} started");
        ctx.add_child(Child(0).spawn());
        ctx.add_child(Child(1).spawn());
        ctx.add_child(Child(2).spawn());

        ctx.register_child::<Hello>(Child(3).spawn());
        ctx.register_child::<Hello>(Child(4).spawn());
        ctx.register_child::<Hello>(Child(5).spawn());

        ctx.interval_with(|| Hello, Duration::from_millis(500));
        ctx.interval(Gc, Duration::from_millis(500));

        let mut me = ctx.weak_address();
        ctx.delayed_exec(
            async move {
                me.try_halt().await.unwrap();
                println!("shut down root");
            },
            Duration::from_secs(5),
        );
        Ok(())
    }
    async fn stopped(&mut self, _: &mut Context<Self>) {
        println!("{self:?} stopped");
    }
}

#[hannibal::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();
    Root.spawn().await?;
    Ok(())
}