Struct tokio_util::context::TokioContext [−][src]
pub struct TokioContext<F> { /* fields omitted */ }
rt
only.Expand description
TokioContext
allows running futures that must be inside Tokio’s
context on a non-Tokio runtime.
It contains a Handle
to the runtime. A handle to the runtime can be
obtain by calling the Runtime::handle()
method.
Note that the TokioContext
wrapper only works if the Runtime
it is
connected to has not yet been destroyed. You must keep the Runtime
alive until the future has finished executing.
Warning: If TokioContext
is used together with a current thread
runtime, that runtime must be inside a call to block_on
for the
wrapped future to work. For this reason, it is recommended to use a
multi thread runtime, even if you configure it to only spawn one
worker thread.
Examples
This example creates two runtimes, but only enables time on one of
them. It then uses the context of the runtime with the timer enabled to
execute a sleep
future on the runtime with timing disabled.
use tokio::time::{sleep, Duration}; use tokio_util::context::RuntimeExt; // This runtime has timers enabled. let rt = tokio::runtime::Builder::new_multi_thread() .enable_all() .build() .unwrap(); // This runtime has timers disabled. let rt2 = tokio::runtime::Builder::new_multi_thread() .build() .unwrap(); // Wrap the sleep future in the context of rt. let fut = rt.wrap(async { sleep(Duration::from_millis(2)).await }); // Execute the future on rt2. rt2.block_on(fut);
Implementations
impl<F> TokioContext<F>
[src]
impl<F> TokioContext<F>
[src]pub fn new(future: F, handle: Handle) -> TokioContext<F>ⓘNotable traits for TokioContext<F>
impl<F: Future> Future for TokioContext<F> type Output = F::Output;
[src]
pub fn new(future: F, handle: Handle) -> TokioContext<F>ⓘNotable traits for TokioContext<F>
impl<F: Future> Future for TokioContext<F> type Output = F::Output;
[src]Associate the provided future with the context of the runtime behind
the provided Handle
.
This constructor uses a 'static
lifetime to opt-out of checking that
the runtime still exists.
Examples
This is the same as the example above, but uses the new
constructor
rather than RuntimeExt::wrap
.
use tokio::time::{sleep, Duration}; use tokio_util::context::TokioContext; // This runtime has timers enabled. let rt = tokio::runtime::Builder::new_multi_thread() .enable_all() .build() .unwrap(); // This runtime has timers disabled. let rt2 = tokio::runtime::Builder::new_multi_thread() .build() .unwrap(); let fut = TokioContext::new( async { sleep(Duration::from_millis(2)).await }, rt.handle().clone(), ); // Execute the future on rt2. rt2.block_on(fut);
pub fn into_inner(self) -> F
[src]
pub fn into_inner(self) -> F
[src]Remove the association between the Tokio runtime and the wrapped future.
Trait Implementations
impl<F: Future> Future for TokioContext<F>
[src]
impl<F: Future> Future for TokioContext<F>
[src]impl<'__pin, F> Unpin for TokioContext<F> where
__Origin<'__pin, F>: Unpin,
[src]
__Origin<'__pin, F>: Unpin,
Auto Trait Implementations
impl<F> !RefUnwindSafe for TokioContext<F>
impl<F> Send for TokioContext<F> where
F: Send,
F: Send,
impl<F> Sync for TokioContext<F> where
F: Sync,
F: Sync,
impl<F> !UnwindSafe for TokioContext<F>
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<F> IntoFuture for F where
F: Future,
[src]
impl<F> IntoFuture for F where
F: Future,
[src]type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]into_future
)Creates a future from a value.