Rust中用enum实现多参数Hook机制完整代码

伟峰

目录

• 示例运行结果
• 代码解析
• 优化方向
• 总结

在 Rust 中，如果想为 enum 实现一个带多参数的 Hook 机制，可以结合模式匹配和枚举来处理。这种方式可以扩展到支持不同类型的输入参数和逻辑处理。

以下是一个实现 enum 和 Hook 的多参数机制的完整示例：

定义枚举和 Hook 类型

use std::sync::{Arc, Mutex};
// 定义一个多参数枚举
enum HookInput {
    Add(i32, i32),
    Multiply(i32, i32),
    Concat(String, String),
}
// 定义一个多返回值枚举
enum HookOutput {
    Sum(i32),
    Product(i32),
    Combined(String),
    None,
}
// 定义 Hook 类型
type HookFn = Arc<dyn Fn(HookInput) -> HookOutput + Send + Sync>;
// Hook 管理器
struct HookManager {
    hooks: Mutex<Vec<HookFn>>,
}
impl HookManager {
    fn new() -> Self {
        Self {
            hooks: Mutex::new(Vec::new()),
        }
    }
    // 添加 Hook 函数
    fn add_hook<F>(&self, hook: F)
    where
        F: Fn(HookInput) -> HookOutput + Send + Sync + 'static,
    {
        self.hooks.lock().unwrap().push(Arc::new(hook));
    }
    // 执行所有 Hook
    fn execute_hooks(&self, input: HookInput) -> Vec<HookOutput> {
        let hooks = self.hooks.lock().unwrap();
        hooks.iter().map(|hook| hook(input.clone())).collect()
    }
}
// 实现 Clone 对 HookInput 的支持
impl Clone for HookInput {
    fn clone(&self) -> Self {
        match self {
            HookInput::Add(a, b) => HookInput::Add(*a, *b),
            HookInput::Multiply(a, b) => HookInput::Multiply(*a, *b),
            HookInput::Concat(a, b) => HookInput::Concat(a.clone(), b.clone()),
        }
    }
}

使用 Hook 管理器

fn main() {
    let manager = HookManager::new();
    // 添加第一个 Hook：处理 Add
    manager.add_hook(|input| match input {
        HookInput::Add(a, b) => {
            println!("Adding: {} + {}", a, b);
            HookOutput::Sum(a + b)
        }
        _ => HookOutput::None,
    });
    // 添加第二个 Hook：处理 Multiply
    manager.add_hook(|input| match input {
        HookInput::Multiply(a, b) => {
            println!("Multiplying: {} * {}", a, b);
            HookOutput::Product(a * b)
        }
        _ => HookOutput::None,
    });
    // 添加第三个 Hook：处理 Concat
    manager.add_hook(|input| match input {
        HookInput::Concat(a, b) => {
            println!("Concatenating: {} + {}", a, b);
            HookOutput::Combined(format!("{}{}", a, b))
        }
        _ => HookOutput::None,
    });
    // 执行 Hook：Add
    let add_results = manager.execute_hooks(HookInput::Add(3, 4));
    println!("Results for Add: {:?}", add_results);
    // 执行 Hook：Multiply
    let multiply_results = manager.execute_hooks(HookInput::Multiply(5, 6));
    println!("Results for Multiply: {:?}", multiply_results);
    // 执行 Hook：Concat
    let concat_results = manager.execute_hooks(HookInput::Concat(
        "Hello".to_string(),
        "World".to_string(),
    ));
    println!("Results for Concat: {:?}", concat_results);
}

示例运行结果

Adding: 3 + 4
Results for Add: [Sum(7), None, None]

Multiplying: 5 * 6
Results for Multiply: [None, Product(30), None]

Concatenating: Hello + World
Results for Concat: [None, None, Combined("HelloWorld")]

代码解析

多参数处理：

• HookInput 使用枚举定义了不同的输入类型（如 Add(i32, i32)、Multiply(i32, i32)、Concat(String, String)）。
• 每个变体表示不同的逻辑分支，可扩展为更多的操作类型。

多返回值处理：
• HookOutput 使用枚举定义了不同的输出类型（如 Sum(i32)、Product(i32)、Combined(String)）。
• 每个变体对应不同的返回值逻辑。

Hook 管理器：
• HookManager 使用 Vec 存储所有注册的 Hook 函数。
• execute_hooks 遍历所有 Hook，并根据输入调用相应逻辑，收集返回值。

扩展性：
• 可以轻松添加新的 HookInput 和 HookOutput 枚举变体，扩展新的逻辑。
• 新的 Hook 函数只需要匹配新添加的变体即可。

优化方向

并行执行：
如果多个 Hooks 可以并行执行，可以引入并行迭代工具，如 rayon。

use rayon::prelude::*;
hooks.par_iter().map(|hook| hook(input.clone())).collect()

动态分派：
如果需要动态注册更多类型的操作，可以将输入参数定义为 Box，并结合 downcast 使用。返回值过滤：
可以在 execute_hooks 中过滤掉 HookOutput::None 的结果，以简化结果处理。

总结

• 核心思路：
利用 enum 表达多种输入和输出类型，配合模式匹配实现多参数和多逻辑分支的 Hook 机制。
• 扩展性强：
通过新增枚举变体，可以轻松支持更多的输入和返回值类型。
• 适用场景：
• 插件系统
• 事件驱动架构
• 动态业务逻辑处理

到此这篇关于Rust中用enum实现多参数Hook机制的文章就介绍到这了,更多相关Rust enum 多参数Hook机制内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！

您可能感兴趣的文章:

• Rust数据类型之结构体Struct的使用
• Rust Struct结构体详解
• 解析Rust struct 中的生命周期
• 解析rust中的struct
• Rust中non_exhaustive的enum使用确保程序健壮性
• 在Rust中要用Struct和Enum组织数据的原因解析