Struct tokio::reactor::Reactor

pub struct Reactor { /* fields omitted */ }

The core reactor, or event loop.

The event loop is the main source of blocking in an application which drives all other I/O events and notifications happening. Each event loop can have multiple handles pointing to it, each of which can then be used to create various I/O objects to interact with the event loop in interesting ways.

Methods

impl Reactor

pub fn new() -> Result<Reactor, Error>

Creates a new event loop, returning any error that happened during the creation.

pub fn handle(&self) -> Handle

Returns a handle to this event loop which can be sent across threads and can be used as a proxy to the event loop itself.

Handles are cloneable and clones always refer to the same event loop. This handle is typically passed into functions that create I/O objects to bind them to this event loop.

pub fn turn(&mut self, max_wait: Option<Duration>) -> Result<Turn, Error>

Performs one iteration of the event loop, blocking on waiting for events for at most max_wait (forever if None).

This method is the primary method of running this reactor and processing I/O events that occur. This method executes one iteration of an event loop, blocking at most once waiting for events to happen.

If a max_wait is specified then the method should block no longer than the duration specified, but this shouldn't be used as a super-precise timer but rather a "ballpark approximation"

Return value

This function returns an instance of Turn

Turn as of today has no extra information with it and can be safely discarded. In the future Turn may contain information about what happened while this reactor blocked.

Errors

This function may also return any I/O error which occurs when polling for readiness of I/O objects with the OS. This is quite unlikely to arise and typically mean that things have gone horribly wrong at that point. Currently this is primarily only known to happen for internal bugs to tokio itself.

pub fn is_idle(&self) -> bool

Returns true if the reactor is currently idle.

Idle is defined as all tasks that have been spawned have completed, either successfully or with an error.

Trait Implementations

impl AsRawFd for Reactor

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl Park for Reactor

type Unpark = Handle

Unpark handle type for the Park implementation.

type Error = Error

Error returned by park

fn unpark(&self) -> <Reactor as Park>::Unpark

Get a new Unpark handle associated with this Park instance.

fn park(&mut self) -> Result<(), Error>

Block the current thread unless or until the token is available.

fn park_timeout(&mut self, duration: Duration) -> Result<(), Error>

Park the current thread for at most duration.

impl Debug for Reactor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.