event 0.2.1

A mulit-threaded event loop for Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#![feature(macro_rules, unboxed_closures)]
// #![deny(missing_docs, warnings)]

//! An Event-Loop for Rust.

extern crate mio;

use std::cell::RefCell;
use std::time::duration::Duration;
use ioloop::{IoLoop, IoLoopSender};

pub use handler::{Handler, ClosureHandler};
pub use error::{EventResult, EventError};

use registration::Registration;

mod ioloop;
mod error;
mod handler;
mod registration;
mod util;

thread_local! {
    static EVENT_LOOP: RefCell<IoLoop> =
        RefCell::new(IoLoop::new())
}

thread_local! {
    static EVENT_LOOP_SENDER: IoLoopSender =
        EVENT_LOOP.with(move |event| event.borrow().channel())
}

pub fn register<H: Handler>(handler: H) {
    EVENT_LOOP_SENDER.with(move |events| {
        let _ = events.send(Registration::new(box handler));
    });
}

pub fn timeout<F: FnOnce() + 'static>(callback: F, timeout: Duration) {
    EVENT_LOOP_SENDER.with(move |events| {
        let _ = events.send(Registration::timeout(callback, timeout));
    });
}

pub fn next<F: FnOnce() + 'static>(callback: F) {
    EVENT_LOOP_SENDER.with(move |events| {
        let _ = events.send(Registration::next(callback));
    });
}

pub fn start() {
    EVENT_LOOP_SENDER.with(|_| {});
}

pub fn interval<F: FnMut() + Send>(callback: F, delay: Duration) {
    struct Interval<F> {
        callback: F,
        delay: Duration
    }

    impl<F: FnMut() + Send()> FnOnce() for Interval<F> {
        extern "rust-call" fn call_once(mut self, _: ()) {
            (self.callback)();
            let delay = self.delay.clone();
            timeout(self, delay);
        }
    }

    timeout(Interval { callback: callback, delay: delay.clone() }, delay);
}

// Starts the event loop on this thread.
pub fn run() {
    EVENT_LOOP.with(move |event| event.borrow_mut().run().unwrap())
}