Rust 事件发射器

Rust 中线程安全且灵活的事件发射器实现。

特性

• 线程安全的事件发射和处理
• 支持多种事件类型和处理程序
• 类型化事件参数
• 异步事件处理
• 易于使用的宏进行事件发射

安装

将以下内容添加到您的 Cargo.toml

[dependencies]
event_emitter = "2.0.2"  # Replace with the actual version

使用

以下是一个更全面的示例，展示了 EventEmitter 的各种功能。

use event_emitter::{EventEmitter, emit};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    // Create a new EventEmitter
    let emitter = EventEmitter::new();
    
    // Start the event listener in a separate thread
    let listener = emitter.start_listening();

    // Create a shared state to demonstrate thread-safe updates
    let shared_state = Arc::new(Mutex::new(Vec::new()));

    // Handler for a simple greeting event
    emitter.on("greet", |(name,): (String,)| {
        println!("Hello, {}!", name);
    });

    // Handler for an event with multiple arguments
    {
        let state = Arc::clone(&shared_state);
        emitter.on("user_action", move |(user, action, value): (String, String, i32)| {
            println!("User {} performed action: {} with value: {}", user, action, value);
            let mut data = state.lock().unwrap();
            data.push((user, action, value));
        });
    }

    // Handler for a more complex event
    {
        let state = Arc::clone(&shared_state);
        emitter.on("process_data", move |(data, callback): (Vec<i32>, Box<dyn Fn(i32) + Send + 'static>)| {
            let sum: i32 = data.iter().sum();
            callback(sum);
            let mut shared_data = state.lock().unwrap();
            shared_data.push(("System".to_string(), "process_data".to_string(), sum));
        });
    }

    // Emit events
    emit!(emitter, "greet", "Alice".to_string());
    
    emit!(emitter, "user_action", "Bob".to_string(), "click".to_string(), 5);
    
    let callback = Box::new(|result: i32| {
        println!("Processing result: {}", result);
    });
    emit!(emitter, "process_data", vec![1, 2, 3, 4, 5], callback);

    // Demonstrate emitting events from another thread
    let emitter_clone = emitter.clone();
    thread::spawn(move || {
        thread::sleep(Duration::from_millis(100));
        emit!(emitter_clone, "greet", "Thread".to_string());
    });

    // Wait a bit for all events to be processed
    thread::sleep(Duration::from_millis(200));

    // Print the final state
    let final_state = shared_state.lock().unwrap();
    println!("Final state: {:?}", *final_state);

    // Stop the event listener
    emitter.stop_listening();
    listener.join().unwrap();
}

此示例演示

1. 创建和启动 EventEmitter
2. 为不同事件类型注册处理程序
3. 处理多个参数的事件
4. 在事件处理程序之间使用共享状态
5. 使用 emit! 宏发射事件
6. 将回调作为事件参数传递
7. 在不同的线程中克隆和使用 EventEmitter

请记住在您的实际实现中处理潜在的错误并使用适当的同步原语。

API

EventEmitter

管理事件的主要结构。

方法

• new(): 创建一个新的 EventEmitter。
• with_thread_pool_size(thread_pool_size: usize): 创建一个新的 EventEmitter，具有指定的容量。
• on<F, Args>(&self, event: &str, handler: F) -> HandlerId: 注册事件处理程序。
• off(&self, event: &str, handler_id: HandlerId): 移除某个事件的全部处理器。
• emit(&self, event: &str, args: Vec<ArcAny>): 触发一个事件。
• start_listening(&self) -> JoinHandle<()>: 启动事件处理循环。
• stop_listening(&self): 停止事件处理循环。
• clone(&self) -> Self: 创建 EventEmitter 的一个克隆。

事件参数

EventEmitter 支持为每个事件最多传递16个参数。此限制通过 FromArgs 特性和 impl_from_args! 宏实现。如果您需要传递超过16个参数，请考虑将相关数据分组到结构体中，或使用 Vec 或 HashMap 来传递数据集合。

宏

• emit!：用于以类型化参数触发事件的便捷宏。

线程安全

EventEmitter 被设计为线程安全的。事件处理器在单独的线程中执行，允许并发处理事件。

测试

该库包含一个全面的测试套件。使用以下命令运行测试：

cargo test

许可证

本项目根据 [LICENSE NAME] 许可。有关详细信息，请参阅 LICENSE 文件。

贡献

欢迎贡献！请随时提交一个 Pull Request。