guinea-core 0.18.0

guinea's core: actors, reducers, scopes and the event bus
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

use crate::actor::addr::Addr;
use crate::actor::event_bus::subscribe::Event;
use crate::actor::event_bus::{GlobalEventBus, RpcCall, RpcRequest};
use crate::actor::traits::Handler;
use crate::lifecycle_tracker::LifecycleTracker;

pub trait EventSubscription<A> {
    fn subscribe_into(addr: Addr<A>, tracker: &impl LifecycleTracker);
}

impl<A, M> EventSubscription<A> for M
where
    M: Event,
    A: Handler<M> + 'static,
{
    fn subscribe_into(addr: Addr<A>, tracker: &impl LifecycleTracker) {
        tracker.track_sub(GlobalEventBus::instance().subscribe::<A, M>(addr));
    }
}

impl<A> EventSubscription<A> for () {
    fn subscribe_into(_: Addr<A>, _: &impl LifecycleTracker) {}
}

pub trait EventBatch<A, L: LifecycleTracker> {
    fn subscribe_batch(builder: EventBusBuilder<A, L>) -> EventBusBuilder<A, L>;
}

pub struct EventBusBuilder<'a, A: 'static, L: LifecycleTracker> {
    pub(crate) addr: Addr<A>,
    pub(crate) tracker: &'a L,
}

impl<'a, A: 'static, L: LifecycleTracker> EventBusBuilder<'a, A, L> {
    pub fn batch<T>(self) -> Self
    where
        T: EventBatch<A, L>,
    {
        T::subscribe_batch(self)
    }

    pub fn subscribe<M>(self) -> Self
    where
        M: Event,
        A: Handler<M> + 'static,
    {
        self.tracker
            .track_sub(GlobalEventBus::instance().subscribe::<A, M>(self.addr.clone()));
        self
    }

    pub fn rpc<Req>(self) -> Self
    where
        Req: RpcCall,
        A: Handler<RpcRequest<Req>> + 'static,
    {
        self.tracker.track_sub(
            GlobalEventBus::instance().subscribe::<A, RpcRequest<Req>>(self.addr.clone()),
        );
        self
    }
}

impl<A, L, M> EventBatch<A, L> for M
where
    A: Handler<M> + 'static,
    L: LifecycleTracker,
    M: Event,
{
    fn subscribe_batch(builder: EventBusBuilder<A, L>) -> EventBusBuilder<A, L> {
        builder.subscribe::<M>()
    }
}