Lib.rs

Framework introduction

EDA development framework, namely: interactive event, function componentization, logic strategy. In other words, a project is composed of multiple businesses, each business has multiple functions (components), multiple logic (policies), and multiple interaction events to complete

Example

use rs_eda::{engine::Engine, event::EventDispatcher, plugin::PluginOptions, strategy::StrategyOptions};
use serde_json::{Value, json};
use std::sync::{Arc, Mutex};

async fn b_func(x: Option<Value>) {
    println!("22---{:?}", x);
}

fn main() {
    let event = Arc::new(Mutex::new(EventDispatcher::new()));
    let mut engine = Engine::new(Arc::clone(&event));
    engine.install(APlugin::new()).unwrap();
    engine.install(BPlugin).unwrap();
    engine.exec(AStrategy).unwrap();

    event.lock().unwrap().emit("start", None);

    engine.rollback("AStrategy");
    engine.uninstall("BPlugin");
}

struct APlugin {
    title: String,
}
impl APlugin {
    fn new() -> Self {
        Self {
            title: "".to_string(),
        }
    }
}
impl PluginOptions for APlugin {
    fn name(&self) -> &str {
        "APlugin"
    }
    fn deps(&self) -> Vec<&str> {
        vec![]
    }
    fn install(&mut self, event: Arc<Mutex<EventDispatcher>>) {
        self.title = "camera".to_string();
        println!("install APlugin: {}", self.title);

        let event_rc = Arc::clone(&event);
        let a_func = move |x| {
            let event_clone = Arc::clone(&event_rc);
            Box::pin(async move {
                println!("1---{:?}", x);
                event_clone.lock().unwrap().emit("test-b", Some(200.into()));
            })
        };
        event.lock().unwrap().on("test-a", a_func);

    }
    fn dispose(&mut self, event: Arc<Mutex<EventDispatcher>>) {
        println!("dispose APlugin");
    }
}

struct BPlugin;
impl PluginOptions for BPlugin {
    fn name(&self) -> &str {
        "BPlugin"
    }
    fn deps(&self) -> Vec<&str> {
        vec!["APlugin"]
    }
    fn install(&mut self, event: Arc<Mutex<EventDispatcher>>) {
        println!("install BPlugin");

        event.lock().unwrap().on("test-b", async |x| {
            println!("---2---{:?}", x);
        });
    }
    fn dispose(&mut self, event: Arc<Mutex<EventDispatcher>>) {
        println!("dispose BPlugin");
    }
}
struct AStrategy;
impl StrategyOptions for AStrategy {
    fn name(&self) -> &str {
        "AStrategy"
    }
    fn condition(&self) -> Vec<&str> {
        vec!["APlugin", "BPlugin"]
    }
    fn exec(&self, event: Arc<Mutex<EventDispatcher>>) {
        println!("exec AStrategy");

        let event_clone = Arc::clone(&event);
        event.lock().unwrap().on("start", move |x| {
            let event_c = Arc::clone(&event_clone);
            Box::pin(async move {
                println!("0---{:?}", x);
                event_c
                    .lock()
                    .unwrap()
                    .emit("test-a", Some(100.into()));
            })
        });
    }
    fn rollback(&mut self, event: Arc<Mutex<EventDispatcher>>) {
        println!("rollback AStrategy");
    }
}

Unrealized needs, hope everyone help

1, one-time trigger (once)
link: https://docs.rs/rs-eda/0.1.8/src/rs_eda/event/mod.rs.html#139

2, throttle trigger (on_throttle)
link: https://docs.rs/rs-eda/0.1.8/src/rs_eda/event/mod.rs.html#248

3, anti-shake trigger (on_anti_shake)
link: https://docs.rs/rs-eda/0.1.8/src/rs_eda/event/mod.rs.html#258