evno 1.0.2

A high-performance event bus for asynchronous tasks and event-driven systems.
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

use crate::event::Event;
use crate::{EmitterProxy, TypedEmit, bind_latch};
use std::any::Any;
use std::sync::Arc;

pub struct Publisher<E> {
    publisher: gyre::Publisher<E>,
    bind_latch: Arc<bind_latch::BindLatch>,
}

impl<T: Event> Publisher<T> {
    pub(crate) fn new(capacity: usize, bind_latch: Arc<bind_latch::BindLatch>) -> Self {
        let (publisher, _) = gyre::channel(capacity);
        Self {
            publisher,
            bind_latch,
        }
    }

    pub async fn subscribe(&self) -> gyre::Consumer<T> {
        self.publisher.subscribe().await
    }
}

impl<T: Event> TypedEmit for Publisher<T> {
    type Event = T;

    #[inline]
    async fn emit(&self, event: Self::Event) {
        self.bind_latch.wait_for_binds().await;
        self.publisher.publish(event).await.unwrap_or(());
    }
}

impl<T> Clone for Publisher<T> {
    fn clone(&self) -> Self {
        Self {
            publisher: self.publisher.clone(),
            bind_latch: self.bind_latch.clone(),
        }
    }
}

impl<E: Event> EmitterProxy for Publisher<E> {
    fn as_any(&self) -> &dyn Any {
        self
    }
}