Trait AsyncRuntime 

pub trait AsyncRuntime:
    Debug
    + Default
    + PartialEq
    + Eq
    + OptionalSend
    + OptionalSync
    + 'static {
    type JoinError: Debug + Display + OptionalSend;
    type JoinHandle<T: OptionalSend + 'static>: Future<Output = Result<T, Self::JoinError>> + OptionalSend + OptionalSync + Unpin;
    type Sleep: Future<Output = ()> + OptionalSend + OptionalSync;
    type Instant: Instant;
    type TimeoutError: Debug + Display + OptionalSend;
    type Timeout<R, T: Future<Output = R> + OptionalSend>: Future<Output = Result<R, Self::TimeoutError>> + OptionalSend;
    type ThreadLocalRng: Rng;
    type OneshotSender<T: OptionalSend>: AsyncOneshotSendExt<T> + OptionalSend + OptionalSync + Debug;
    type OneshotReceiverError: Error + OptionalSend;
    type OneshotReceiver<T: OptionalSend>: OptionalSend + OptionalSync + Future<Output = Result<T, Self::OneshotReceiverError>> + Unpin;

    // Required methods
    fn spawn<T>(future: T) -> Self::JoinHandle<<T as Future>::Output>
       where T: Future + OptionalSend + 'static,
             <T as Future>::Output: OptionalSend + 'static;
    fn sleep(duration: Duration) -> Self::Sleep;
    fn sleep_until(deadline: Self::Instant) -> Self::Sleep;
    fn timeout<R, F>(duration: Duration, future: F) -> Self::Timeout<R, F>
       where F: Future<Output = R> + OptionalSend;
    fn timeout_at<R, F>(
        deadline: Self::Instant,
        future: F,
    ) -> Self::Timeout<R, F>
       where F: Future<Output = R> + OptionalSend;
    fn is_panic(join_error: &Self::JoinError) -> bool;
    fn thread_rng() -> Self::ThreadLocalRng;
    fn oneshot<T>() -> (Self::OneshotSender<T>, Self::OneshotReceiver<T>)
       where T: OptionalSend;
}

A trait defining interfaces with an asynchronous runtime.

The intention of this trait is to allow an application using this crate to bind an asynchronous runtime that suits it the best.

Some additional related functions are also exposed by this trait.

Note

The default asynchronous runtime is tokio.

Required Associated Types

type JoinError: Debug + Display + OptionalSend

The error type of Self::JoinHandle.

type JoinHandle<T: OptionalSend + 'static>: Future<Output = Result<T, Self::JoinError>> + OptionalSend + OptionalSync + Unpin

The return type of Self::spawn.

type Sleep: Future<Output = ()> + OptionalSend + OptionalSync

The type that enables the user to sleep in an asynchronous runtime.

type Instant: Instant

A measurement of a monotonically non-decreasing clock.

type TimeoutError: Debug + Display + OptionalSend

The timeout error type.

type Timeout<R, T: Future<Output = R> + OptionalSend>: Future<Output = Result<R, Self::TimeoutError>> + OptionalSend

The timeout type used by Self::timeout and Self::timeout_at that enables the user to await the outcome of a Future.

type ThreadLocalRng: Rng

Type of a thread-local random number generator.

type OneshotSender<T: OptionalSend>: AsyncOneshotSendExt<T> + OptionalSend + OptionalSync + Debug

Type of a oneshot sender.

type OneshotReceiverError: Error + OptionalSend

Type of a oneshot receiver error.

type OneshotReceiver<T: OptionalSend>: OptionalSend + OptionalSync + Future<Output = Result<T, Self::OneshotReceiverError>> + Unpin

Type of a oneshot receiver.

Required Methods

fn spawn<T>(future: T) -> Self::JoinHandle<<T as Future>::Output>

where T: Future + OptionalSend + 'static, <T as Future>::Output: OptionalSend + 'static,

Spawn a new task.

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

Wait until duration has elapsed.

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

Wait until deadline is reached.

fn timeout<R, F>(duration: Duration, future: F) -> Self::Timeout<R, F>

where F: Future<Output = R> + OptionalSend,

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

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

where F: Future<Output = R> + OptionalSend,

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

fn is_panic(join_error: &Self::JoinError) -> bool

Check if the Self::JoinError is panic.

fn thread_rng() -> Self::ThreadLocalRng

Get the random number generator to use for generating random numbers.

Note

This is a per-thread instance, which cannot be shared across threads or sent to another thread.

fn oneshot<T>() -> (Self::OneshotSender<T>, Self::OneshotReceiver<T>)

where T: OptionalSend,

Creates a new one-shot channel for sending single values.

The function returns separate “send” and “receive” handles. The Sender handle is used by the producer to send the value. The Receiver handle is used by the consumer to receive the value.

Each handle can be used on separate tasks.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl AsyncRuntime for TokioRuntime

type JoinError = JoinError

type JoinHandle<T: OptionalSend + 'static> = JoinHandle<T>

type Sleep = Sleep

type Instant = Instant

type TimeoutError = Elapsed

type Timeout<R, T: Future<Output = R> + OptionalSend> = Timeout<T>

type ThreadLocalRng = ThreadRng

type OneshotSender<T: OptionalSend> = TokioOneShotSender<T>

type OneshotReceiver<T: OptionalSend> = Receiver<T>

type OneshotReceiverError = RecvError