implement the new event system, things are still really messy

src/event.rs

@@ -1,56 +1,262 @@
-//! Provides an abstract event type which can be downcasted into a more specific one.
-//!
-//! # Examples
-//!
-//! ```
-//! use xmpp::event::{Event, AbstractEvent};
-//!
-//! #[derive(Debug, PartialEq, Eq)]
-//! struct EventA;
-//!
-//! impl Event for EventA {}
-//!
-//! #[derive(Debug, PartialEq, Eq)]
-//! struct EventB;
-//!
-//! impl Event for EventB {}
-//!
-//! let event_a = AbstractEvent::new(EventA);
-//!
-//! assert_eq!(event_a.is::<EventA>(), true);
-//! assert_eq!(event_a.is::<EventB>(), false);
-//!
-//! assert_eq!(event_a.downcast::<EventA>(), Some(&EventA));
-//! assert_eq!(event_a.downcast::<EventB>(), None);
-//! ```
-
+use std::marker::PhantomData;
+use std::any::{TypeId, Any};
 use std::fmt::Debug;
+use std::collections::BTreeMap;
+use std::cmp::Ordering;
+use std::sync::Arc;
+use std::mem;
+use std::ptr;
+use std::raw::TraitObject;
 
-use std::any::Any;
+use minidom::Element;
 
