tyra 1.0.0

Typed Actor System
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

use crate::actor::actor::Actor;
use crate::actor::context::ActorContext;
use crate::message::actor_message::BaseActorMessage;
use crate::message::actor_stop_message::ActorStopMessage;
use crate::message::sleep_message::SleepMessage;
use crate::message::system_stop_message::SystemStopMessage;
use crate::prelude::{ActorResult, BulkActorMessage, SerializedMessage};
use std::error::Error;

/// Defines which [ActorMessage] is supported per [Actor]
///
/// # Examples
///
/// Basic usage:
///
/// ```rust
/// use std::error::Error;
/// use tyra::prelude::{TyraConfig, ActorSystem, ActorFactory, ActorContext, SerializedMessage, Handler, Actor, ActorResult, ActorMessage};
///
/// struct TestActor {}
/// impl Actor for TestActor {}
///
/// struct FooBar {}
/// impl ActorMessage for FooBar {}
///
/// impl Handler<FooBar> for TestActor {
///     fn handle(&mut self, _msg: FooBar, _context: &ActorContext<Self>) -> Result<ActorResult, Box<dyn Error>> {
///         Ok(ActorResult::Ok)
///     }
/// }
/// ```
pub trait Handler<M: ?Sized>
where
    Self: Actor + Sized,
    M: BaseActorMessage,
{
    fn handle(
        &mut self,
        msg: M,
        context: &ActorContext<Self>,
    ) -> Result<ActorResult, Box<dyn Error>>;
}

impl<A> Handler<ActorStopMessage> for A
where
    A: Actor + Sized,
{
    fn handle(
        &mut self,
        _msg: ActorStopMessage,
        _context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        return Ok(ActorResult::Stop);
    }
}

impl<A> Handler<SystemStopMessage> for A
where
    A: Actor + Sized,
{
    fn handle(
        &mut self,
        _msg: SystemStopMessage,
        context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        return self.on_system_stop(context);
    }
}

impl<M, A> Handler<BulkActorMessage<M>> for A
where
    Self: Actor + Sized,
    A: Handler<M>,
    M: BaseActorMessage,
{
    fn handle(
        &mut self,
        msg: BulkActorMessage<M>,
        context: &ActorContext<Self>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        for i in msg.data.into_iter() {
            self.handle(i, context)?;
        }
        return Ok(ActorResult::Ok);
    }
}

impl<A> Handler<SerializedMessage> for A
where
    A: Actor + Sized + Actor,
{
    fn handle(
        &mut self,
        msg: SerializedMessage,
        context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        return self.handle_serialized_message(msg, context);
    }
}

impl<A> Handler<SleepMessage> for A
where
    A: Actor + Sized + Actor,
{
    fn handle(
        &mut self,
        msg: SleepMessage,
        _context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        return Ok(ActorResult::Sleep(msg.duration));
    }
}