zestors 0.1.2

A fast and flexible actor-framework for building fault-tolerant Rust applications
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

use async_trait::async_trait;

use super::*;
use std::any::TypeId;

/// A [`Protocol`] defines exactly which [messages](Message) an actor [`Accepts`]. Normally this is derived with
/// the [`macro@protocol`] macro.
///
/// [`Protocol`] is automatically implemented for `()`, which accepts only `()`.
pub trait Protocol: Send + 'static {
    /// Take out the payload as a [`BoxPayload`].
    fn into_boxed_payload(self) -> BoxPayload;

    /// Attempt to create the [`Protocol`] from a message.
    ///
    /// # Implementation
    /// This should succeed if and only if the protocol implements [`FromPayload<M>`].
    fn try_from_boxed_payload(payload: BoxPayload) -> Result<Self, BoxPayload>
    where
        Self: Sized;

    /// Whether the [`Protocol`] accepts the type-id of a [`Message`].
    ///
    /// # Implementation
    /// Should return true if and only if the protocol implements [`FromPayload<M>`].
    fn accepts_msg(msg_id: &TypeId) -> bool
    where
        Self: Sized;
}

/// Specifies that a [`Protocol`] can be created from the [`Message::Payload`] of `M`.
pub trait FromPayload<M: Message>: Protocol {
    /// Create the [`Protocol`] from the [`Message::Payload`].
    fn from_payload(payload: M::Payload) -> Self
    where
        Self: Sized;

    /// Attempt to convert the protocol into the [`Message::Payload`] of `M`.
    fn try_into_payload(self) -> Result<M::Payload, Self>
    where
        Self: Sized;
}

//------------------------------------------------------------------------------------------------
//  Protocol: `()`
//------------------------------------------------------------------------------------------------

impl Protocol for () {
    fn into_boxed_payload(self) -> BoxPayload {
        BoxPayload::new::<()>(())
    }

    fn try_from_boxed_payload(payload: BoxPayload) -> Result<Self, BoxPayload> {
        payload.downcast::<()>()
    }

    fn accepts_msg(msg_id: &std::any::TypeId) -> bool {
        *msg_id == TypeId::of::<()>()
    }
}

#[async_trait]
impl<H: Handler> HandledBy<H> for ()
where
    H: HandleMessage<()>,
{
    async fn handle_with(
        self,
        handler: &mut H,
        state: &mut <H as Handler>::State,
    ) -> HandlerResult<H> {
        handler.handle_msg(state, self).await
    }
}

impl FromPayload<()> for () {
    fn from_payload(payload: ()) -> Self
    where
        Self: Sized,
    {
        payload
    }

    fn try_into_payload(self) -> Result<(), Self>
    where
        Self: Sized,
    {
        Ok(self)
    }
}