Struct Runtime 

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

A full-featured async runtime that combines an executor and a reactor.

Runtime<RK> wraps any RuntimeKit and adds higher-level helpers such as domain-name resolution (Runtime::to_socket_addrs) and runtime-shutdown error detection (Runtime::is_runtime_shutdown_error).

Concrete type aliases — NoopRuntime, SmolRuntime, TokioRuntime — are provided for each built-in backend and are the usual entry points.

Implementations

impl<RK: RuntimeKit> 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, ) -> SocketAddrsResolver<'_, RK, A>

where <A as ToSocketAddrs>::Iter: Send + 'static,

Asynchronously resolve the given domain name

pub fn is_runtime_shutdown_error(&self, err: &Error) -> bool

Check if an std::io::Error is a runtime shutdown error

Only tokio’s shutdown error is recognised, and it is recognised by its value alone: no runtime is consulted, so the answer does not depend on which kit backs this Runtime nor on where the error came from. What this does not do is ask the kit about its own shutdown errors, so a SmolRuntime gets false for anything smol-specific.

impl Runtime<RuntimeParts<AsyncGlobalExecutor, AsyncIO>>

pub fn async_global_executor() -> Self

Create a new AGERuntime

impl Runtime<Noop>

pub fn noop() -> Self

Create a new NoopRuntime

impl Runtime<Smol>

pub fn smol() -> Self

Create a new SmolRuntime

impl Runtime<Tokio>

pub fn tokio() -> Result<Self>

Create a new TokioRuntime backed by a freshly created tokio multi-threaded runtime.

pub fn tokio_current() -> 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.

pub fn tokio_with_runtime(runtime: TokioRT) -> Self

Create a new TokioRuntime and bind it to this tokio runtime.

Trait Implementations

impl<RK: Clone + RuntimeKit> Clone for Runtime<RK>

fn clone(&self) -> Runtime<RK>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<RK: RuntimeKit> Executor for Runtime<RK>

type Task<T: Send + 'static> = <RK as Executor>::Task<T>

The type representing the tasks the are returned when spawning a Future on the executor

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

Block on a future until completion

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

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

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

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

impl<RK: RuntimeKit> From<RK> for Runtime<RK>

fn from(kit: RK) -> Self

Converts to this type from the input type.

impl<RK: RuntimeKit> Reactor for Runtime<RK>

type TcpStream = <RK as Reactor>::TcpStream

The type representing a TCP stream (after tcp_connect) for this reactor

type Sleep = <RK as Reactor>::Sleep

A future that completes after a requested duration has elapsed (see Reactor::sleep)

fn register<H: Read + Write + AsSysFd + Send + 'static>( &self, socket: H, ) -> Result<impl AsyncRead + AsyncWrite + Send + Unpin + 'static>

Register a synchronous handle, returning an asynchronous one

fn sleep(&self, dur: Duration) -> Self::Sleep

Sleep for the given duration

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

Stream that yields at every given interval

fn tcp_connect_addr( &self, addr: SocketAddr, ) -> impl Future<Output = Result<Self::TcpStream>> + Send + 'static

Create a TcpStream by connecting to a specific pre-resolved address

fn tcp_connect<A: AsyncToSocketAddrs + Send>( &self, addrs: A, ) -> impl Future<Output = Result<Self::TcpStream>> + Send

where Self: Sync + Sized,

Create a TcpStream by connecting to a remote host