Struct tokio_core::reactor::Remote

pub struct Remote { /* fields omitted */ }

Handle to an event loop, used to construct I/O objects, send messages, and otherwise interact indirectly with the event loop itself.

Handles can be cloned, and when cloned they will still refer to the same underlying event loop.

Implementations

impl Remote

pub fn spawn<F, R>(&self, f: F) where
    F: FnOnce(&Handle) -> R + Send + 'static,
    R: IntoFuture<Item = (), Error = ()>,
    R::Future: 'static, 

Spawns a new future into the event loop this remote is associated with.

This function takes a closure which is executed within the context of the I/O loop itself. The future returned by the closure will be scheduled on the event loop and run to completion.

Note that while the closure, F, requires the Send bound as it might cross threads, the future R does not.

Panics

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 id(&self) -> CoreId

Return the ID of the represented Core

pub fn handle(&self) -> Option<Handle>

Attempts to "promote" this remote to a handle, if possible.

This function is intended for structures which typically work through a Remote but want to optimize runtime when the remote doesn't actually leave the thread of the original reactor. This will attempt to return a handle if the Remote is on the same thread as the event loop and the event loop is running.

If this Remote has moved to a different thread or if the event loop is running, then None may be returned. If you need to guarantee access to a Handle, then you can call this function and fall back to using spawn above if it returns None.

Trait Implementations

impl Clone for Remote

pub fn clone(&self) -> Remote

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Remote

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

pub fn execute(&self, future: F) -> Result<(), ExecuteError<F>>

Spawns a future to run on this Executor, typically in the "background".