Struct EvidenceChain 

pub struct EvidenceChain {
    pub rule_id: String,
    pub rule_version: String,
    pub links: Vec<EvidenceLink>,
    pub strength: EvidenceStrength,
}

An ordered chain of evidence links for a single decision.

Build the chain by adding EvidenceLinks, then call finalize to compute the aggregate EvidenceStrength.

rule_id and rule_version identify the rule or model that produced this chain — use any stable identifiers meaningful to your domain.

Example

use evidence_chain::{EvidenceChain, EvidenceLink, EvidenceCategory};

let mut chain = EvidenceChain::new("velocity-check", "1.2.0");

chain.add_link(
    EvidenceLink::new(EvidenceCategory::Value, "5 transactions in 10 minutes", "window:abc")
        .with_metric(5.0, "tx/10min")
        .with_threshold(3.0, true),
);
chain.add_link(
    EvidenceLink::new(EvidenceCategory::Structural, "All transactions to same recipient", "addr:xyz")
        .with_threshold(1.0, true),
);

chain.finalize();
assert_eq!(chain.strength.ratio, 1.0);

Fields

rule_id: String

Identifier of the rule or model that produced this chain.

rule_version: String

Version of the rule or model.

links: Vec<EvidenceLink>

Ordered list of evidence observations.

strength: EvidenceStrength

Aggregate strength — populated by finalize.

Implementations

impl EvidenceChain

pub fn new(rule_id: impl Into<String>, version: impl Into<String>) -> Self

Creates an empty chain for the given rule identifier and version.

pub fn add_link(&mut self, link: EvidenceLink)

Appends an evidence link to the chain.

pub fn finalize(&mut self)

Recomputes EvidenceStrength from the current links.

Idempotent — safe to call multiple times. Call after all links have been added to get an accurate strength.

Trait Implementations

impl Clone for EvidenceChain

fn clone(&self) -> EvidenceChain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EvidenceChain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EvidenceChain

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EvidenceChain

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

where __S: Serializer,

Serialize this value into the given Serde serializer.