Struct Post

pub struct Post { /* private fields */ }

A Resource to send command or future.

This resource provides clients funtionalities to send commands or futures in their systems. This resource also provides interior mutability, so that clients can request the resource with ResRead.

Implementations

impl Post

pub fn send_command<F>(&self, f: F)

where F: FnOnce(Ecs<'_>) -> DynResult<()> + Send + 'static,

Sends the given command to ECS scheduler.

Commands are executed on the main worker, but the command is not executed at the time of sending. ECS scheduler runs all buffered commands at the end of current cycle and before the next cycle.

Examples

use my_ecs::prelude::*;
use std::sync::mpsc;

let (tx, rx) = mpsc::channel();

// A system sending a command.
let tx_a = tx.clone();
let sys_a = move |rr: ResRead<Post>| {
    tx_a.send("sys_a").unwrap();
    let tx_aa = tx_a.clone();
    rr.send_command(move |ecs| {
        tx_aa.send("cmd_a").unwrap();
        Ok(())
    });
};

// A system sending a command.
let tx_b = tx.clone();
let sys_b = move |rr: ResRead<Post>| {
    tx_b.send("sys_b").unwrap();
    let tx_bb = tx_b.clone();
    rr.send_command(move |ecs| {
        tx_bb.send("cmd_b").unwrap();
        Ok(())
    });
};

Ecs::default(WorkerPool::with_len(2), [2])
    .add_systems((sys_a, sys_b))
    .step();

// No data dependency between `sys_a` and `sys_b`, so they can be run
// simultaneously.
assert!(matches!(rx.try_recv(), Ok("sys_a") | Ok("sys_b")));
assert!(matches!(rx.try_recv(), Ok("sys_a") | Ok("sys_b")));
assert!(matches!(rx.try_recv(), Ok("cmd_a") | Ok("cmd_b")));
assert!(matches!(rx.try_recv(), Ok("cmd_a") | Ok("cmd_b")));

pub fn send_future<F, R>(&self, future: F)

where F: Future<Output = R> + Send + 'static, R: Command,

Sends the given future to ECS scheduler.

The future is guaranteed to be polled more than or just once in the current cycle.

Examples

use my_ecs::prelude::*;
use std::{time::Duration, sync::{Arc, Mutex}};

let state = Arc::new(Mutex::new(0));

let c_state = Arc::clone(&state);
let foo = async move {
    *c_state.lock().unwrap() = 1;
    async_io::Timer::after(Duration::from_millis(10)).await;
    *c_state.lock().unwrap() = 2;
};

Ecs::default(WorkerPool::new(), [])
    .add_once_system(move |rr: ResRead<Post>| {
        rr.send_future(foo);
    })
    .run(|_| {});

assert_eq!(*state.lock().unwrap(), 2);

pub fn request_lock<'buf, Req>(&self) -> RequestLockFuture<'buf, Req>

where Req: Request,

pub fn change_entity(&self, eid: EntityId) -> EntityMoveCommandBuilder<'_>

Trait Implementations

impl Resource for Post