Struct CompioRuntime 

pub struct CompioRuntime { /* private fields */ }

Compio async runtime.

Trait Implementations

impl AsyncRuntime for CompioRuntime

type JoinError = CompioJoinError

The error type of Self::JoinHandle.

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

The return type of Self::spawn.

type Sleep = Pin<Box<dyn Future<Output = ()>>>

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 = Elapsed

The timeout error type.

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

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

type ThreadLocalRng = ThreadRng

Type of thread-local random number generator.

type Mpsc = FlumeMpsc

The bounded MPSC channel implementation.

type Watch = See

The watch channel implementation.

type Oneshot = FuturesOneshot

The oneshot channel implementation.

type Mutex<T: OptionalSend + 'static> = FlumeMutex<T>

The async mutex implementation.

fn spawn<T>(fut: T) -> Self::JoinHandle<T::Output>

where T: Future + OptionalSend + 'static, T::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: Future<Output = R> + OptionalSend>( duration: Duration, future: F, ) -> Self::Timeout<R, F>

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

fn timeout_at<R, F: Future<Output = R> + OptionalSend>( deadline: Self::Instant, future: F, ) -> Self::Timeout<R, F>

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

fn is_panic(_: &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.

fn new(_threads: usize) -> Self

Create a new runtime instance for testing purposes.

fn block_on<F, T>(&mut self, future: F) -> T

where F: Future<Output = T>, T: OptionalSend,

Run a future to completion on this runtime.

fn run<F, T>(future: F) -> T

where Self: Sized, F: Future<Output = T>, T: OptionalSend,

Convenience method: create a runtime and run the future to completion.

fn spawn_blocking<F, T>(f: F) -> impl Future<Output = Result<T, Error>> + Send

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

Run a blocking function on a separate thread.

impl Debug for CompioRuntime

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

Formats the value using the given formatter.