hannibal 0.16.3

A small actor library
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
132

use crate::{
    Actor, Addr, Handler, Message, WeakCaller, WeakSender,
    channel::WeakTx,
    context::Core,
    error::{ActorError::ActorDropped, Result},
};

/// A weak reference to an actor.
///
/// This is the weak counterpart to [`Addr`]. It can be upgraded to a strong [`Addr`] if the Actor is still alive.
#[derive(Clone)]
pub struct WeakAddr<A: Actor> {
    core: Core,
    pub(super) weak_tx: WeakTx<A>,
}

impl<A: Actor> WeakAddr<A> {
    /// Attempts to upgrade this weak address to a strong address.
    pub fn upgrade(&self) -> Option<Addr<A>> {
        self.weak_tx.upgrade().map(|tx| Addr {
            core: self.core.clone(),
            tx,
        })
    }

    /// Returns true if the actor is still running.
    pub fn running(&self) -> bool {
        self.core.running()
    }

    /// Checks if the actor is stopped.
    pub fn stopped(&self) -> bool {
        self.core.stopped()
    }

    /// Attempts to send a stop signal to the actor.
    ///
    /// If the actor is already stopped, an error is returned.
    pub fn try_stop(&mut self) -> Result<()> {
        if let Some(mut addr) = self.upgrade() {
            addr.stop()
        } else {
            Err(ActorDropped)
        }
    }

    /// Attempts to halt the actor and awaits its termination.
    ///
    /// If the actor is already stopped, an error is returned.
    pub async fn try_halt(&mut self) -> Result<()> {
        if let Some(mut addr) = self.upgrade() {
            addr.stop()?;
            addr.await
        } else {
            Err(ActorDropped)
        }
    }

    pub(crate) const fn new(core: Core, weak_tx: WeakTx<A>) -> Self {
        WeakAddr { core, weak_tx }
    }

    /// Creates a weak sender for the actor.
    pub fn sender<M>(&self) -> WeakSender<M>
    where
        A: Actor + Handler<M>,
        M: Message<Response = ()>,
    {
        WeakSender::from_weak_tx(self.weak_tx.clone(), self.core.clone())
    }

    /// Creates a weak caller for the actor.
    pub fn caller<M>(&self) -> WeakCaller<M>
    where
        A: Actor + Handler<M>,
        M: Message,
    {
        WeakCaller::from_weak_tx(self.weak_tx.clone(), self.core.clone())
    }
}

impl<A: Actor> From<&Addr<A>> for WeakAddr<A> {
    fn from(addr: &Addr<A>) -> Self {
        let weak_tx = addr.tx.downgrade();
        let core = addr.core.clone();

        WeakAddr { core, weak_tx }
    }
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used)]
    use super::*;
    use crate::addr::tests::*;

    #[test_log::test(tokio::test)]
    async fn upgrade() {
        let (event_loop, addr) = start(MyActor::default());
        tokio::spawn(event_loop);

        let weak_addr = WeakAddr::from(&addr);
        assert_eq!(weak_addr.upgrade().unwrap().call(Add(1, 2)).await, Ok(3))
    }

    #[test_log::test(tokio::test)]
    async fn does_not_prolong_life() {
        let (event_loop, addr) = start(MyActor::default());
        let actor = tokio::spawn(event_loop);

        let weak_addr = WeakAddr::from(&addr);
        weak_addr.upgrade().unwrap();

        drop(addr);

        actor.await.unwrap().unwrap();
        assert!(weak_addr.upgrade().is_none());
    }

    #[test_log::test(tokio::test)]
    async fn send_fails_after_drop() {
        let (event_loop, addr) = start(MyActor::default());
        let actor = tokio::spawn(event_loop);

        let weak_addr = WeakAddr::from(&addr);
        let mut addr = weak_addr.upgrade().unwrap();
        addr.stop().unwrap();

        actor.await.unwrap().unwrap();
        assert!(addr.send(Store("password")).await.is_err());
    }
}