typesafe event registry

registry.rs

use std::marker::PhantomData;

use typemap::{Key, TypeMap};

struct EventListenerKey<E>(PhantomData<E>);

trait EventListner<E>: FnMut(&E) -> () + 'static {}

impl<F, E> EventListner<E> for F where F: FnMut(&E) -> () + 'static {}

impl<E: 'static> Key for EventListenerKey<E> {
    type Value = Vec<Box<dyn EventListner<E>>>;
}

struct EventDispatcher(TypeMap);

impl EventDispatcher {
    fn new() -> Self {
        EventDispatcher(TypeMap::new())
    }

    fn add_listener<E: 'static>(&mut self, f: impl EventListner<E>) {
        let e = self.0.entry::<EventListenerKey<E>>().or_insert(vec![]);
        e.push(Box::new(f));
    }

    fn trigger<E: 'static>(&mut self, event: &E) {
        if let Some(listeners) = self.0.get_mut::<EventListenerKey<E>>() {
            for listener in listeners {
                listener(event);
            }
        }
    }
}

#[derive(Debug)]
struct Blah {
    x: i32,
}

fn main() {
    let mut events = EventDispatcher::new();
    events.add_listener(|blah: &Blah| {
        println!("blah {blah:?}");
    });

    events.trigger(&Blah { x: 3 });

    events.add_listener(|blah: &i32| {
        println!("blah {blah:?}");
    });

    events.trigger(&5);
    events.add_listener(|blah: &i32| {
        println!("woot {blah:?}");
    });
    events.trigger(&53);

    println!("done");
}