rs_eda/event/

mod.rs

use serde_json::Value;
use std::{collections::HashMap, pin::Pin};
use tokio::sync::mpsc::{self, Sender};

pub struct Event {
    name: String,        // 事件名
    data: Option<Value>, // 数据使用Value格式
}
impl Event {
    pub fn new(name: &str, data: Option<Value>) -> Self {
        Self {
            name: name.to_string(),
            data,
        }
    }
}

type FnVal = Option<Value>;
type ListenersMap = HashMap<String, Vec<Sender<FnVal>>>;
type BoxedHandler = Box<dyn Fn(FnVal) -> BoxFuture + Send + Sync>;
type BoxFuture = Pin<Box<dyn Future<Output = ()> + Send + Sync>>;

#[derive(Debug, Clone)]
pub struct EventDispatcher {
    listeners: ListenersMap,
}

impl EventDispatcher {
    pub fn new() -> Self {
        Self {
            listeners: HashMap::new(),
        }
    }
    /**
     * @description: 获取事件列表
     * @author: tgy3300
     * @Date: 2025-03-29 12:20:36
     * @param {*} self
     * @return {*}
     */
    pub fn get_listeners(&self) -> &ListenersMap {
        &self.listeners
    }
    /**
     * @description: 订阅事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:20:08
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn add_event_listener(&mut self, name: &str, listener: BoxedHandler) {
        let (tx, mut rx) = mpsc::channel(30);

        self.listeners
            .entry(name.to_string())
            .or_insert(Vec::new())
            .push(tx);

        tokio::spawn(async move {
            while let Some(data) = rx.recv().await {
                (listener)(data).await;
            }
        });
    }
    /**
     * @description: 判断事件名下指定事件方法是否存在，这里有问题，无法通过listener区分判断
     * @author: tgy3300
     * @Date: 2025-03-29 12:19:38
     * @param {*} name
     * @param {EventListener} listener
     * @return {*}
     */
    pub fn has_event_listener(&self, name: &str, listener: BoxedHandler) -> bool {
        if let Some(listeners) = self.listeners.get(name) {
            // let func = &(listener);
            // return listeners.contains(func);
            return true;
        }
        false
    }
    /**
     * @description: 判断事件是否存在
     * @author: tgy3300
     * @Date: 2025-03-29 12:19:11
     * @param {*} name
     * @return {*}
     */
    pub fn has_event(&self, name: &str) -> bool {
        if let Some(_) = self.listeners.get(name) {
            true
        } else {
            false
        }
    }
    /**
     * @description: 移除事件下指定事件方法(包括该事件对应的节流事件和防抖事件)
     * @author: tgy3300
     * @Date: 2025-03-29 12:17:39
     * @param {*} name 事件名
     * @param {EventListener} listener 事件方法
     * @return {*}
     */
    pub fn remove_event_listener(&mut self, name: &str, listener: BoxedHandler) {
        // if let Some(arr) = self.listeners.get_mut(name) {
        //     // 删除节流事件
        //     // 删除防抖事件

        //     // 通过指针地址对比，过滤掉传入的事件
        //     arr.retain(|x| format!("{:?}", x) != format!("{:?}", &(listener)));
        // }
    }
    /**
     * @description: 移除事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:17:00
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn remove_event(&mut self, name: &str) {
        if self.listeners.contains_key(name) {
            self.listeners.remove(name);
        }
    }
    /**
     * @description: 触发事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:15:47
     * @param {Event} event 事件数据
     * @return {*}
     */
    pub fn dispatch_event(&self, event: Event) {
        if let Some(listeners) = self.listeners.get(&event.name) {
            for listener in listeners {
                let listener_clone = listener.clone();
                let data_clone = event.data.clone();
                tokio::spawn(async move {
                    let _x = listener_clone.send(data_clone).await.unwrap();
                });
            }
        }
    }
    /**
     * @description: 一次性触发，触发之后会自动移除，再次触发无效果
     * @author: tgy3300
     * @Date: 2025-03-29 12:13:34
     * @param {*} self
     * @param {*} _name
     * @param {Option} _listener
     * @return {*}
     */
    pub fn once(&self, _name: &str, _listener: BoxedHandler) {}
    /**
     * @description: 触发事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:13:05
     * @param {*} name 事件名
     * @param {Option} params 事件参数
     * @return {*}
     */
    pub fn emit(&self, name: &str, params: FnVal) {
        self.dispatch_event(Event::new(name, params))
    }
    /**
     * @description: 订阅事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:12:40
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn on<F, Fut>(&mut self, name: &str, listener: F)
    where
        F: Fn(FnVal) -> Fut + Send + Sync + 'static,
        Fut: Future<Output = ()> + Send + Sync + 'static,
    {
        let handler: BoxedHandler = Box::new(move |x| Box::pin(listener(x)));
        self.add_event_listener(name, handler);
    }
    /**
     * @description: 判断事件名、事件名下指定事件方法是否存在，通过listener区分判断
     * @author: tgy3300
     * @Date: 2025-03-29 12:10:06
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn has(&self, name: &str, listener: Option<BoxedHandler>) -> bool {
        if let Some(x) = listener {
            self.has_event_listener(name, x)
        } else {
            self.has_event(name)
        }
    }
    /**
     * @description: 移除事件，如果不传listener就会移除整个name事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:09:22
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn off(&mut self, name: &str, listener: Option<BoxedHandler>) {
        if let Some(func) = listener {
            self.remove_event_listener(name, func);
        } else {
            self.remove_event(name);
        }
    }
    /**
     * @description: 获取该事件类型下的事件数量
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:55
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn event_count(&self, name: &str) -> usize {
        if let Some(x) = self.listeners.get(name) {
            x.len()
        } else {
            0
        }
    }
    /**
     * @description: 销毁该类型的最后一个事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:05:38
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn pop_latest_event(&mut self, name: &str) -> bool {
        if let Some(arr) = self.listeners.get_mut(name) {
            if let Some(_) = arr.pop() {
                return true;
            }
        }
        false
    }
    /**
     * @description: 清空所有事件类型的事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:05:14
     * @return {*}
     */
    pub fn clear(&mut self) {
        self.listeners.clear();
    }
    /**
     * @description: 当前派发器是否使用
     * @author: tgy3300
     * @Date: 2025-03-29 12:04:43
     * @return {*}
     */
    pub fn useful(&self) -> bool {
        self.listeners.keys().len() > 0
    }
    /**
     * @description: 节流触发
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:04
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @param {u64} time 节流时间
     * @return {*}
     */
    pub fn on_throttle(&self, _name: &str, _listener: BoxedHandler, _time: u64) {}
    /**
     * @description: 防抖触发
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:23
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @param {u64} time 防抖时间
     * @return {*}
     */
    pub fn on_anti_shake(&self, _name: &str, _listener: BoxedHandler, _time: u64) {}
}