Struct SmolRT 

pub struct SmolRT {}

Trait Implementations

impl AsyncIO for SmolRT

type AsyncFd<T: AsRawFd + AsFd + Send + Sync + 'static> = SmolFD<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 SmolRT

fn current() -> SmolExec

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() -> SmolExec

Initiate executor with one background thread.

NOTE

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

fn multi(size: usize) -> SmolExec

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) -> SmolJoinHandle<R>

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

Spawn a task in the background

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

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

Depends on how you initialize SmolRT, spawn with executor or globally

type Exec = SmolExec

fn spawn_blocking<F, R>(f: F) -> BlockingJoinHandle<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 SmolRT

type Interval = SmolInterval

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.