Struct RuleSet

pub struct RuleSet<'a> {
    pub name: &'a str,
    pub order: u16,
    pub solver_families: &'a [SolverFamily],
    /* private fields */
}

A structure representing a set of rules with a name, priority, and dependencies.

RuleSet is a way to group related rules together under a single name. You can think of it like a list of rules that belong to the same category. Each RuleSet can also have a number that tells it what order it should run in compared to other RuleSet instances. Additionally, a RuleSet can depend on other RuleSet instances, meaning it needs them to run first.

To make things efficient, RuleSet only figures out its rules and dependencies the first time they’re needed, and then it remembers them so it doesn’t have to do the work again.

Fields

• name: The name of the rule set.
• order: A number that decides the order in which this RuleSet should be applied. If two RuleSet instances have the same rule but with different priorities, the one with the higher order number will be the one that is used.
• rules: A lazily initialized map of rules to their priorities.
• dependency_rs_names: The names of the rule sets that this rule set depends on.
• dependencies: A lazily initialized set of RuleSet dependencies.
• solver_families: The solver families that this rule set applies to.

Fields

name: &'a str

The name of the rule set.

order: u16

Order of the RuleSet. Used to establish a consistent order of operations when resolving rules. If two RuleSets overlap (contain the same rule but with different priorities), the RuleSet with the higher order will be used as the source of truth.

solver_families: &'a [SolverFamily]

The solver families that this rule set applies to.

Implementations

impl<'a> RuleSet<'a>

pub const fn new( name: &'a str, order: u16, dependencies: &'a [&'a str], solver_families: &'a [SolverFamily], ) -> RuleSet<'a>

pub fn get_rules(&self) -> &HashMap<&'a Rule<'a>, u16>

Get the rules of this rule set, evaluating them lazily if necessary Returns a &HashMap<&Rule, u16> where the key is the rule and the value is the priority of the rule.

pub fn get_dependencies(&self) -> &HashSet<&'static RuleSet<'_>>

Get the dependencies of this rule set, evaluating them lazily if necessary Returns a &HashSet<&RuleSet> of the rule sets that this rule set depends on.

pub fn with_dependencies(&self) -> HashSet<&'static RuleSet<'_>>

Get the dependencies of this rule set, including itself

Trait Implementations

impl<'a> Clone for RuleSet<'a>

fn clone(&self) -> RuleSet<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for RuleSet<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for RuleSet<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for RuleSet<'_>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RuleSet<'_>

fn eq(&self, other: &RuleSet<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for RuleSet<'_>