Director

Director is a simple, versatile, ergonomic state machine in Rust-lang. (no-std)

| Examples | Docs | Latest Note |

director = "0.5.0"

Why?

Because writing state-machine is kind of tedious. Not for human way. It is difficult to achieve flexibility, readability and more analyzability to the architecture. This crate gives all of them. And well optimized[ex:) RAII]. So you don't need to worry way bad performance for your implementation.

How to use,

use crate::Engine; // Any common state

#[director::state {
    super = StateBaz,
    sub = [StateBar, StateBar2]
}]
pub struct StateFoo {
    count: u32,
}

impl director::State<Engine> for StateFoo {
    /// This determines whether or not to run this local state machine.
    fn toggle(engine: &mut Engine, inner: Option<&Self>) -> bool {
        director::on!(inner, None) || director::off!(state: StateBaz, Some(state) if state.count > 1000)
    }
    /// This creates and imports new initial state on this local state machine when the toggle's on.
    fn load(engine: &mut Engine) -> Self {
        Self { count: Self::lock_super__state_baz().get().count }
    }
    /// This executes custom logics and manipulates this local state machine's states.
    fn run(&mut self, engine: &mut Engine) {
        self.count += 1;
        println!("{}", self.count);
    }
    /// When the toggle's off
    fn drop(&self, engine: &mut Engine) {
        // ...
        // After then, the sub states[i.e) StateBar and StateBar2] will be droped automatically.
    }
}

pub struct Engine; // i.e) dummy engine

#[director::main(std::sync)] // It can be any kind of Mutex
fn main() {
    let mut engine = Engine;
    for _ in 0..10000 {
        StateBaz::run(&mut engine);
    }
}