Struct rotor::mio::prelude::EventLoop
[−]
[src]
pub struct EventLoop<H> where H: Handler {
// some fields omitted
}Single threaded IO event loop.
Methods
impl<H> EventLoop<H> where H: Handler
fn new() -> Result<EventLoop<H>, Error>
Initializes a new event loop using default configuration settings. The event loop will not be running yet.
fn configured(config: EventLoopConfig) -> Result<EventLoop<H>, Error>
fn channel(&self) -> Sender<H::Message>
Returns a sender that allows sending messages to the event loop in a thread-safe way, waking up the event loop if needed.
Example
use std::thread; use mio::{EventLoop, Handler}; struct MyHandler; impl Handler for MyHandler { type Timeout = (); type Message = u32; fn notify(&mut self, event_loop: &mut EventLoop<MyHandler>, msg: u32) { assert_eq!(msg, 123); event_loop.shutdown(); } } let mut event_loop = EventLoop::new().unwrap(); let sender = event_loop.channel(); // Send the notification from another thread thread::spawn(move || { let _ = sender.send(123); }); let _ = event_loop.run(&mut MyHandler);
Implementation Details
Each EventLoop contains a lock-free queue with a pre-allocated buffer size. The size can be changed by modifying EventLoopConfig.notify_capacity. When a message is sent to the EventLoop, it is first pushed on to the queue. Then, if the EventLoop is currently running, an atomic flag is set to indicate that the next loop iteration should be started without waiting.
If the loop is blocked waiting for IO events, then it is woken up. The strategy for waking up the event loop is platform dependent. For example, on a modern Linux OS, eventfd is used. On older OSes, a pipe is used.
The strategy of setting an atomic flag if the event loop is not already sleeping allows avoiding an expensive wakeup operation if at all possible.
fn timeout_ms(&mut self, token: H::Timeout, delay: u64) -> Result<Timeout, TimerError>
Schedules a timeout after the requested time interval. When the duration has been reached, Handler::timeout will be invoked passing in the supplied token.
Returns a handle to the timeout that can be used to cancel the timeout using #clear_timeout.
Example
use mio::{EventLoop, Handler}; struct MyHandler; impl Handler for MyHandler { type Timeout = u32; type Message = (); fn timeout(&mut self, event_loop: &mut EventLoop<MyHandler>, timeout: u32) { assert_eq!(timeout, 123); event_loop.shutdown(); } } let mut event_loop = EventLoop::new().unwrap(); let timeout = event_loop.timeout_ms(123, 300).unwrap(); let _ = event_loop.run(&mut MyHandler);
fn clear_timeout(&mut self, timeout: Timeout) -> bool
If the supplied timeout has not been triggered, cancel it such that it will not be triggered in the future.
fn shutdown(&mut self)
Tells the event loop to exit after it is done handling all events in the current iteration.
fn is_running(&self) -> bool
Indicates whether the event loop is currently running. If it's not it has either stopped or is scheduled to stop on the next tick.
fn register<E>(&mut self, io: &E, token: Token, interest: EventSet, opt: PollOpt) -> Result<(), Error> where E: Evented + ?Sized
Registers an IO handle with the event loop.
fn reregister<E>(&mut self, io: &E, token: Token, interest: EventSet, opt: PollOpt) -> Result<(), Error> where E: Evented + ?Sized
Re-Registers an IO handle with the event loop.
fn run(&mut self, handler: &mut H) -> Result<(), Error>
Keep spinning the event loop indefinitely, and notify the handler whenever any of the registered handles are ready.
fn deregister<E>(&mut self, io: &E) -> Result<(), Error> where E: Evented + ?Sized
Deregisters an IO handle with the event loop.
fn run_once(&mut self, handler: &mut H, timeout_ms: Option<usize>) -> Result<(), Error>
Spin the event loop once, with a timeout of one second, and notify the handler if any of the registered handles become ready during that time.