Struct RuntimeParts

pub struct RuntimeParts<E: Executor, R: Reactor> { /* private fields */ }

Wrapper around separate Executor and Reactor implementing RuntimeKit

Implementations

impl<E: Executor, R: Reactor> RuntimeParts<E, R>

pub fn new(executor: E, reactor: R) -> Self

Create new RuntimeParts from separate Executor and Reactor

Trait Implementations

impl<E: Debug + Executor, R: Debug + Reactor> Debug for RuntimeParts<E, R>

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

Formats the value using the given formatter.

impl<E: Executor, R: Reactor> Executor for RuntimeParts<E, R>

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<E: Executor + Sync, R: Reactor + Sync> Reactor for RuntimeParts<E, R>

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<'life0, 'async_trait>( &'life0 self, addr: SocketAddr, ) -> Pin<Box<dyn Future<Output = Result<impl AsyncIOHandle + Send>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a TcpStream by connecting to a remote host

impl<E: Executor + Sync + Debug, R: Reactor + Sync + Debug> RuntimeKit for RuntimeParts<E, R>