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

use crate::actor::context::ActorContext;
use crate::actor::handler::Handler;
use crate::message::actor_message::BaseActorMessage;
use crate::prelude::{Actor, ActorResult};
use std::error::Error;

pub trait MessageEnvelopeTrait<A>: Send + Sync
where
    A: Actor,
{
    fn handle(
        &mut self,
        actor: &mut A,
        context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>>;
}

pub struct MessageEnvelope<A>(Box<dyn MessageEnvelopeTrait<A> + Send + Sync>);

impl<A> MessageEnvelope<A> {
    pub fn new<M>(msg: M) -> Self
    where
        A: Handler<M> + Actor,
        M: BaseActorMessage + Send + Sync + 'static,
    {
        MessageEnvelope(Box::new(SyncMessageEnvelope { msg: Some(msg) }))
    }
}

impl<A> MessageEnvelopeTrait<A> for MessageEnvelope<A>
where
    A: Actor,
{
    fn handle(
        &mut self,
        act: &mut A,
        context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        return self.0.handle(act, context);
    }
}

pub struct SyncMessageEnvelope<M>
where
    M: BaseActorMessage + Send + Sync,
{
    msg: Option<M>,
}

impl<A, M> MessageEnvelopeTrait<A> for SyncMessageEnvelope<M>
where
    M: BaseActorMessage + Send + 'static,
    A: Handler<M> + Actor,
{
    fn handle(
        &mut self,
        act: &mut A,
        context: &ActorContext<A>,
    ) -> Result<ActorResult, Box<dyn Error>> {
        if let Some(msg) = self.msg.take() {
            return act.handle(msg, context);
        }
        return Ok(ActorResult::Ok);
    }
}