Struct mio::EventLoop

pub struct EventLoop<H: Handler> {
    // some fields omitted
}

Single threaded IO event loop.

Methods

impl<H: Handler> EventLoop<H>

fn new() -> Result<EventLoop<H>>

Initializes a new event loop using default configuration settings. The event loop will not be running yet.

fn configured(config: EventLoopConfig) -> Result<EventLoop<H>>

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) -> TimerResult<Timeout>

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: ?Sized>(&mut self, io: &E, token: Token) -> Result<()> where E: Evented

Registers an IO handle with the event loop.

fn register_opt<E: ?Sized>(&mut self, io: &E, token: Token, interest: EventSet, opt: PollOpt) -> Result<()> where E: Evented

Registers an IO handle with the event loop.

fn reregister<E: ?Sized>(&mut self, io: &E, token: Token, interest: EventSet, opt: PollOpt) -> Result<()> where E: Evented

Re-Registers an IO handle with the event loop.

fn run(&mut self, handler: &mut H) -> Result<()>

Keep spinning the event loop indefinitely, and notify the handler whenever any of the registered handles are ready.

fn deregister<E: ?Sized>(&mut self, io: &E) -> Result<()> where E: Evented

Deregisters an IO handle with the event loop.

fn run_once(&mut self, handler: &mut H) -> Result<()>

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.

Trait Implementations

impl<H: Debug + Handler> Debug for EventLoop<H> where H::Timeout: Debug, H::Message: Debug

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<H: Handler> Sync for EventLoop<H>

impl<H: Handler> Drop for EventLoop<H>

fn drop(&mut self)

A method called when the value goes out of scope.