interthread 3.1.0

Auto implementation of the Actor Model
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

pub struct MyActor {
    value: i8,
}
impl MyActor {
    pub fn new(v: i8) -> Self {
        Self { value: v }
    }
    pub fn increment(&mut self) {
        self.value += 1;
    }
    pub fn add_number(&mut self, num: i8) -> i8 {
        self.value += num;
        self.value
    }
    pub fn get_value(&self) -> i8 {
        self.value
    }
}
enum MyActorScript {
    Increment {},
    AddNumber { num: i8, inter_send: oneshot::Sender<i8> },
    GetValue { inter_send: oneshot::Sender<i8> },
}
impl MyActorScript {
    fn direct(self, actor: &mut MyActor) {
        match self {
            Self::Increment {} => {
                actor.increment();
            }
            Self::AddNumber { num, inter_send } => {
                inter_send
                    .send(actor.add_number(num))
                    .unwrap_or_else(|_error| {
                        core::panic!(
                            "'MyActorScript::AddNumber.direct'. Sending on a closed channel."
                        )
                    });
            }
            Self::GetValue { inter_send } => {
                inter_send
                    .send(actor.get_value())
                    .unwrap_or_else(|_error| {
                        core::panic!(
                            "'MyActorScript::GetValue.direct'. Sending on a closed channel."
                        )
                    });
            }
        }
    }
    fn play(
        receiver: std::sync::mpsc::Receiver<MyActorScript>,
        v: i8,
        inter_send: oneshot::Sender<()>,
    ) {
        let mut actor = MyActor::new(v);
        let _ = inter_send
            .send(())
            .unwrap_or_else(|_error| {
                core::panic!(
                    "'MyActorScript::play' from inter_send. Sending on a closed channel!"
                )
            });
        while let ::std::result::Result::Ok(msg) = receiver.recv() {
            msg.direct(&mut actor);
        }
    }
}
#[derive(Clone)]
pub struct MyActorLive {
    sender: std::sync::mpsc::Sender<MyActorScript>,
}
impl MyActorLive {
    pub fn new(v: i8) -> Self {
        let (sender, receiver) = std::sync::mpsc::channel();
        let (inter_send, inter_recv) = oneshot::channel();
        std::thread::spawn(move || { MyActorScript::play(receiver, v, inter_send) });
        let _ = inter_recv
            .recv()
            .unwrap_or_else(|_error| {
                core::panic!("'MyActorLive::new' from inter_recv. Channel is closed!")
            });
        Self { sender }
    }
    pub fn increment(&mut self) {
        let msg = MyActorScript::Increment {};
        let _ = self
            .sender
            .send(msg)
            .expect("'MyActorLive::method.send'. Channel is closed!");
    }
    pub fn add_number(&mut self, num: i8) -> i8 {
        let (inter_send, inter_recv) = oneshot::channel();
        let msg = MyActorScript::AddNumber {
            num,
            inter_send,
        };
        let _ = self
            .sender
            .send(msg)
            .expect("'MyActorLive::method.send'. Channel is closed!");
        inter_recv
            .recv()
            .unwrap_or_else(|_error| {
                core::panic!(
                    "'MyActorLive::add_number' from inter_recv. Channel is closed!"
                )
            })
    }
    pub fn get_value(&self) -> i8 {
        let (inter_send, inter_recv) = oneshot::channel();
        let msg = MyActorScript::GetValue {
            inter_send,
        };
        let _ = self
            .sender
            .send(msg)
            .expect("'MyActorLive::method.send'. Channel is closed!");
        inter_recv
            .recv()
            .unwrap_or_else(|_error| {
                core::panic!(
                    "'MyActorLive::get_value' from inter_recv. Channel is closed!"
                )
            })
    }
}