Struct Rule 

pub struct Rule {
    pub id: &'static str,
    pub when: &'static [Condition],
    pub setting: &'static str,
    pub expect: Test,
    pub default: Value,
    pub unit: Unit,
    pub strength: Strength,
    pub basis: Basis,
    pub reason: &'static str,
    pub source: &'static str,
}

A rule: when Self::when holds, Self::setting should pass Self::expect.

Serialised with every field and its Kind ("kind", from the strength).

Fields

id: &'static str

Stable identifier, <method>.<what> in kebab case.

when: &'static [Condition]

Conditions, all of which must hold. The first is the triggering choice the rule is scoped to (see the module docs).

setting: &'static str

The setting the rule is about (a path in SETTINGS).

expect: Test

What the setting should pass.

default: Value

The value to apply to resolve the finding (one that passes expect).

unit: Unit

Unit of default and of any range in expect.

strength: Strength

basis: Basis

What the rule rests on: a statement by the authors, a QSM.rs measurement, the reference’s choice, or QSM.rs’s implementation.

reason: &'static str

One line: why.

source: &'static str

The authors’ code (file, line) or paper (section), or the QSM.rs docs recording the measurement.

Implementations

impl Rule

pub fn trigger(&self) -> &'static Condition

The triggering choice (the first condition).

pub fn kind(&self) -> Kind

The original authors’ setting, or a reasoned recommendation (Strength::kind).

pub fn needs_scan(&self) -> bool

Whether the rule can only fire once the scan is known.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Rule

impl Debug for Rule

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

Formats the value using the given formatter.

impl PartialEq for Rule

fn eq(&self, other: &Rule) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Rule

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Rule