Struct Runtime

pub struct Runtime<RK: RuntimeKit + 'static> { /* private fields */ }

A full-featured Runtime implementation

Implementations

impl<RK: RuntimeKit + 'static> Runtime<RK>

pub fn new(kit: RK) -> Self

Create a new Runtime from a RuntimeKit

pub fn to_socket_addrs<A: ToSocketAddrs + Send + 'static>( &self, addrs: A, ) -> impl AsyncToSocketAddrs

where <A as ToSocketAddrs>::Iter: Iterator<Item = SocketAddr> + Send + 'static,

Asynchronously resolve the given domain name

impl Runtime<RuntimeParts<AsyncGlobalExecutor, AsyncIO>>

pub fn async_global_executor() -> Self

Create a new SmolRuntime

impl Runtime<Smol>

pub fn smol() -> Self

Create a new SmolRuntime

impl Runtime<Tokio>

pub fn tokio() -> Self

Create a new TokioRuntime and bind it to the current tokio runtime by default.

pub fn tokio_with_handle(handle: Handle) -> Self

Create a new TokioRuntime and bind it to the tokio runtime associated to this handle by default.

Trait Implementations

impl<RK: Debug + RuntimeKit + 'static> Debug for Runtime<RK>

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

Formats the value using the given formatter.

impl<RK: RuntimeKit + 'static> Executor for Runtime<RK>

fn block_on<T, F: Future<Output = T>>(&self, f: F) -> T

Block on a future until completion

fn spawn<T: Send + 'static>( &self, f: impl Future<Output = T> + Send + 'static, ) -> impl Task<T>

Spawn a future and return a handle to track its completion.

fn spawn_blocking<F: FnOnce() -> T + Send + 'static, T: Send + 'static>( &self, f: F, ) -> impl Task<T>

Convert a blocking task into a future, spawning it on a decicated thread pool

impl<RK: RuntimeKit + 'static> From<RK> for Runtime<RK>

fn from(kit: RK) -> Self

Converts to this type from the input type.

impl<RK: RuntimeKit + Sync + 'static> Reactor for Runtime<RK>

fn register<H: IO + Send + 'static>( &self, socket: IOHandle<H>, ) -> Result<impl AsyncIOHandle + Send>

Register a synchronous handle, returning an asynchronous one

fn sleep(&self, dur: Duration) -> impl Future<Output = ()>

Sleep for the given duration

fn interval(&self, dur: Duration) -> impl Stream<Item = Instant>

Stream that yields at every given interval

fn tcp_connect( &self, addr: SocketAddr, ) -> impl Future<Output = Result<impl AsyncIOHandle + Send>> + Send

Create a TcpStream by connecting to a remote host