Struct TokioRT 

pub struct TokioRT {}

Trait Implementations

impl AsyncIO for TokioRT

type AsyncFd<T: AsRawFd + AsFd + Send + Sync + 'static> = TokioFD<T>

The type used to represent async file descriptors.

async fn connect_tcp(addr: &SocketAddr) -> Result<Self::AsyncFd<TcpStream>>

Connect to a TCP address asynchronously.

async fn connect_unix(addr: &Path) -> Result<Self::AsyncFd<UnixStream>>

Connect to a Unix socket address asynchronously.

fn to_async_fd_rd<T: AsRawFd + AsFd + Send + Sync + 'static>( fd: T, ) -> Result<Self::AsyncFd<T>>

Wrap a readable file object as an async handle

fn to_async_fd_rw<T: AsRawFd + AsFd + Send + Sync + 'static>( fd: T, ) -> Result<Self::AsyncFd<T>>

Wrap a readable/writable file object as an async handle.

impl AsyncRuntime for TokioRT

fn current() -> Self::Exec

Initiate executor using current thread.

Safety

You should run AsyncExec::block_on() with this executor.

If spawn without a block_on() running, it’s possible the runtime just init future without scheduling.

fn one() -> Self::Exec

Initiate executor with one background thread.

NOTE

AsyncExec::block_on() is optional, you can directly call AsyncExec::spawn with it.

fn multi(num: usize) -> Self::Exec

Initiate executor with multiple background threads.

NOTE

When num == 0, start threads that match cpu number.

AsyncExec::block_on() is optional, you can directly call AsyncExec::spawn with it.

fn spawn<F, R>(f: F) -> TokioJoinHandle<R>

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

Spawn a task in the background, returning a handle to await its result

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

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

Spawn a task and detach it (no handle returned)

type Exec = TokioExec

fn spawn_blocking<F, R>(f: F) -> TokioThreadHandle<R>

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

Run blocking code with the thread context in blocking thread pool, and return an async join handle

impl AsyncTime for TokioRT

type Interval = TokioInterval

The type used for periodic timers.

fn sleep(d: Duration) -> impl Future + Send

Sleep for the specified duration.

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

Create a periodic timer that ticks at the specified interval.

fn timeout<F>( d: Duration, func: F, ) -> impl Future<Output = Result<<F as Future>::Output, ()>> + Send

where F: Future + Send,

Apply a timeout to a future.