RustyEmitter

RustyEmitter is a basic implementation of a simple emitter. The module expose a Events trait with the on, off and emit methods, and a default implementation of that trait, called Emitter.

In order to use it, you must use the trait in your code.

The Emitter can register multiple callbacks for the same event, and it will pass a mutable reference of an HashMap<String, T> to those.

Since it's a mutable reference the function consuming the emitter can modify the HashMap, hence allowing a 2 channel communication between the event dispatcher and the code listening to the event

Build and Test

The project uses cargo build using cargo build and test it using the cargo test commands.

Cargo configuration

just add

[dependencies.RustyEmitter]
version = "2.1.0"

to your Cargo.toml file.

to use it like

extern crate RustyEmitter;
use RustyEmitter::{Events, Emitter};
use std::collections::HashMap;

fn main(){  
  let (mut emitter, callback) = (
    // create a new emitter instance
    Emitter::new(),
    // creating the handler in the same lifetime 
    &mut |data:& mut HashMap<String, String>| { 
      println!("IT WORKS!");
      for (key, value) in data {
          println!("{}: {}", key, value);
      }
    }
  );
  // listen to the "IT WORKS" event
  emitter.on("IT WORKS".to_string(), callback);
  // fire the "IT WORKS" event with an empty HashMap;
  emitter.emit("IT WORKS".to_string(), & mut HashMap::new());

  // fire it again passing some more data
  let mut datas : HashMap<String, String> = HashMap::new();
  datas.insert("some data".to_string(), "here".to_string());
  emitter.emit("IT WORKS".to_string(), & mut datas);
}