-/// An abstract event.
-pub struct AbstractEvent {
-    inner: Box<Any>,
+/// A marker trait which marks all events.
+pub trait Event: Any + Debug {}
+
+/// A trait which can be implemented when something can handle a specific kind of event.
+pub trait EventHandler<E: Event>: Any {
+    /// Handle an event, returns whether to propagate the event to the remaining handlers.
+    fn handle(&self, event: &E) -> Propagation;
 }
 
-impl AbstractEvent {
-    /// Creates an abstract event from a concrete event.
-    pub fn new<E: Event>(event: E) -> AbstractEvent {
-        AbstractEvent {
-            inner: Box::new(event),
+struct Record<P, T>(P, T);
+
+impl<P: PartialEq, T> PartialEq for Record<P, T> {
+    fn eq(&self, other: &Record<P, T>) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<P: Eq, T> Eq for Record<P, T> {}
+
+impl<P: PartialOrd, T> PartialOrd for Record<P, T> {
+    fn partial_cmp(&self, other: &Record<P, T>) -> Option<Ordering> {
+        self.0.partial_cmp(&other.0)
+    }
+}
+
+impl<P: Ord, T> Ord for Record<P, T> {
+    fn cmp(&self, other: &Record<P, T>) -> Ordering {
+        self.0.cmp(&other.0)
+    }
+}
+
+/// An enum representing whether to keep propagating an event or to stop the propagation.
+pub enum Propagation {
+    /// Stop the propagation of the event, the remaining handlers will not get invoked.
+    Stop,
+    /// Continue propagating the event.
+    Continue,
+}
+
+#[derive(Debug)]
+struct GarbageEvent;
+
+impl Event for GarbageEvent {}
+
+impl<E, F> EventHandler<E> for Box<F> where E: Event, F: 'static + Fn(&E) -> Propagation {
+    fn handle(&self, evt: &E) -> Propagation {
+        self(evt)
+    }
+}
+
+/// An event dispatcher, this takes care of dispatching events to their respective handlers.
+pub struct Dispatcher {
+    handlers: BTreeMap<TypeId, Vec<Record<Priority, Box<Any>>>>,
+    queue: Vec<(TypeId, Box<Any>)>,
+}
+
+impl Dispatcher {
+    /// Create a new `Dispatcher`.
+    pub fn new() -> Dispatcher {
+        Dispatcher {
+            handlers: BTreeMap::new(),
+            queue: Vec::new(),
         }
     }
 
-    /// Downcasts this abstract event into a concrete event.
-    pub fn downcast<E: Event + 'static>(&self) -> Option<&E> {
-        self.inner.downcast_ref::<E>()
+    /// Register an event handler.
+    pub fn register<E, H>(&mut self, priority: Priority, handler: H) where E: Event + 'static, H: EventHandler<E> {
+        let handler: Box<EventHandler<E>> = Box::new(handler) as Box<EventHandler<E>>;
+        let ent = self.handlers.entry(TypeId::of::<E>())
+                               .or_insert_with(|| Vec::new());
+        ent.push(Record(priority, Box::new(handler) as Box<Any>));
+        ent.sort();
     }
 
-    /// Checks whether this abstract event is a specific concrete event.
-    pub fn is<E: Event + 'static>(&self) -> bool {
-        self.inner.is::<E>()
+    /// Append an event to the queue.
+    pub fn dispatch<E>(&mut self, event: E) where E: Event {
+        self.queue.push((TypeId::of::<E>(), Box::new(event) as Box<Any>));
+    }
+
+    /// Flush all events in the queue so they can be handled by their respective handlers.
+    /// Returns whether there are still pending events.
+    pub fn flush(&mut self) -> bool {
+        let mut q = Vec::new();
+        mem::swap(&mut self.queue, &mut q);
+        'evts: for (t, evt) in q {
+            if let Some(handlers) = self.handlers.get_mut(&t) {
+                for &mut Record(_, ref mut handler) in handlers {
+                    // GarbageEvent is a garbage type.
+                    // The actual passed type is NEVER of this type.
+                    let h: &mut EventHandler<GarbageEvent> = unsafe {
+                        let handler_obj: &mut TraitObject = mem::transmute(handler);
+                        let handler_inner: *mut TraitObject = mem::transmute(handler_obj.data);
+                        mem::transmute(*handler_inner)
+                    };
+                    let e: &&GarbageEvent = unsafe {
+                        let evt_ref: &Any = &evt;
+                        let evt_obj: TraitObject = mem::transmute(evt_ref);
+                        mem::transmute(evt_obj.data)
+                    };
+                    match h.handle(e) {
+                        Propagation::Stop => { continue 'evts; },
+                        Propagation::Continue => (),
+                    }
+                }
+            }
+        }
+        !self.queue.is_empty()
+    }
+
+    /// Flushes all events, like `flush`, but keeps doing this until there is nothing left in the
+    /// queue.
+    pub fn flush_all(&mut self) {
+        while self.flush() {}
+    }
+
+    /// Dispatch an event to the handlers right now, without going through the queue.
+    pub fn dispatch_now<E>(&mut self, event: E) where E: Event {
+        if let Some(handlers) = self.handlers.get_mut(&TypeId::of::<E>()) {
+            for &mut Record(_, ref mut handler) in handlers {
+                let h = handler.downcast_mut::<Box<EventHandler<E>>>().unwrap();
+                match h.handle(&event) {
+                    Propagation::Stop => { return; },
+                    Propagation::Continue => (),
+                }
+            }
+        }
     }
 }
 
-/// A marker trait which all events must implement.
-pub trait Event: Any + Debug {}
+pub struct EventProxy<T: ?Sized, E: Event> {
+    inner: Arc<Box<T>>,
+    vtable: *mut (),
+    _event_type: PhantomData<E>,
+}
+
+impl<T: ?Sized, E: Event> EventProxy<T, E> {
+    /// Unsafe because T is assumed to be a TraitObject or at least have its shape.
+    /// If it is not, things will break. In a fascinatingly horrible manner.
+    /// Some people, such as myself, find it hilarious. Most people do not.
+    /// T is also assumed to actually support EventHandler<E>, if it does not, refer to above
+    /// statement.
+    pub unsafe fn new<H: EventHandler<E>>(inner: Arc<Box<T>>) -> EventProxy<T, E> {
+        let box_with_vtable = &*ptr::null::<H>() as &EventHandler<E>;
+        let obj: TraitObject = mem::transmute(box_with_vtable);
+        EventProxy {
+            inner: inner,
+            vtable: obj.vtable,
+            _event_type: PhantomData,
+        }
+    }
+}
+
+impl<T: ?Sized, E: Event> EventHandler<E> for EventProxy<T, E> where Box<T>: 'static {
+    fn handle(&self, evt: &E) -> Propagation {
+        let inner = Arc::into_raw(self.inner.clone());
+        let obj = TraitObject { data: unsafe { mem::transmute(inner) }, vtable: self.vtable };
+        let handler: &EventHandler<E> = unsafe { mem::transmute(obj) };
+        let prop = handler.handle(evt);
+        unsafe { Arc::<Box<T>>::from_raw(mem::transmute(inner)); }
+        prop
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Priority {
+    Max,
+    Default,
+    Min,
+}
+
+impl Default for Priority {
+    fn default() -> Priority {
+        Priority::Default
+    }
+}
+
+#[derive(Debug)]
+pub struct SendElement(pub Element);
+
+impl Event for SendElement {}
+
+#[derive(Debug)]
+pub struct ReceiveElement(pub Element);
+
+impl Event for ReceiveElement {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "success")]
+    fn test() {
+        let mut disp = Dispatcher::new();
+
+        struct MyHandler;
+        struct EvilHandler;
+        struct EventFilter;
+
+        #[derive(Debug)]
+        struct MyEvent {
+            should_be_42: u32,
+        }
+
+        impl Event for MyEvent {}
+
+        impl EventHandler<MyEvent> for MyHandler {
+            fn handle(&self, evt: &MyEvent) -> Propagation {
+                if evt.should_be_42 == 42 {
+                    panic!("success");
+                }
+                else {
+                    panic!("not 42");
+                }
+            }
+        }
+
+        impl EventHandler<MyEvent> for EvilHandler {
+            fn handle(&self, _: &MyEvent) -> Propagation {
+                panic!("should not be called");
+            }
+        }
+
+        impl EventHandler<MyEvent> for EventFilter {
+            fn handle(&self, evt: &MyEvent) -> Propagation {
+                if evt.should_be_42 == 42 {
+                    Propagation::Continue
+                }
+                else {
+                    Propagation::Stop
+                }
+            }
+        }
+
+        disp.register(Priority::Max, EventFilter);
+        disp.register(Priority::Min, EvilHandler);
+        disp.register(Priority::Default, MyHandler);
+        disp.register(Priority::Min, EvilHandler);
+
+        disp.dispatch(MyEvent {
+            should_be_42: 39,
+        });
+
+        disp.dispatch(MyEvent {
+            should_be_42: 42,
+        });
+
+        disp.flush();
+    }
+}