[][src]Struct tokio_core::reactor::Core

pub struct Core { /* fields omitted */ }

An 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.


impl Core[src]

pub fn new() -> Result<Core>[src]

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

pub fn handle(&self) -> Handle[src]

Returns a handle to this event loop which cannot be sent across threads but 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 runtime(&self) -> &Runtime[src]

Returns a reference to the runtime backing the instance

This provides access to the newer features of Tokio.

pub fn remote(&self) -> Remote[src]

Generates a remote handle to this event loop which can be used to spawn tasks from other threads into this event loop.

pub fn run<F>(&mut self, f: F) -> Result<F::Item, F::Error> where
    F: Future

Runs a future until completion, driving the event loop while we're otherwise waiting for the future to complete.

This function will begin executing the event loop and will finish once the provided future is resolved. Note that the future argument here crucially does not require the 'static nor Send bounds. As a result the future will be "pinned" to not only this thread but also this stack frame.

This function will return the value that the future resolves to once the future has finished. If the future never resolves then this function will never return. Any other futures spawned on this core may still be incomplete when this function returns.


This method will not catch panics from polling the future f. If the future panics then it's the responsibility of the caller to catch that panic and handle it as appropriate.

pub fn turn(&mut self, max_wait: Option<Duration>)[src]

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

It only makes sense to call this method if you've previously spawned a future onto this event loop.

loop { core.turn(None) } is equivalent to calling run with an empty future (one that never finishes).

pub fn id(&self) -> CoreId[src]

Get the ID of this loop

Trait Implementations

impl Debug for Core[src]

impl<F> Executor<F> for Core where
    F: Future<Item = (), Error = ()> + 'static, 

Auto Trait Implementations

impl !RefUnwindSafe for Core

impl !Send for Core

impl !Sync for Core

impl Unpin for Core

impl !UnwindSafe for Core

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.