Struct riddle_common::eventpub::EventPub

pub struct EventPub<T> { /* fields omitted */ }

Event publisher which can have multiple subscribers.

Example

#[derive(Clone)]
enum Message {
    Test(u32)
}

fn main() {
    let publisher: EventPub<Message> = EventPub::new();

    // Attach any subscribers
    // ...

    publisher.dispatch(Message::Test(42));
    publisher.dispatch(Message::Test(13));
}

Implementations

impl<T: Clone> EventPub<T>

pub fn new() -> Self

Create a new event publisher.

The new publisher will have no subscribers, so any message dispatched to it in this state will be silently dropped.

pub fn attach(&self, sub: &EventSub<T>)

Attach a subscriber to the publisher.

Any events dispatched after this call will be registered with the subscriber. The subscriber won’t receive any events dispatched before it has been attached.

The subscriber is detached by dropping the attached EventSub.

Example

let publisher: EventPub<Message> = EventPub::new();
let subscriber: EventSub<Message> = EventSub::new();

publisher.attach(&subscriber);
assert_eq!(1, publisher.subscription_count());

drop(subscriber);
assert_eq!(0, publisher.subscription_count());

pub fn dispatch(&self, event: T)

Send an event to all currently registered subscribers.

Example

let sub_a: EventSub<Message> = EventSub::new();
let sub_b: EventSub<Message> = EventSub::new();
let publisher: EventPub<Message> = EventPub::new();
publisher.attach(&sub_a);
publisher.attach(&sub_b);

publisher.dispatch(Message::Test(0));

assert_eq!(vec![Message::Test(0)], sub_a.collect());
assert_eq!(vec![Message::Test(0)], sub_b.collect());

pub fn subscription_count(&self) -> u32

The current count of attached subscribers.

Trait Implementations

impl<T: Clone> Default for EventPub<T>

fn default() -> Self

Returns the “default value” for a type.