Struct tokio_core::reactor::Remote
[−]
[src]
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.
Methods
impl Remote
[src]
fn spawn<F, R>(&self, f: F) where
F: FnOnce(&Handle) -> R + Send + 'static,
R: IntoFuture<Item = (), Error = ()>,
R::Future: 'static,
[src]
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.
fn id(&self) -> CoreId
[src]
Return the ID of the represented Core
fn handle(&self) -> Option<Handle>
[src]
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
[src]
fn clone(&self) -> Remote
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<F> Executor<F> for Remote where
F: Future<Item = (), Error = ()> + Send + 'static,
[src]
F: Future<Item = (), Error = ()> + Send + 'static,
fn execute(&self, future: F) -> Result<(), ExecuteError<F>>
[src]
Spawns a future to run on this Executor
, typically in the "background". Read more