Struct Provenance 

pub struct Provenance {
    pub molframe_version: &'static str,
    pub input_source: SourceRef,
    pub input_digest: Option<ContentDigest>,
    pub policy: AnalysisPolicy,
    pub policy_fingerprint: Fingerprint,
    pub profile: Option<ProfileId>,
    pub algorithm: Option<AlgorithmId>,
    pub parameters: AnalysisParameters,
    pub schema_version: Option<DictionaryVersion>,
    pub component_version: Option<DictionaryVersion>,
    pub timestamp: Option<Box<str>>,
}

Everything needed to reproduce a result.

Examples

use molframe_core::contract::{AnalysisPolicy, Provenance, SourceRef};

let policy = AnalysisPolicy::default();
let record = Provenance::new(&policy).with_source(SourceRef::path("1abc.cif"));

assert_eq!(record.profile.map(|profile| profile.as_str()), Some("molframe-default-1.0"));
assert_eq!(record.policy_fingerprint, policy.fingerprint());

Fields

molframe_version: &'static str

The version of molframe that produced the result.

input_source: SourceRef

Where the input came from.

input_digest: Option<ContentDigest>

The SHA-256 digest of the input’s bytes, where they were read.

policy: AnalysisPolicy

The policy in force.

policy_fingerprint: Fingerprint

A fingerprint of that policy.

profile: Option<ProfileId>

The named profile, where the policy is one unaltered.

algorithm: Option<AlgorithmId>

Versioned algorithm, when the result is algorithm-specific.

parameters: AnalysisParameters

Sorted typed parameters that can change the result.

schema_version: Option<DictionaryVersion>

The version of the schema dictionary consulted.

component_version: Option<DictionaryVersion>

The version of the chemical component data consulted.

timestamp: Option<Box<str>>

When the analysis ran, if the caller asked for it recorded.

Excluded from every fingerprint.

Implementations

impl Provenance

pub fn new(policy: &AnalysisPolicy) -> Self

Starts a record under policy.

pub fn with_policy_reads(self, fields: &[PolicyField]) -> Self

Records which policy fields the analysis actually applied.

A field the policy sets but the analysis never reads cannot change its result, so varying it measures nothing. Recording what was read is what lets an audit tell “stable under this decision” from “never saw this decision”.

pub fn policy_reads(&self) -> Option<Vec<PolicyField>>

The policy fields the analysis applied, when it recorded them.

pub fn with_estimand(self, estimand: &str) -> Self

Records the quantity the analysis estimates, in words.

Two analyses under the same name can ask different questions of the same structure; saying which one was asked is part of what a result means.

pub fn estimand(&self) -> Option<&str>

The quantity the analysis estimates, when it said.

pub fn with_source(self, source: SourceRef) -> Self

Records where the input came from.

pub const fn with_input_digest(self, digest: ContentDigest) -> Self

Records the SHA-256 digest of the input’s bytes.

pub fn with_timestamp(self, timestamp: impl Into<Box<str>>) -> Self

Records when the analysis ran.

pub fn with_algorithm(self, algorithm: AlgorithmId) -> Self

Records the versioned algorithm used by this analysis.

pub fn with_parameter( self, name: impl Into<Box<str>>, value: ParameterValue, ) -> Self

Records or replaces one result-affecting parameter.

pub fn fingerprint(&self) -> Fingerprint

A fingerprint of everything that affects the result.

Two runs over the same input under the same policy agree here whatever the clock said, which is what makes the value a property of the result rather than of the occasion.

impl Provenance

pub fn to_json(&self) -> String

Serialises the complete record as deterministic JSON.

Keys follow a fixed order and every policy field is named explicitly. The result is independent of map iteration order.

pub fn entries(&self) -> Vec<(String, String)>

The record as ordered key and value pairs: the one list that to_json and to_mmcif both project, for a caller that writes another format.

pub fn to_mmcif(&self) -> String

Serialises the complete record as a standalone mmCIF data block.

The two-column category is deliberately lossless and extensible: older readers can preserve fields they do not interpret.

Trait Implementations

impl Clone for Provenance

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Provenance

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

Formats the value using the given formatter.