Struct Runtime 

pub struct Runtime;

Available on crate feature tokio only.

Concrete RuntimeLite implementation based on tokio runtime.

Trait Implementations

impl Clone for TokioRuntime

fn clone(&self) -> TokioRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokioRuntime

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

Formats the value using the given formatter.

impl Display for TokioRuntime

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

Formats the value using the given formatter.

impl RuntimeLite for TokioRuntime

type Spawner = TokioSpawner

The spawner type for this runtime

type LocalSpawner = TokioSpawner

The local spawner type for this runtime

type BlockingSpawner = TokioSpawner

The blocking spawner type for this runtime

type Instant = Instant

The instant type for this runtime

type AfterSpawner = TokioSpawner

The after spawner type for this runtime

type Interval = TokioInterval

The interval type for this runtime

type LocalInterval = TokioInterval

The local interval type for this runtime

type Sleep = TokioSleep

The sleep type for this runtime

type LocalSleep = TokioSleep

The local sleep type for this runtime

type Delay<F: Future + Send> = Delay<F, TokioSleep>

The delay type for this runtime

type LocalDelay<F: Future> = Delay<F, TokioSleep>

The local delay type for this runtime

type Timeout<F: Future + Send> = TokioTimeout<F>

The timeout type for this runtime

type LocalTimeout<F: Future> = TokioTimeout<F>

The local timeout type for this runtime

fn new() -> TokioRuntime

Create a new instance of the runtime

fn name() -> &'static str

Returns the name of the runtime

fn fqname() -> &'static str

Returns the fully qualified name of the runtime

fn block_on<F>(f: F) -> <F as Future>::Output

where F: Future,

Block the current thread on the given future

async fn yield_now()

Yield the current task

fn interval(interval: Duration) -> <TokioRuntime as RuntimeLite>::Interval

Create a new interval that starts at the current time and yields every period duration

fn interval_at( start: <TokioRuntime as RuntimeLite>::Instant, period: Duration, ) -> <TokioRuntime as RuntimeLite>::Interval

Create a new interval that starts at the given instant and yields every period duration

fn interval_local( interval: Duration, ) -> <TokioRuntime as RuntimeLite>::LocalInterval

Create a new interval that starts at the current time and yields every period duration

fn interval_local_at( start: <TokioRuntime as RuntimeLite>::Instant, period: Duration, ) -> <TokioRuntime as RuntimeLite>::LocalInterval

Create a new interval that starts at the given instant and yields every period duration

fn sleep(duration: Duration) -> <TokioRuntime as RuntimeLite>::Sleep

Create a new sleep future that completes after the given duration has elapsed

fn sleep_until( instant: <TokioRuntime as RuntimeLite>::Instant, ) -> <TokioRuntime as RuntimeLite>::Sleep

Create a new sleep future that completes at the given instant has elapsed

fn sleep_local(duration: Duration) -> <TokioRuntime as RuntimeLite>::LocalSleep

Create a new sleep future that completes after the given duration has elapsed

fn sleep_local_until( instant: <TokioRuntime as RuntimeLite>::Instant, ) -> <TokioRuntime as RuntimeLite>::LocalSleep

Create a new sleep future that completes at the given instant has elapsed

fn delay<F>( duration: Duration, fut: F, ) -> <TokioRuntime as RuntimeLite>::Delay<F>

where F: Future + Send,

Create a new delay future that runs the fut after the given duration has elapsed. The Future will never be polled until the duration has elapsed.

fn delay_local<F>( duration: Duration, fut: F, ) -> <TokioRuntime as RuntimeLite>::LocalDelay<F>

where F: Future,

Like delay, but does not require the fut to be Send. Create a new delay future that runs the fut after the given duration has elapsed. The Future will never be polled until the duration has elapsed.

fn delay_at<F>( deadline: <TokioRuntime as RuntimeLite>::Instant, fut: F, ) -> <TokioRuntime as RuntimeLite>::Delay<F>

where F: Future + Send,

Create a new timeout future that runs the future after the given deadline. The Future will never be polled until the deadline has reached.

fn delay_local_at<F>( deadline: <TokioRuntime as RuntimeLite>::Instant, fut: F, ) -> <TokioRuntime as RuntimeLite>::LocalDelay<F>

where F: Future,

Like delay_at, but does not require the fut to be Send. Create a new timeout future that runs the future after the given deadline The Future will never be polled until the deadline has reached.

fn timeout<F>( timeout: Duration, fut: F, ) -> <TokioRuntime as RuntimeLite>::Timeout<F>

where F: Future + Send,

Requires a Future to complete before the specified duration has elapsed.

fn timeout_at<F>( deadline: <TokioRuntime as RuntimeLite>::Instant, future: F, ) -> <TokioRuntime as RuntimeLite>::Timeout<F>

where F: Future + Send,

Requires a Future to complete before the specified instant in time.

fn timeout_local<F>( duration: Duration, future: F, ) -> <TokioRuntime as RuntimeLite>::LocalTimeout<F>

where F: Future,

Like timeout, but does not requrie the future to be Send. Requires a Future to complete before the specified duration has elapsed.

fn timeout_local_at<F>( deadline: <TokioRuntime as RuntimeLite>::Instant, future: F, ) -> <TokioRuntime as RuntimeLite>::LocalTimeout<F>

where F: Future,

Like timeout_at, but does not requrie the future to be Send. Requires a Future to complete before the specified duration has elapsed.

fn spawn<F>( future: F, ) -> <Self::Spawner as AsyncSpawner>::JoinHandle<<F as Future>::Output>

where <F as Future>::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime

fn spawn_detach<F>(future: F)

where <F as Future>::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime and detach it

fn spawn_local<F>( future: F, ) -> <Self::LocalSpawner as AsyncLocalSpawner>::JoinHandle<<F as Future>::Output>

where F: Future + 'static, <F as Future>::Output: 'static,

Spawn a future onto the local runtime

fn spawn_local_detach<F>(future: F)

where F: Future + 'static, <F as Future>::Output: 'static,

Spawn a future onto the local runtime and detach it

fn spawn_blocking<F, R>( f: F, ) -> <Self::BlockingSpawner as AsyncBlockingSpawner>::JoinHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Spawn a blocking function onto the runtime

fn spawn_blocking_detach<F, R>(f: F)

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Spawn a blocking function onto the runtime and detach it

fn now() -> Self::Instant

Returns an instant corresponding to “now”.

fn spawn_after<F>( duration: Duration, future: F, ) -> <Self::AfterSpawner as AsyncAfterSpawner>::JoinHandle<<F as Future>::Output>

where <F as Future>::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime and run the given future after the given duration

fn spawn_after_at<F>( at: Self::Instant, future: F, ) -> <Self::AfterSpawner as AsyncAfterSpawner>::JoinHandle<<F as Future>::Output>

where <F as Future>::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime and run the given future after the given instant.

impl Copy for TokioRuntime