simplify Envelope type, just have event loop threads generate Events which are then wrapped by Envelopes transparently

src/event/mod.rs

@@ -13,15 +13,8 @@ pub enum Event {
 
 #[derive(Debug)]
 pub struct Envelope {
-    pub from: Option<String>,
+    pub from: String,
     pub event: Event,
 }
 
-impl Envelope {
-    pub fn new (event: Event) -> Envelope {
-        Envelope {
-            from: None,
-            event: event
-        }
-    }
-}
+impl Envelope {}

src/lib.rs

@@ -82,10 +82,10 @@ impl Tenquestionmarks {
                 let (dispatcher_sender, dispatcher_receiver) = transformable_channels::mpsc::channel();
                 dispatchers.insert(key, dispatcher_receiver);
 
-                let mapped_sender = dispatcher_sender.map(move |envelope: Envelope| {
+                let mapped_sender = dispatcher_sender.map(move |event: Event| {
                     Envelope {
-                        from: Some(from.clone()),
-                        event: envelope.event
+                        from: from.clone(),
+                        event: event
                     }
                 });
 

src/modules/autolink.rs

@@ -83,7 +83,7 @@ fn print_any_link (link: &Link, message: &Message) {
 }
 
 impl EventLoop for AutolinkModule {
-    fn run (&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run (&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         let link_regex = Regex::new(r"\[\[([^\[\]]*)\]\]").expect("Invalid regex...");
         let mut searchers = AggregateSearcher::new();
         searchers.add_searcher("mtg", Box::new(MtgSearcher::new()));

src/modules/discord.rs

@@ -102,7 +102,7 @@ fn channel_from_public_channel (discord: Arc<Discord>, channel: discord::model::
 }
 
 impl EventLoop for DiscordModule {
-    fn run (&self, sender: Box<ExtSender<event::Envelope>>, _: Receiver<Arc<event::Envelope>>) {
+    fn run (&self, sender: Box<ExtSender<event::Event>>, _: Receiver<Arc<event::Envelope>>) {
         let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Discord module: Login failed"));
         let (mut connection, _) = discord.connect().expect("Discord module: Connection failed");
 
@@ -121,9 +121,9 @@ impl EventLoop for DiscordModule {
                             for channel in server.channels {
                                 info!(" - Joined channel: {}", channel.name);
 
-                                match sender.send(Envelope::new(event::Event::SelfJoin {
+                                match sender.send(event::Event::SelfJoin {
                                     channel: channel_from_public_channel(discord.clone(), channel)
-                                })) {
+                                }) {
                                     Err(err) => error!("Error sending selfjoin event: {:?}", err),
                                     Ok(_) => {}
                                 }
@@ -147,7 +147,7 @@ impl EventLoop for DiscordModule {
                         channel: discord.get_channel(message.channel_id).ok().and_then(|channel| make_channel_object(discord.clone(), channel))
                     };
 
-                    if let Err(err) = sender.send(Envelope::new(event::Event::Message { message: message })) {
+                    if let Err(err) = sender.send(event::Event::Message { message: message }) {
                         error!("Error sending message event: {:?}", err)
                     }
                 }

src/modules/echo.rs

@@ -29,7 +29,7 @@ impl EchoModule {
 }
 
 impl EventLoop for EchoModule {
-    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         loop {
             match receiver.recv() {
                 Ok(envelope) => {

src/modules/echobox.rs

@@ -36,7 +36,7 @@ impl EchoboxModule {
 }
 
 impl EventLoop for EchoboxModule {
-    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         let echobox = Echobox::with_file(&self.file).unwrap();
 
         loop {

src/modules/logger.rs

@@ -21,7 +21,7 @@ impl LoggerModule {
 }
 
 impl EventLoop for LoggerModule {
-    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         loop {
             match receiver.recv() {
                 Ok(envelope) => {

src/modules/lua.rs

@@ -54,7 +54,7 @@ implement_lua_push!(Message, |mut metatable| {
 });
 
 impl EventLoop for LuaModule {
-    fn run (&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run (&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         let mut lua = Lua::new();
         lua.openlibs();
 

src/modules/mod.rs

@@ -10,7 +10,7 @@ pub mod logger;
 
 pub mod loader;
 
-use event::Envelope;
+use event::{Event, Envelope};
 
 use std::sync::Arc;
 use std::sync::mpsc::Receiver;
@@ -25,7 +25,7 @@ pub struct Module {
 }
 
 impl Module {
-    pub fn run (&self, sender: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    pub fn run (&self, sender: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         self.event_loop.run(sender, receiver);
     }
 
@@ -55,5 +55,5 @@ impl Module {
 }
 
 pub trait EventLoop : Sync {
-    fn run (&self, _: Box<ExtSender<Envelope>>, _: Receiver<Arc<Envelope>>) {}
+    fn run (&self, _: Box<ExtSender<Event>>, _: Receiver<Arc<Envelope>>) {}
 }

src/modules/pvn.rs

@@ -141,7 +141,7 @@ impl PirateVsNinja {
 }
 
 impl EventLoop for PvnModule {
-    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         let mut pvn = PirateVsNinja {
             pirates: Pirates::new(),
             ninjas: Ninjas::new()

src/modules/random.rs

@@ -40,7 +40,7 @@ impl RandomModule {
 }
 
 impl EventLoop for RandomModule {
-    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
         let mut rng = rand::thread_rng();
 
         loop {

src/modules/stdin.rs

@@ -36,7 +36,7 @@ impl StdinModule {
 }
 
 impl EventLoop for StdinModule {
-    fn run(&self, sender: Box<ExtSender<Envelope>>, _: Receiver<Arc<Envelope>>) {
+    fn run(&self, sender: Box<ExtSender<Event>>, _: Receiver<Arc<Envelope>>) {
         loop {
             let mut input = String::new();
             match io::stdin().read_line(&mut input) {
@@ -52,7 +52,7 @@ impl EventLoop for StdinModule {
                         channel: None
                     };
 
-                    match sender.send(Envelope::new(Event::Message { message: message })) {
+                    match sender.send(Event::Message { message: message }) {
                         Err(err) => error!("Error sending message event: {:?}", err),
                         Ok(_) => {}
                     }