如何从特定模块创建所有装饰函数的向量？

我有一个文件main.rs和一个文件rule.rs。我想定义函数rule.rs将被纳入Rules::rule矢量，而不必将它们一一推动。我更喜欢一个循环来推动它们。

main.rs:

struct Rules {
    rule: Vec<fn(arg: &Arg) -> bool>,
}

impl Rules {
    fn validate_incomplete(self, arg: &Arg) -> bool {
        // iterate through all constraints and evaluate, if false return and stop
        for constraint in self.incomplete_rule_constraints.iter() {
            if !constraint(&arg) {
                return false;
            }
        }
        true
    }
}

rule.rs:

pub fn test_constraint1(arg: &Arg) -> bool {
    arg.last_element().total() < 29500
}

pub fn test_constraint2(arg: &Arg) -> bool {
    arg.last_element().total() < 35000
}

Rules::rule应该填充test_constraint1 and test_constraint2.

在Python中，我可以添加一个装饰器@rule_decorator高于您想要包含在的约束Vec，但我在 Rust 中没有看到类似的东西。

在Python中，我可以使用dir(module)查看所有可用的方法/属性。

Python 变体：

class Rules:

    def __init__(self, name: str):
        self.name = name
        self.rule = []

        for member in dir(self):
            method = getattr(self, member)
            if "rule_decorator" in dir(method):
                self.rule.append(method)

    def validate_incomplete(self, arg: Arg):
        for constraint in self.incomplete_rule_constraints:
            if not constraint(arg):
                return False
        return True

使用rule.py文件：

@rule_decorator
def test_constraint1(arg: Arg):
    return arg.last_element().total() < 29500

@rule_decorator
def test_constraint1(arg: Arg):
    return arg.last_element().total() < 35000

所有功能都带有rule_decorator被添加到self.rule列出并由validate_incomplete功能。

通过一些调整和限制，您可以实现您的目标。您需要使用库存箱 https://crates.io/crates/inventory。这是仅限 Linux、macOS 和 Windows眼下。

然后你可以使用inventory::submit向全局注册表添加值，inventory::collect建立注册表，以及inventory::iter迭代注册表。

由于语言限制，您无法为不属于您的类型的值创建注册表，其中包括原始函数指针。我们需要创建一个newtype called Predicate使用板条箱：

use inventory; // 0.1.3

struct Predicate(fn(&u32) -> bool);
inventory::collect!(Predicate);

struct Rules;

impl Rules {
    fn validate_incomplete(&self, arg: &u32) -> bool {
        inventory::iter::<Predicate>
            .into_iter()
            .all(|Predicate(constraint)| constraint(arg))
    }
}

mod rules {
    use super::Predicate;

    pub fn test_constraint1(arg: &u32) -> bool {
        *arg < 29500
    }
    inventory::submit!(Predicate(test_constraint1));

    pub fn test_constraint2(arg: &u32) -> bool {
        *arg < 35000
    }
    inventory::submit!(Predicate(test_constraint2));
}

fn main() {
    if Rules.validate_incomplete(&42) {
        println!("valid");
    } else {
        println!("invalid");
    }
}

为了实现最初设定的目标，您还需要采取一些步骤：

• “一个向量”

  You can collect从提供的迭代器构建一个Vec.

• “装饰函数”

  您可以编写自己的程序宏来调用inventory::submit!(Predicate(my_function_name));为你。

• “来自特定模块”

  你可以加模块名称 https://doc.rust-lang.org/std/macro.module_path.html进入Predicate稍后对其进行结构和过滤。

也可以看看：

• 如何在编译时静态注册结构？ https://stackoverflow.com/q/32678845/155423