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

use std::{any::type_name, pin::Pin, sync::Arc};

use crate::{Actor, DynResult};

/// A future that resolves to an actor.
pub type JoinFuture<A> = Pin<Box<dyn Future<Output = Option<A>> + Send>>;

pub struct ActorHandle<A> {
    join_fn: Box<dyn FnMut() -> JoinFuture<A>>,
    detach_fn: Option<Box<dyn FnOnce()>>,
}

impl<A> ActorHandle<A> {
    fn new<F>(join_fn: F) -> Self
    where
        F: FnMut() -> JoinFuture<A> + 'static,
    {
        Self {
            join_fn: Box::new(join_fn),
            detach_fn: None,
        }
    }

    #[cfg_attr(feature = "tokio_runtime", allow(dead_code))]
    fn with_detach_fn<F: FnOnce() + 'static>(mut self, detach_fn: F) -> Self {
        self.detach_fn = Some(Box::new(detach_fn));
        self
    }

    pub fn join(&mut self) -> JoinFuture<A> {
        (self.join_fn)()
    }

    pub fn detach(self) {
        if let Some(detach_fn) = self.detach_fn {
            detach_fn();
        }
    }
}

impl<A: Actor> ActorHandle<A> {
    #[cfg(feature = "tokio_runtime")]
    pub fn spawn<F>(event_loop: F) -> Self
    where
        F: Future<Output = DynResult<A>> + Send + 'static,
    {
        log::trace!("spawning in tokio {}", type_name::<Self>());

        let join_handle = tokio::spawn(event_loop);
        let handle = Arc::new(async_lock::Mutex::new(Some(join_handle)));

        Self::new(move || -> JoinFuture<A> {
            let handle = Arc::clone(&handle);
            Box::pin(async move {
                if let Some(handle) = handle.lock().await.take() {
                    handle.await.ok().and_then(Result::ok)
                } else {
                    None
                }
            })
        })
    }

    #[cfg(not(feature = "tokio_runtime"))]
    pub fn spawn<F>(event_loop: F) -> Self
    where
        F: Future<Output = DynResult<A>> + Send + 'static,
    {
        log::trace!("spawning {}", type_name::<Self>());

        let task = async_global_executor::spawn(event_loop);
        let handle = Arc::new(async_lock::Mutex::new(Some(task)));
        let detach_handle = Arc::clone(&handle);

        Self::new(move || {
            let handle = Arc::clone(&handle);
            Box::pin(async move {
                if let Some(handle) = handle.lock().await.take() {
                    handle.await.ok()
                } else {
                    None
                }
            })
        })
        .with_detach_fn(move || {
            let mut handle = detach_handle.lock_blocking().take();
            if let Some(handle) = handle.take() {
                handle.detach();
            }
        })
    }
}