Multiple events of different payloads

[wimvelzeboer]

Hi @dimitri-br
I like the simplicity of this event bus, I tried to add a feature to but got stranded. That probably because I am quite new to Rust.

My idea was to add the ability to have different events with any type of payload, so that you could do something like this:

fn main() {
  let mut event_bus = EventBus::new();

  // Add each subscriber to the event bus, two for the "foo" and one for the "bar" event
  event_bus.subscribe_listener("foo".to_string(), FooOneSubscriber::new("Foo Subscriber 1".to_string()));
  event_bus.subscribe_listener("foo".to_string(), FooTwoSubscriber::new("Foo Subscriber 2".to_string()));
  event_bus.subscribe_listener("bar".to_string(), BarSubscriber::new("Foo Subscriber 1".to_string()));

  // publish two events, one for each.
  event_bus.publish("foo".to_string(), Event::new("hello".to_string()));  // takes a String as payload/message
  event_bus.publish("bar".to_string(), Event::new(42)); // takes a Number/u32 as payload/message

  // Run through each event
  event_bus.run();
}

The event name (foo/bar) is always a String but it should be able to take any kind of payload/message, e.g. String, u32, Struct/Trait
I started with changing the event of EventBus into a HashMap, but got into a conflict where I could only payloads of either a String or u32, not both. And got lost while trying to refactor everything into a Trait.

Any pointers that you can give me are very welcome!

This is the changed event_bus:

#![allow(dead_code)]

use std::collections::HashMap;
use super::Event;
use super::Subscriber;

pub struct EventBus<T> {
    /// A vec of events that have been published to the event bus.
    events: HashMap<String, Vec<Box<Event<T>>>>,
    /// A vec of all subscribers that are linked to the event bus.
    subscribers: HashMap<String, Vec<Box<dyn Subscriber<Input = T>>>>,
}

impl<T> EventBus<T> {

    pub fn new() -> EventBus<T> {
        EventBus {
            events: HashMap::new(),
            subscribers: HashMap::new(),
        }
    }

    pub fn publish(&mut self, event_name: String, message: Event<T>) {
        if self.events.contains_key(&event_name) {
            self.events.get_mut(&event_name).unwrap()
                .push(Box::new(message));
        } else {
            self.events.insert(event_name, vec![Box::new(message)]);
        }
    }

    pub fn subscribe_listener<R: Subscriber<Input = T> + 'static>(&mut self, event_name:String, listener: R) {
        if self.subscribers.contains_key(&event_name) {
            self.subscribers.get_mut(&event_name).unwrap()
                .push(Box::new(listener));
        } else {
            self.subscribers.insert(event_name, vec![Box::new(listener)]);
        }
    }

    pub fn run(&mut self) {
        for (event, messages) in self.events.drain() {
            if self.subscribers.contains_key(&event) {
                for listener in self.subscribers.get_mut(&event).unwrap().iter_mut() {
                    for message in &messages {
                        listener.on_event(message);
                    }
                }
            } else {
                println!("No event subscribers for '{}'", event);
            }
        }
    }
...
}

// Default
impl<T> Default for EventBus<T> {
...
}

And this is the Example to test it

use simple_event_bus::{Event, EventBus, Subscriber};

struct ExampleSubscriber {
    pub name: String,
}

impl ExampleSubscriber {
    pub fn new(name: String) -> ExampleSubscriber {
        ExampleSubscriber { name }
    }
}

impl Subscriber for ExampleSubscriber {
    type Input = String;

    fn on_event(&mut self, event: &Event<Self::Input>) {
        println!("{} received message: {}", self.name, event.get_data());
    }
}

struct NumberSubscriber {
    pub name: String,
}

impl NumberSubscriber {
    pub fn new(name: String) -> NumberSubscriber {
        NumberSubscriber { name }
    }
}

impl Subscriber for NumberSubscriber {
    type Input = u32;

    fn on_event(&mut self, event: &Event<Self::Input>) {
        println!("{} received message: {}", self.name, event.get_data());
    }
}


fn main() {
    let mut event_bus = EventBus::new();

    // We have to manually create and add each subscriber to the event bus.
    // event_bus.subscribe_listener("bar".to_string(), ExampleSubscriber::new("Subscriber 1".to_string()));
    // event_bus.subscribe_listener("bar".to_string(), ExampleSubscriber::new("Subscriber 2".to_string()));
    event_bus.subscribe_listener("foo".to_string(), NumberSubscriber::new("Number Subscriber".to_string()));

    // We can manually define an event and publish it to the event bus.
    // event_bus.publish(Event::new("hello".to_string()));
    let number: u32 = 32;
    event_bus.publish("foo".to_string(), Event::new(number));
    // event_bus.publish("bar".to_string(), Event::new("hello".to_string()));


    // Runs through each event, and calls each listener's on_event method.
    event_bus.run();
}

It works, but I can't use both ExampleSubscriber and NumberSubscriber at the same time...

[dimitri-br]

Yep that makes sense! This is how rust works, it's very finicky when it comes to types and generics. There's a few ways you can work around this, but most of them involve casting to a generic type (such as Any), then downcasting back to the type you want.

You'd need to change how the structs and traits are formulated, I'll make a full example tomorrow and get it uploaded. But the gist of it is to avoid using generics for the simplest and imo, cleanest option.

Something like

pub struct Event {
    /// The data that is held by the event.
    pub data: Box<dyn Any>,
}

impl Event {
    /// # New
    ///
    /// Creates a new event.
    pub fn new<T: 'static>(data: T) -> Event {
        let data = Box::new(data);
        Event { data }
    }

    pub fn get_data<T: 'static>(&self) -> Option<&T> {
        self.data.downcast_ref::<T>()
    }
}

for the event and

pub trait Subscriber {
    fn on_event(&mut self, event: &Event);
}

for the subscriber

This should be a good start. You'll need to adjust the rest of the code, and it's probably a good idea to try and expand it further. You can look into downcasting for getting a type out of the Any value. This will mean that you'll need to do a bit more work to get any meaningful types out of it, and it could potentially have issues if you downcast the wrong type - if both Subscribers are listening to "foo" and recieve an integer, they'll have a garbage output and it'll cause issues for example.

You can do a simple check for this though. Something like this could work:

impl Subscriber for NumberSubscriber {
    fn on_event(&mut self, event: &Event) {

        // Here we can do whatever we want with the event.
        // Downcast to a string, as we know that the event is a string.
        let event = event.get_data::<i32>().unwrap_or_else(|| {
            panic!("{} received an event that was not a number!", self.name);
        });

        println!("{} received number: {}", self.name, event);
    }
}

this is really just one way to do it, and it's very simple too. It involves a bit of manual work when it comes to using it, but I think it could be extended too if you want to do more with it!

Hope that's helped, let me know if you need anything else :)

[wimvelzeboer]

@dimitri-br Thank you so much!
I now managed to get it working. It was indeed one of those small Rust things that blocked me.
Now, I have changed it into payloads of Any type and with event names with separate sets of subscribers.

I forked your repo here and added the change there.
Would you want it included in your repo that I raise a PR or do you rather want to keep what you have?