RobotS 0.3.0

Actor framework
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

/// In this example we show how to compute a factorial with actors.
/// Here the actor simply sends messages to himself.

extern crate robots;

use std::any::Any;
use std::sync::Arc;
use std::time::Duration;

use robots::actors::{Actor, ActorSystem, ActorCell, ActorContext, Props};

/// Basic tail recursive factorial.
struct Factorial;

impl Actor for Factorial {
    fn receive(&self, message: Box<Any>, context: ActorCell) {
        if let Ok(message) = Box::<Any>::downcast::<(u32, u32)>(message) {
            let (i, j) = *message;
            if i == 0 {
                println!("factorial: {}", j);
            } else {
                context.tell(context.actor_ref(), (i - 1, j * i));
            }
        }
    }
}

impl Factorial {
    fn new(_dummy: ()) -> Factorial {
        Factorial
    }
}

fn main() {
    let actor_system = ActorSystem::new("test".to_owned());
    actor_system.spawn_threads(2);

    let props_factorial = Props::new(Arc::new(Factorial::new), ());
    let factorial_actor_ref_1 = actor_system.actor_of(props_factorial.clone(), "sender".to_owned());
    let factorial_actor_ref_2 = actor_system.actor_of(props_factorial.clone(),
                                                      "receiver".to_owned());

    factorial_actor_ref_1.tell_to(factorial_actor_ref_2.clone(), (3u32, 1u32));
    factorial_actor_ref_1.tell_to(factorial_actor_ref_2.clone(), (7u32, 1u32));
    factorial_actor_ref_1.tell_to(factorial_actor_ref_2.clone(), (11u32, 1u32));

    std::thread::sleep(Duration::from_millis(100));
    actor_system.shutdown();
}