Struct Analysis 

pub struct Analysis<T> {
    pub coverage: Coverage,
    pub warnings: Vec<Diagnostic>,
    pub assumptions: Vec<Assumption>,
    pub provenance: Provenance,
    /* private fields */
}

An outcome, and everything needed to judge it.

The answer is behind Analysis::outcome, Analysis::value or Analysis::into_result, each of which says what happens when there is no answer. There is no Deref to the value: a contract that lets the value be read without asking whether it exists is a contract the indeterminate case can slip through.

Examples

use molframe_core::contract::{Analysis, AnalysisPolicy, Coverage, Status};

let policy = AnalysisPolicy::default();
let radius = Analysis::complete(14.2_f64, Coverage::complete(1_960), &policy);

assert_eq!(radius.value(), Some(&14.2));
assert_eq!(radius.status(), Status::Complete);
assert_eq!(radius.coverage.fraction(), 1.0);

Fields

coverage: Coverage

How much of the intended data was used.

warnings: Vec<Diagnostic>

What the analysis found worth saying.

assumptions: Vec<Assumption>

What it decided on the caller’s behalf.

provenance: Provenance

Where the inputs came from and under what policy.

Implementations

impl<T> Analysis<T>

pub fn determinate( value: T, quality: Quality, coverage: Coverage, policy: &AnalysisPolicy, ) -> Self

An answer of the given quality.

pub fn complete(value: T, coverage: Coverage, policy: &AnalysisPolicy) -> Self

A complete result.

pub fn partial(value: T, coverage: Coverage, policy: &AnalysisPolicy) -> Self

A result computed over less than it intended.

pub fn ambiguous(value: T, coverage: Coverage, policy: &AnalysisPolicy) -> Self

A result that is one of several defensible ones.

pub fn indeterminate( reason: Indeterminacy, coverage: Coverage, policy: &AnalysisPolicy, ) -> Self

A refusal to answer, with the reason.

There is no value to supply and none to read back.

pub const fn from_parts( outcome: Outcome<T>, quality: Quality, coverage: Coverage, warnings: Vec<Diagnostic>, assumptions: Vec<Assumption>, provenance: Provenance, ) -> Self

Assembles an analysis from its parts.

quality qualifies a determinate outcome and is ignored for an indeterminate one, which has no answer to qualify.

pub fn with_atom_origin(self, origin: Vec<u32>) -> Self

Records which input atom each analysed atom is.

A governed analysis runs over a system the policy builds: the input with some atoms dropped (a conformer not chosen, hydrogens excluded) or copied (an assembly). The atom indices in its result number that system, not the input; this map says which input atom each one is, and copies of an atom share it.

pub fn atom_origin(&self) -> Option<&[u32]>

For each analysed atom, the input atom it is; None when the result’s atoms are the input’s own.

pub fn into_parts( self, ) -> (Outcome<T>, Quality, Coverage, Vec<Diagnostic>, Vec<Assumption>, Provenance)

Takes the analysis apart, for code that builds a new one from an old one.

pub const fn outcome(&self) -> &Outcome<T>

The answer or the reason there is none.

pub fn into_outcome(self) -> Outcome<T>

Consumes the analysis, keeping only the outcome.

pub const fn value(&self) -> Option<&T>

The answer, if there is one.

pub const fn indeterminacy(&self) -> Option<&Indeterminacy>

The reason there is no answer, if there is none.

pub fn into_result(self) -> Result<T, Indeterminacy>

Consumes the analysis: the answer, or the reason it is missing.

Errors

Returns the Indeterminacy when no defensible answer exists.

pub const fn status(&self) -> Status

How far the analysis got: the quality of its answer, or Indeterminate.

pub const fn quality(&self) -> Option<Quality>

The quality of the answer, when there is one.

pub fn degrade(&mut self, quality: Quality)

Lowers the quality to quality if that is worse; no effect on a refusal.

pub fn with_warning(self, warning: Diagnostic) -> Self

Attaches a finding.

pub fn with_assumption(self, assumption: Assumption) -> Self

Records a decision made on the caller’s behalf.

pub fn policy_fingerprint(&self) -> Fingerprint

The fingerprint of the policy this was computed under.

pub fn silent_assumptions( &self, threshold: f64, ) -> impl Iterator<Item = &Assumption>

The decisions the caller never made that measurably changed the answer by at least threshold.

pub fn map<U>(self, transform: impl FnOnce(T) -> U) -> Analysis<U>

Applies a function to the answer, keeping everything else.

Trait Implementations

impl<T: Clone> Clone for Analysis<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Analysis<T>

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

Formats the value using the given formatter.