Enum TokioRT 

pub enum TokioRT {
    Runtime(Runtime),
    Handle(Handle),
}

The main struct for tokio runtime IO, assign this type to AsyncIO trait when used.

Variants

Runtime(Runtime)

Handle(Handle)

Implementations

impl TokioRT

pub fn new_with_runtime(rt: Runtime) -> Self

Capture a runtime

pub fn new_multi_thread(workers: usize) -> Self

pub fn new_current_thread() -> Self

pub fn new_with_handle(handle: Handle) -> Self

Only capture a runtime handle. Should acquire with async { Handle::current() }

Trait Implementations

impl AsyncExec for TokioRT

fn spawn<F, R>(&self, f: F) -> Self::AsyncHandle<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>(&self, f: F)

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

Spawn a task and detach it (no handle returned)

fn block_on<F, R>(&self, f: F) -> R

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

Run a future to completion on the runtime

type AsyncHandle<R: Send> = TokioJoinHandle<R>

type ThreadHandle<R: Send> = TokioThreadHandle<R>

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

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

Run blocking code in a background thread pool, and return an async join handle

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 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.

impl Clone for TokioRT

fn clone(&self) -> Self

Clone a TokioRT::Handle out of runtime, for spawn

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

Performs copy-assignment from source.

impl Debug for TokioRT

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

Formats the value using the given formatter.

impl AsyncRuntime for TokioRT