Struct Finding 

pub struct Finding {
    pub id: String,
    pub verdict: Verdict,
    pub why: String,
    pub revision: &'static str,
    pub substitutions: Vec<Substitution>,
    pub conjoined: bool,
    pub observed: Option<Observation>,
}

One published query’s verdict, with the evidence behind it.

Fields

id: String

verdict: Verdict

why: String

The evidence, in the words a maintainer needs to act on it.

revision: &'static str

What a re-card would do to this query: current (byte-identical to what this generator writes for this very card — nothing to fix), superseded (the generator writes a different body now), or dropped (it would no longer be emitted at all).

substitutions: Vec<Substitution>

The terms substituted into the body, each tagged with the card ranking it was drawn from. Two terms from different rankings conjoined in one body is the #172 shape — recorded for every query, so the census is empirical rather than a re-reading of the table.

conjoined: bool

True when the body conjoins two or more independently-ranked terms.

observed: Option<Observation>

What running the query actually did — absent unless --measure ran it. Kept beside verdict, never merged into it: one is what a card can prove about a file, the other is what the file did. Where they disagree the observation wins, and the disagreement is the finding.

Trait Implementations

impl Clone for Finding

fn clone(&self) -> Finding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Finding

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

Formats the value using the given formatter.

impl Serialize for Finding

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.