Struct Runtime 

pub struct Runtime;

Available on crate feature async-std only.

Concrete RuntimeLite implementation based on async_std runtime.

Trait Implementations

impl Clone for AsyncStdRuntime

fn clone(&self) -> AsyncStdRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AsyncStdRuntime

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

Formats the value using the given formatter.

impl Display for AsyncStdRuntime

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

Formats the value using the given formatter.

impl RuntimeLite for AsyncStdRuntime

type Spawner = AsyncStdSpawner

The spawner type for this runtime

type LocalSpawner = AsyncStdSpawner

The local spawner type for this runtime

type BlockingSpawner = AsyncStdSpawner

The blocking spawner type for this runtime

type Instant = Instant

The instant type for this runtime

type AfterSpawner = AsyncStdSpawner

The after spawner type for this runtime

type Interval = Timer

The interval type for this runtime

type LocalInterval = Timer

The local interval type for this runtime

type Sleep = AsyncIoSleep

The sleep type for this runtime

type LocalSleep = AsyncIoSleep

The local sleep type for this runtime

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

The delay type for this runtime

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

The local delay type for this runtime

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

The timeout type for this runtime

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

The local timeout type for this runtime

fn new() -> AsyncStdRuntime

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) -> <AsyncStdRuntime as RuntimeLite>::Interval

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn delay<F>( duration: Duration, fut: F, ) -> <AsyncStdRuntime 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, ) -> <AsyncStdRuntime 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: Instant, fut: F, ) -> <AsyncStdRuntime 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: Instant, fut: F, ) -> <AsyncStdRuntime 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>( duration: Duration, future: F, ) -> <AsyncStdRuntime as RuntimeLite>::Timeout<F>

where F: Future + Send,

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

fn timeout_at<F>( deadline: Instant, future: F, ) -> <AsyncStdRuntime 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, ) -> <AsyncStdRuntime 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: Instant, future: F, ) -> <AsyncStdRuntime 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 AsyncStdRuntime