tiny-actor 0.2.0-beta.0

A minimal actor framework for Rust
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
128
129
130
131

macro_rules! dyn_channel_methods {
    () => {
        /// Close the [Channel].
        pub fn close(&self) -> bool {
            self.channel.close()
        }

        /// Halt the actor.
        pub fn halt(&self) {
            self.channel.halt_some(u32::MAX)
        }

        /// Halt n processes.
        pub fn halt_some(&self, n: u32) {
            self.channel.halt_some(n)
        }

        /// Get the amount of processes.
        pub fn process_count(&self) -> usize {
            self.channel.inbox_count()
        }

        /// Get the amount of messages in the [Channel].
        pub fn msg_count(&self) -> usize {
            self.channel.msg_count()
        }

        /// Get the amount of [Addresses](Address) of the [Channel].
        pub fn address_count(&self) -> usize {
            self.channel.address_count()
        }

        /// Whether the [Channel] is closed.
        pub fn is_closed(&self) -> bool {
            self.channel.is_closed()
        }

        pub fn is_bounded(&self) -> bool {
            self.channel.is_bounded()
        }

        /// Get the [Capacity] of the [Channel].
        pub fn capacity(&self) -> &Capacity {
            self.channel.capacity()
        }

        /// Whether all processes have exited.
        pub fn has_exited(&self) -> bool {
            self.channel.has_exited()
        }

        /// Get the actor's id.
        pub fn actor_id(&self) -> u64 {
            self.channel.actor_id()
        }
    };
}
pub(crate) use dyn_channel_methods;

macro_rules! send_methods {
    () => {
        /// Attempt to send a message to the actor.
        ///
        /// * In the case of an `unbounded` [Channel], when [BackPressure] returns a timeout this fails.
        /// * In the case of a `bounded` [Channel], when it is full this fails.
        ///
        /// For `bounded` channels, this method is the same as [send_now](Address::send_now).
        pub fn try_send(&self, msg: M) -> Result<(), TrySendError<M>> {
            self.channel.try_send(msg)
        }

        /// Attempt to send a message to the actor.
        ///
        /// * In the case of an `unbounded` [Channel], any [BackPressure] is ignored.
        /// * In the case of a `bounded` [Channel], when it is full this fails.
        ///
        /// For `bounded` channels, this method is the same as [try_send](Address::send_now).
        pub fn send_now(&self, msg: M) -> Result<(), TrySendError<M>> {
            self.channel.send_now(msg)
        }

        /// Attempt to send a message to the actor.
        ///
        /// * In the case of an `unbounded` [Channel], when [BackPressure] returns a timeout this waits
        /// untill the timeout is over.
        /// * In the case of a `bounded` [Channel], when it is full this waits untill space is available.
        pub fn send(&self, msg: M) -> Snd<'_, M> {
            self.channel.send(msg)
        }

        /// Same as [send](Address::send) but it blocking the OS-thread.
        pub fn send_blocking(&self, msg: M) -> Result<(), SendError<M>> {
            self.channel.send_blocking(msg)
        }
    };
}
pub(crate) use send_methods;

macro_rules! child_methods {
    () => {
        /// Attach the actor.
        ///
        /// Returns the old abort-timeout if it was already attached.
        pub fn attach(&mut self, duration: Duration) -> Option<Duration> {
            self.link.attach(duration)
        }

        /// Detach the actor.
        ///
        /// Returns the old abort-timeout if it was attached before.
        pub fn detach(&mut self) -> Option<Duration> {
            self.link.detach()
        }

        /// Whether the actor is aborted.
        pub fn is_aborted(&self) -> bool {
            self.is_aborted
        }

        /// Whether the actor is attached.
        pub fn is_attached(&self) -> bool {
            self.link.is_attached()
        }

        /// Get a reference to the current [Link] of the actor.
        pub fn link(&self) -> &Link {
            &self.link
        }
    };
}
pub(crate) use child_methods;