Crate acril_rt 

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

SingletonError

An error returned while retrieving a singleton service.

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))