Struct EmbassyRuntime 

pub struct EmbassyRuntime;

Available on crate feature embassy only.

Concrete RuntimeLite implementation based on embassy-executor.

Before any task is spawned through this runtime, the global spawner must be installed once with init from within a running embassy executor. See the module documentation for the caveats of this backend (block_on busy-polls, spawn_blocking and local spawning panic, and the number of live spawned tasks is bounded by TASK_POOL_SIZE).

Trait Implementations

impl Clone for EmbassyRuntime

fn clone(&self) -> EmbassyRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EmbassyRuntime

impl Debug for EmbassyRuntime

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

Formats the value using the given formatter.

impl Display for EmbassyRuntime

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

Formats the value using the given formatter.

impl LocalRuntimeLite for EmbassyRuntime

type LocalSpawner = EmbassySpawner

The local spawner type for this runtime

type BlockingSpawner = EmbassySpawner

The blocking spawner type for this runtime

type Instant = Instant

Available on crate feature time only.

The instant type for this runtime

type LocalInterval = EmbassyInterval

Available on crate feature time only.

The local interval type for this runtime

type LocalSleep = EmbassySleep

Available on crate feature time only.

The local sleep type for this runtime

type LocalDelay<F> = Delay<F, EmbassySleep> where F: Future

Available on crate feature time only.

The local delay type for this runtime

type LocalTimeout<F> = EmbassyTimeout<F> where F: Future

Available on crate feature time only.

The local timeout type for this runtime

fn new() -> Self

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: Future>(f: F) -> F::Output

Block the current thread on the given future

fn interval_local(interval: Duration) -> Self::LocalInterval

Available on crate feature time only.

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

fn interval_local_at(start: Instant, period: Duration) -> Self::LocalInterval

Available on crate feature time only.

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

fn sleep_local(duration: Duration) -> Self::LocalSleep

Available on crate feature time only.

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

fn sleep_local_until(instant: Instant) -> Self::LocalSleep

Available on crate feature time only.

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

fn delay_local<F>(duration: Duration, fut: F) -> Self::LocalDelay<F>

where F: Future,

Available on crate feature time only.

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_local_at<F>(deadline: Instant, fut: F) -> Self::LocalDelay<F>

where F: Future,

Available on crate feature time only.

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_local<F>(duration: Duration, future: F) -> Self::LocalTimeout<F>

where F: Future,

Available on crate feature time only.

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) -> Self::LocalTimeout<F>

where F: Future,

Available on crate feature time only.

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_local<F>( future: F, ) -> <Self::LocalSpawner as AsyncLocalSpawner>::JoinHandle<F::Output>

where F: Future + 'static, F::Output: 'static,

Spawn a future onto the local runtime

fn spawn_local_detach<F>(future: F)

where F: Future + 'static, F::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

Available on crate feature time only.

Returns an instant corresponding to “now”.

impl RuntimeLite for EmbassyRuntime

type Spawner = EmbassySpawner

The spawner type for this runtime

type AfterSpawner = EmbassySpawner

Available on crate feature time only.

The after spawner type for this runtime

type Interval = EmbassyInterval

Available on crate feature time only.

The interval type for this runtime

type Sleep = EmbassySleep

Available on crate feature time only.

The sleep type for this runtime

type Delay<F> = Delay<F, EmbassySleep> where F: Future + Send

Available on crate feature time only.

The delay type for this runtime

type Timeout<F> = EmbassyTimeout<F> where F: Future + Send

Available on crate feature time only.

The timeout type for this runtime

async fn yield_now()

Yield the current task

fn interval(interval: Duration) -> Self::Interval

Available on crate feature time only.

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

fn interval_at(start: Instant, period: Duration) -> Self::Interval

Available on crate feature time only.

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

fn sleep(duration: Duration) -> Self::Sleep

Available on crate feature time only.

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

fn sleep_until(instant: Instant) -> Self::Sleep

Available on crate feature time only.

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

fn delay<F>(duration: Duration, fut: F) -> Self::Delay<F>

where F: Future + Send,

Available on crate feature time only.

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) -> Self::Delay<F>

where F: Future + Send,

Available on crate feature time only.

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) -> Self::Timeout<F>

where F: Future + Send,

Available on crate feature time only.

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

fn timeout_at<F>(deadline: Instant, future: F) -> Self::Timeout<F>

where F: Future + Send,

Available on crate feature time only.

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

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

where F::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime

fn spawn_detach<F>(future: F)

where F::Output: Send + 'static, F: Future + Send + 'static,

Spawn a future onto the runtime and detach it

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

where F::Output: Send + 'static, F: Future + Send + 'static,

Available on crate feature time only.

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::Output>

where F::Output: Send + 'static, F: Future + Send + 'static,

Available on crate feature time only.

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