Struct asynchronous::EventLoop

pub struct EventLoop<Ev> { /* fields omitted */ }

Executes a task in background collecting events from other threads

Methods

impl<Ev> EventLoop<Ev> where
    Ev: Send + 'static, 

fn new() -> EventLoop<Ev>

Creates a new Event Loop and collects all the events into a vector

use asynchronous::EventLoop;
 
let el = EventLoop::new().finish_in_ms(100);
el.emit("Event1");
el.emit("Event2");
// Do something here
el.to_promise().finally_sync(|res| {  // res: Result<Vec<Ev>,()>
    assert_eq!(res.unwrap(), vec!["Event1", "Event2"]);
});

fn on<F>(f: F) -> EventLoop<Ev> where
    F: Send + 'static + Fn(Ev), 

Creates a new Event Loop and parses all the events produced

use asynchronous::EventLoop;
enum MiEvents { Hello(String), Goodbye(u32)}

let el = EventLoop::on(|event| {
   match event {
      MiEvents::Hello(s) => println!("Hello {}", s),
      MiEvents::Goodbye(v) => println!("Goodbye {}", v),
   }
});
el.emit(MiEvents::Hello("World".to_string()));
el.emit(MiEvents::Goodbye(3));
// Do something here
el.finish().to_promise().finally_sync(|res| {  // res: Result<Vec<Ev>,()>
    assert_eq!(res.unwrap().len(), 0);
});

fn on_managed<F>(f: F) -> EventLoop<Ev> where
    F: Send + 'static + Fn(Ev) -> Emit<Ev>, 

Creates a new Event Loop, parses all the events produced and collects what you want into a vector

use asynchronous::{EventLoop, Emit};
enum MiEvents { Hello(String), Goodbye(u32)}
 
let el = EventLoop::on_managed(|event| {
   match event {
      MiEvents::Hello(s) => { println!("Hello {}", s); Emit::Continue },
      MiEvents::Goodbye(v) => Emit::Event(MiEvents::Goodbye(v)),
   }
});
el.emit(MiEvents::Hello("World".to_string()));
el.emit(MiEvents::Goodbye(555));
// Do something here
el.finish().to_promise().finally_sync(|res| {  // res: Result<Vec<Ev>,()>
    let vec_res = res.unwrap();
    assert_eq!(vec_res.len(), 1);
    match vec_res[0] { MiEvents::Goodbye(vec_res) => assert_eq!(vec_res, 555), _=> () };
});

fn emit(&self, event: Ev) -> Result<(), Ev>

Triggers an event "Ev" once. Returns the same event if the event loop is not active.

fn emit_until<F>(&self, f: F) where
    F: Send + 'static + Fn() -> Emit<Ev>, 

Triggers an event "Ev" until the return of the "clousure" is None

use asynchronous::{EventLoop, Emit};
 
let el = EventLoop::new();
let x = std::sync::Arc::new(std::sync::Mutex::new(0));
el.emit_until(move || {
   let mut lock_x = x.lock().unwrap(); *lock_x += 1;
   if *lock_x <= 3 { Emit::Event("Event Test") } else { Emit::Stop }
});    
// Do something here
el.finish_in_ms(100).to_promise().finally_sync(|res| {  // res: Result<Vec<Ev>,()>
    assert_eq!(res.unwrap(), vec!["Event Test", "Event Test", "Event Test"]);
});

fn finish(self) -> EventLoop<Ev>

Finishes the event loop immediately.

fn finish_in_ms(self, duration_ms: u32) -> EventLoop<Ev>

Finishes the event loop in N milliseconds

fn is_active(&self) -> bool

Returns true if the event loop is running

fn get_handler(&self) -> EventLoopHandler<Ev>

Returns a handler to Event Emitter

fn to_promise(self) -> Promise<Vec<Ev>, ()>

Once the event loop is finished, the promise collects the results.