geese_executor

Geese executor is a runtime for futures, integrated into the Geese event system. It provides the ability to perform asynchronous work and then send the results back via events. Each time the geese_executor::notify::Poll event is raised, each future will be polled a single time, and any events raised by futures will be broadcast to all other systems.

A simple example of executor usage is provided below.

use geese::*;
use geese_executor::*;

struct A {
    cancellation: CancellationToken,
    result: Option<i32>
}

impl A {
    async fn do_background_work() -> i32 {
        // Do some awaiting
        42
    }

    fn handle_result(&mut self, future_result: &i32) {
        self.result = Some(*future_result);
    }
}

impl GeeseSystem for A {
    const DEPENDENCIES: Dependencies = dependencies()
        .with::<GeeseExecutor>();

    const EVENT_HANDLERS: EventHandlers<Self> = event_handlers()
        .with(Self::handle_result);

    fn new(ctx: GeeseContextHandle<Self>) -> Self {
        let cancellation = CancellationToken::default();
        let result = None;

        ctx.get::<GeeseExecutor>().spawn_event(Self::do_background_work())
            .with_cancellation(&cancellation);

        Self { cancellation, result }
    }
}

let mut ctx = GeeseContext::default();
ctx.flush(EventQueue::default()
    .with(geese::notify::add_system::<A>())
    .with(geese_executor::notify::Poll)
);
assert_eq!(Some(42), ctx.get::<A>().result);