Crate acril_rt

source ·
Expand description

acril-rt - a small single-threaded runtime for Acril

Features:

  • Tiny - less than 500 lines of code
  • Fast - runs on an efficient event loop powered by Tokio
  • Safe - #![forbid(unsafe_code)] here and in Acril

Examples

use acril_rt::prelude::*;

struct Pinger {
    count: u32,
}

struct Ping;
struct Pong(u32);

impl Service for Pinger {
    type Context = Context<Self>;
    type Error = ();
}

impl Handler<Ping> for Pinger {
    type Response = Pong;

    async fn call(&mut self, _ping: Ping, _cx: &mut Self::Context) -> Result<Pong, Self::Error> {
        self.count += 1;

        Ok(Pong(self.count))
    }
}

struct GetCount;

impl Handler<GetCount> for Pinger {
    type Response = u32;

    async fn call(&mut self, _get_count: GetCount, _cx: &mut Self::Context) -> Result<u32, Self::Error> {
        Ok(self.count)
    }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    // make sure the runtime can spawn !Send tasks
    let local_set = tokio::task::LocalSet::new();
    let _guard = local_set.enter();

    let runtime = Runtime::new();

    local_set.run_until(async move {
        let addr = runtime.spawn(Pinger { count: 0 }).await;

        for i in 0..100 {
            let pong = addr.send(Ping).await.unwrap();
            assert_eq!(pong.0, i + 1);
        }

        assert_eq!(addr.send(GetCount).await.unwrap(), 100);
    }).await
}

Modules

  • prelude
    use acril_rt::prelude::*; to import the commonly used types.

Structs

  • Addr
    A handle to a running Service, allowing to send messages to it.
  • Arbiter
    An arbiter is a single-threaded event loop, allowing users to spawn tasks onto it.
  • ArbiterHandle
    A handle to an arbiter, allowing to spawn futures onto the arbiter or stop it.
  • Context
    A service context.
  • Runtime
    The main component of acril_rt - the runtime. It stores the running services and handles their lifecycle and messages sent to them.

Enums

Functions

  • only_one
    Require the iterator to have only one item, erroring if it has less than one or more than one. If there were more than one items, the next item is present as Err(Some(next_item))