1 files changed, 50 insertions, 55 deletions

diff --git a/src/event/manager.rs b/src/event/manager.rs
index 867a77f..66a56ab 100644
--- a/src/event/manager.rs
+++ b/src/event/manager.rs
@@ -1,3 +1,4 @@
+use crate::event::event::Event;
 use crate::packet::packet::Packet;
 use crate::session::session::Session;
 use std::cell::RefCell;
@@ -5,75 +6,76 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::rc::Rc;
 
+/******************************************************************************
+ * Event Queue
+ ******************************************************************************/
+
+pub struct EventQueue {
+    queue: VecDeque<(Event, Option<Rc<RefCell<Session>>>)>,
+}
+
+impl EventQueue {
+    pub fn new() -> EventQueue {
+        EventQueue {
+            queue: VecDeque::new(),
+        }
+    }
+
+    pub fn add(&mut self, event: Event, session: Option<Rc<RefCell<Session>>>) {
+        self.queue.push_back((event, session));
+    }
+
+    fn pop(&mut self) -> Option<(Event, Option<Rc<RefCell<Session>>>)> {
+        self.queue.pop_front()
+    }
+}
+
+/******************************************************************************
+ * Event Manager
+ ******************************************************************************/
+
 pub trait EventHandle {
-    fn init(&mut self);
+    fn init(&mut self, event_mgr: &mut EventManager);
     fn handle(
         &mut self,
-        index: usize,
+        event: Event,
+        queue: &mut EventQueue,
         packet: Option<&Packet>,
         session: Option<Rc<RefCell<Session>>>,
     );
 }
 
 pub struct EventManager {
-    index2event: HashMap<usize, &'static str>, // event index -> event name
-    event2index: HashMap<&'static str, usize>, // event name -> event index
-    ready_event: VecDeque<(usize, Option<Rc<RefCell<Session>>>)>, // ready event index
-    cared_event: HashMap<usize, RefCell<Vec<Box<dyn EventHandle>>>>, // event index -> event handle
+    map: HashMap<Event, RefCell<Vec<Box<dyn EventHandle>>>>,
 }
 
 impl EventManager {
     pub fn new() -> EventManager {
         EventManager {
-            index2event: HashMap::new(),
-            event2index: HashMap::new(),
-            ready_event: VecDeque::new(),
-            cared_event: HashMap::new(),
-        }
-    }
-
-    pub fn event2index(&mut self, event: &'static str) -> usize {
-        if let Some(index) = self.event2index.get(event) {
-            *index
-        } else {
-            let index = self.event2index.len();
-            self.event2index.insert(event, index);
-            self.index2event.insert(index, event);
-            index
+            map: HashMap::new(),
         }
     }
 
-    pub fn index2event(&self, index: usize) -> Option<&'static str> {
-        if let Some(event) = self.index2event.get(&index) {
-            Some(*event)
-        } else {
-            None
-        }
-    }
-
-    pub fn register(&mut self, index: usize, handle: Box<dyn EventHandle>) {
-        if let Some(vec) = self.cared_event.get(&index) {
+    pub fn register(&mut self, event: Event, handle: Box<dyn EventHandle>) {
+        if let Some(vec) = self.map.get(&event) {
             let mut vec = vec.borrow_mut();
             vec.push(handle);
         } else {
             let mut vec = Vec::with_capacity(1024);
             vec.push(handle);
-            self.cared_event.insert(index, RefCell::new(vec));
+            self.map.insert(event, RefCell::new(vec));
         }
     }
 
-    pub fn trigger(&mut self, index: usize, session: Option<Rc<RefCell<Session>>>) {
-        self.ready_event.push_back((index, session));
-    }
-
-    pub fn dispatch(&mut self, packet: Option<&Packet>) {
+    pub fn dispatch(&mut self, packet: Option<&Packet>, queue: &mut EventQueue) {
         loop {
-            if let Some(event) = self.ready_event.pop_front() {
-                println!("Dispatch event: {:?}", self.index2event.get(&event.0));
-                if let Some(vec) = self.cared_event.get(&event.0) {
+            let result = queue.pop();
+            if let Some((event, session)) = result {
+                println!("Dispatch Event: {}", event);
+                if let Some(vec) = self.map.get(&event) {
                     let mut vec = vec.borrow_mut();
                     for callback in vec.iter_mut() {
-                        callback.handle(event.0, packet, event.1.clone());
+                        callback.handle(event, queue, packet, session.clone());
                     }
                 }
             } else {
@@ -89,12 +91,11 @@ impl EventManager {
 
 #[cfg(test)]
 mod tests {
+    use super::EventManager;
     use crate::event::manager::EventHandle;
+    use crate::event::manager::EventQueue;
     use crate::packet::packet::Packet;
     use crate::plugin::example::ExamplePulgin;
-    use crate::thread::thread::ThreadContex;
-    use std::cell::RefCell;
-    use std::rc::Rc;
 
     /*
      * Frame 217: 131 bytes on wire (1048 bits), 131 bytes captured (1048 bits) on interface en0, id 0
@@ -220,12 +221,11 @@ mod tests {
             0x2a, 0x0d, 0x0a, 0x0d, 0x0a, /* HTTP END */
         ];
 
-        // Create plugin
-        let thread_ctx = Rc::new(RefCell::new(ThreadContex::new()));
-        let mut plugin = ExamplePulgin::new("Example Plugin", thread_ctx.clone());
-        plugin.init();
+        let mut event_mgr = EventManager::new();
+        let mut plugin = ExamplePulgin::new("Example Plugin");
+        plugin.init(&mut event_mgr);
 
-        // Handle packet
+        let mut queue = EventQueue::new();
         let mut packet = Packet::new(&bytes, bytes.len() as u32);
         let result = packet.handle();
         match result {
@@ -242,12 +242,7 @@ mod tests {
             }
         }
 
-        // Dispatch event
-        thread_ctx
-            .borrow_mut()
-            .get_event_mgr()
-            .borrow_mut()
-            .dispatch(Some(&packet));
+        event_mgr.dispatch(Some(&packet), &mut queue);
 
         // assert_eq!(1, 0);
     }