actor12 0.0.9

A lightweight actor framework for Rust with async support
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use actor12::{Actor, Call, Handler, Init, MpscChannel, Multi, spawn};
use futures::future;
use std::future::Future;

// Actor that can handle multiple different message types using the Handler trait
pub struct MultiHandlerActor {
    counter: i32,
    name: String,
}

// Different message types
#[derive(Debug)]
pub struct IncrementMsg;

#[derive(Debug)]
pub struct GetCountMsg;

#[derive(Debug)]
pub struct SetNameMsg(pub String);

#[derive(Debug)]
pub struct GetNameMsg;

impl Actor for MultiHandlerActor {
    type Spec = String; // actor name
    type Message = Multi<Self>;
    type Channel = MpscChannel<Self::Message>;
    type Cancel = ();
    type State = ();

    fn state(_spec: &Self::Spec) -> Self::State {}

    fn init(ctx: Init<'_, Self>) -> impl Future<Output = Result<Self, Self::Cancel>> + Send + 'static {
        let name = ctx.spec;
        println!("MultiHandlerActor '{}' initialized", name);
        future::ready(Ok(MultiHandlerActor {
            counter: 0,
            name,
        }))
    }
}

// Implement Handler for each message type
impl Handler<IncrementMsg> for MultiHandlerActor {
    type Reply = Result<i32, anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, _msg: IncrementMsg) -> Self::Reply {
        self.counter += 1;
        println!("Actor '{}': Counter incremented to {}", self.name, self.counter);
        Ok(self.counter)
    }
}

impl Handler<GetCountMsg> for MultiHandlerActor {
    type Reply = Result<i32, anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, _msg: GetCountMsg) -> Self::Reply {
        println!("Actor '{}': Current counter is {}", self.name, self.counter);
        Ok(self.counter)
    }
}

impl Handler<SetNameMsg> for MultiHandlerActor {
    type Reply = Result<String, anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: SetNameMsg) -> Self::Reply {
        let old_name = self.name.clone();
        self.name = msg.0;
        println!("Actor name changed from '{}' to '{}'", old_name, self.name);
        Ok(old_name)
    }
}

impl Handler<GetNameMsg> for MultiHandlerActor {
    type Reply = Result<String, anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, _msg: GetNameMsg) -> Self::Reply {
        println!("Actor '{}': Returning current name", self.name);
        Ok(self.name.clone())
    }
}

// String handler for dynamic messages
impl Handler<String> for MultiHandlerActor {
    type Reply = Result<String, anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: String) -> Self::Reply {
        let response = format!("Actor '{}' received string: '{}'", self.name, msg);
        println!("{}", response);
        Ok(response)
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    println!("=== Handler Pattern Example ===\n");

    // Spawn the actor
    let actor = spawn::<MultiHandlerActor>("CounterBot".to_string());

    // Use different message types with the same actor
    println!("1. Testing typed messages:");
    
    // Increment counter
    let count1: Result<i32, anyhow::Error> = actor.ask_dyn(IncrementMsg).await;
    println!("Result: {:?}", count1);

    let count2: Result<i32, anyhow::Error> = actor.ask_dyn(IncrementMsg).await;  
    println!("Result: {:?}", count2);

    // Get current count
    let current: Result<i32, anyhow::Error> = actor.ask_dyn(GetCountMsg).await;
    println!("Current count: {:?}", current);

    println!("\n2. Testing name operations:");
    
    // Change name
    let old_name: Result<String, anyhow::Error> = actor.ask_dyn(SetNameMsg("SuperBot".to_string())).await;
    println!("Previous name: {:?}", old_name);

    // Get current name
    let name: Result<String, anyhow::Error> = actor.ask_dyn(GetNameMsg).await;
    println!("Current name: {:?}", name);

    println!("\n3. Testing dynamic string messages:");
    
    // Send string messages dynamically
    let response1: Result<String, anyhow::Error> = actor.ask_dyn("Hello there!".to_string()).await;
    println!("Response: {:?}", response1);

    let response2: Result<String, anyhow::Error> = actor.ask_dyn("How are you doing?".to_string()).await;
    println!("Response: {:?}", response2);

    println!("\n4. Final state check:");
    let final_count: Result<i32, anyhow::Error> = actor.ask_dyn(GetCountMsg).await;
    let final_name: Result<String, anyhow::Error> = actor.ask_dyn(GetNameMsg).await;
    println!("Final count: {:?}, Final name: {:?}", final_count, final_name);

    Ok(())
}