Struct conjure_oxide::RuleSet

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

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

Fields

name: &'a str

The name of the rule set.

order: u8

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: u8, dependencies: &'a [&'a str], solver_families: &'a [SolverFamily], ) -> RuleSet<'a>

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

Get the rules of this rule set, evaluating them lazily if necessary Returns a &HashMap<&Rule, u8> 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<'a> Display for RuleSet<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for RuleSet<'a>

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<'a> PartialEq for RuleSet<'a>

fn eq(&self, other: &RuleSet<'a>) -> 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<'a> Eq for RuleSet<'a>