Trait Runtime 

pub trait Runtime<'a> {
    // Required methods
    fn push_boxed(&mut self, future: Pin<Box<dyn Future<Output = ()>>>);
    fn spawn_boxed(
        &'a mut self,
        future: Pin<Box<dyn Future<Output = ()>>>,
    ) -> SpawnedFuture<'a> ;
    fn sleep<'b>(
        &'a self,
        duration: Duration,
    ) -> Pin<Box<dyn Future<Output = ()> + 'b>>;
    fn stop(&mut self) -> Stop ;

    // Provided methods
    fn push(&mut self, future: impl Future<Output = ()> + 'static) { ... }
    fn spawn(
        &'a mut self,
        future: impl Future<Output = ()> + 'static,
    ) -> SpawnedFuture<'a>  { ... }
    fn sleep_ms<'b>(
        &'a self,
        amount: u64,
    ) -> Pin<Box<dyn Future<Output = ()> + 'b>> { ... }
}

Auto-trait with the methods that will actually be called by the users of the runtime.

Required Methods

fn push_boxed(&mut self, future: Pin<Box<dyn Future<Output = ()>>>)

Adds a new future to the queue to be completed.

fn spawn_boxed( &'a mut self, future: Pin<Box<dyn Future<Output = ()>>>, ) -> SpawnedFuture<'a>

Adds a new future to the queue to be completed and returns a future waiting for the added future’s completion.

fn sleep<'b>( &'a self, duration: Duration, ) -> Pin<Box<dyn Future<Output = ()> + 'b>>

Asynchronously sleeps

fn stop(&mut self) -> Stop

Stops the runtime. This does not exit the process.

Provided Methods

fn push(&mut self, future: impl Future<Output = ()> + 'static)

Adds a new future to the queue to be completed.

Examples found in repository

examples/tcp.rs (line 15)

fn main() {
    let mut runtime = QueuedRuntime::new();
    runtime.push(go(("0.0.0.0", 5000)));
    sync(runtime);
}

async fn go(addr: (&str, u16)) {
    let mut listener = TcpListener::bind(addr).unwrap();
    loop {
        get_current_runtime()
            .await
            .push(handle(accept(&mut listener).await.unwrap()));
    }
}

examples/recursion.rs (line 8)

fn main() {
    let mut runtime = QueuedRuntime::new();
    runtime.push(print_something_after_ms(0));
    sync(runtime);
}

async fn print_something_after_ms(ms: u64) {
    get_current_runtime()
        .await
        .sleep(Duration::from_millis(ms))
        .await;
    println!("something after {ms}ms! :D");
    get_current_runtime()
        .await
        .push(print_something_after_ms(ms + 1));
}

examples/runtime.rs (line 7)

fn main() {
    let mut runtime = QueuedRuntime::new();
    for _ in 0..50 {
        runtime.push(print_something_after_ms(2000));
    }
    sync(runtime);
}

fn spawn( &'a mut self, future: impl Future<Output = ()> + 'static, ) -> SpawnedFuture<'a>

Adds a new future to the queue to be completed and returns a future waiting for the added future’s completion.

fn sleep_ms<'b>(&'a self, amount: u64) -> Pin<Box<dyn Future<Output = ()> + 'b>>

Asynchronously sleeps some amount of milliseconds

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a> Runtime<'a> for RuntimeWrapper<'a>

impl<'a, T> Runtime<'a> for T

where T: InternalRuntime,