Struct Runtime 

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

A full-featured Runtime implementation

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

impl Runtime<RuntimeParts<AsyncGlobalExecutor, AsyncIO>>

pub fn async_global_executor() -> Self

Create a new SmolRuntime

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 and bind it to this tokio 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 decicated 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

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) -> impl Future<Output = ()> + Send + 'static

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 remote host

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