aector 0.1.1

Dynamic implementation of the actor model with a smart built-in testing 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
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

use std::any::{Any, TypeId};

use crate::address::Addr;

pub(crate) struct BroadcastMessage<M: Any + Clone + Send> {
    inner: M,
    addr: Option<Addr>
}

impl<M: Any + Clone + Send> BroadcastMessage<M> {
    pub(crate) fn without_sender(obj: M) -> Self {
        BroadcastMessage {
            inner: obj,
            addr: None
        }
    }

    pub(crate) fn with_sender(obj: M, sender: Addr) -> Self {
        BroadcastMessage {
            inner: obj,
            addr: Some(sender)
        }
    }

    pub(crate) fn get_message(&self) -> Message {
        let inner = self.inner.clone();
        match &self.addr {
            None => {
                Message::without_sender(inner)
            }
            Some(addr) => {
                Message::with_sender(inner, addr.clone())
            }
        }
    }
}



/// All types of messages which are sent from and to [Actor](crate::actor::Actor)'s are internally stored as [Message]. The
/// only requirements for a type to be qualified as a message is that it implements [Any] and [Send].
/// The message data is owned by this type and, if not explicitly stored by the receiving [Actor](crate::actor::Actor),
/// dropped after handling the message.
pub struct Message {
    inner: Box<dyn Any + Send>,
    pub(crate) sender: Option<Addr>
}

impl Message {
    pub(crate) fn with_sender<M: Any + Send>(obj: M, sender: Addr) -> Self {
        Self {
            inner: Box::new(obj),
            sender: Some(sender)
        }
    }

    pub(crate) fn without_sender<M: Any + Send>(obj: M) -> Self {
        Self {
            inner: Box::new(obj),
            sender: None
        }
    }

    pub(crate) fn instance_of<M: Any + Send>(&self) -> bool {
        self.inner.as_ref().type_id() == TypeId::of::<M>()
    }

    pub(crate) fn type_id(&self) -> TypeId {
        self.inner.as_ref().type_id()
    }

    pub(crate) fn downcast<M: Any + Send>(self) -> Box<M> {
        let inner = self.inner;

        let msg = inner.downcast::<M>();

        // unwrap here is on purpose - if this goes wrong something else has gone very wrong and the panic is ok
        msg.unwrap()
    }
}