crb 0.0.38

CRB | Composable Runtime Blocks
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

use anyhow::{Error, Result};
use async_trait::async_trait;
use crb::agent::{Address, Agent, AgentSession, Context, Next, OnEvent, Standalone};
use crb::superagent::{Supervisor, SupervisorSession};

struct Printer;

impl Agent for Printer {
    type Context = AgentSession<Self>;
    type Link = Address<Self>;
}

struct Print(pub String);

#[async_trait]
impl OnEvent<Print> for Printer {
    async fn handle(&mut self, event: Print, _ctx: &mut Context<Self>) -> Result<()> {
        println!("{}", event.0);
        Ok(())
    }
}

struct Main;

impl Standalone for Main {}

#[async_trait]
impl Agent for Main {
    type Context = SupervisorSession<Self>;
    type Link = Address<Self>;

    fn initialize(&mut self, ctx: &mut Context<Self>) -> Next<Self> {
        ctx.event(SendPrint)
            .map(|_| Next::events())
            .unwrap_or_else(Next::fail)
    }
}

struct SendPrint;

#[async_trait]
impl OnEvent<SendPrint> for Main {
    async fn handle(&mut self, _event: SendPrint, ctx: &mut Context<Self>) -> Result<()> {
        let (printer, _) = ctx.spawn_agent(Printer, ());
        let print = Print("Hello, Trackable!".into());
        printer.event(print)?;
        Ok(())
    }
}

impl Supervisor for Main {
    type BasedOn = AgentSession<Self>;
    type GroupBy = ();
}

#[tokio::test]
async fn test_trackable() -> Result<(), Error> {
    let mut addr = Main.spawn();
    addr.interrupt()?;
    addr.join().await?;
    Ok(())
}