Struct Report 

pub struct Report {
    pub changes: Vec<Change>,
}

What a redaction did: one entry per position that changed.

Entries are in the order the changes were made — rule by rule, and in message order within each rule (spec §8.4). A rule that matched nothing contributes none, and neither does an Action::Keep, an empty leaf, or a null one.

Example:

use er7_redact::{Action, Policy, Redactor};

let mut message = er7::parse("MSH|^~\\&|LAB\rPID|1||9||SMITH^JOHN")?;
let policy = Policy::accept_all().with("PID-5", Action::redacted())?;
let report = Redactor::new(policy).redact(&mut message);

// One row per leaf that actually changed.
let rows: Vec<String> = report.changes.iter().map(|c| c.to_string()).collect();
assert_eq!(rows, [
    "PID[1]-5[1].1.1 replace REDACTED",
    "PID[1]-5[1].2.1 replace REDACTED",
]);

Fields

changes: Vec<Change>

The changes, in the order they were made.

Implementations

impl Report

pub fn is_empty(&self) -> bool

True when nothing changed — which means either that the message carried none of the positions the policy names, or that the policy is wrong. The crate does not presume to say which (spec §2.5).

pub fn len(&self) -> usize

How many positions changed.

Examples found in repository

examples/redact_a_message.rs (line 17)

fn main() -> Result<(), er7_redact::Error> {
    let text = "MSH|^~\\&|ADT1|MCM|LABADT|MCM|20260815140000||ADT^A08|MSG00001|P|2.5\r\
                PID|1||PATID1234^^^ADT1^MR||EVERYWOMAN^EVE^E||19610615|F|||\
                1200 N ELM STREET^^GREENSBORO^NC^27401-1020||(919)379-1212\r\
                OBX|1|NM|2093-3^Cholesterol^LN||187|mg/dL|100-199|H|||F";

    let mut message = er7::parse(text)?;
    let report = Redactor::new(Policy::patient_identifiers()).redact(&mut message);

    println!("{}\n", message.to_er7().replace('\r', "\n"));
    println!("{} positions changed:\n{report}", report.len());

    // The identifiers are gone.
    assert_eq!(
        message.query("PID-5")?.as_deref(),
        Some("REDACTED^REDACTED^REDACTED")
    );
    assert_eq!(message.query("PID-7")?.as_deref(), Some("1961"));
    assert_eq!(message.query("PID-11")?.as_deref(), Some("^^^^"));
    assert_eq!(message.query("PID-13")?.as_deref(), Some(""));
    assert_ne!(message.query("PID-3.1")?.as_deref(), Some("PATID1234"));

    // The message is not.
    assert_eq!(message.control_id().as_deref(), Some("MSG00001"));
    assert_eq!(message.query("PID-3.4")?.as_deref(), Some("ADT1")); // assigning authority
    assert_eq!(message.query("PID-8")?.as_deref(), Some("F")); // not an identifier
    assert_eq!(message.query("OBX-5")?.as_deref(), Some("187")); // the clinical content
    assert!(er7::parse(&message.to_er7()).is_ok());

    // And the shape did not move: every position that held a value still
    // exists, so a test that asserted on PID-11.3 still finds it.
    assert_eq!(message.query("PID-11.3")?.as_deref(), Some(""));

    Ok(())
}

examples/read_the_report.rs (line 47)

fn main() -> Result<(), er7_redact::Error> {
    let text = "MSH|^~\\&|ADT1|MCM||||||ADT^A08|MSG1|P|2.5\r\
                PID|1||PATID1234^^^ADT1^MR||EVERYWOMAN^EVE^E||19610615|F|||\
                12 ELM ST^^BOSTON^MA^02101||555-555-1111~555-555-2222\r\
                NK1|1|EVERYMAN^ADAM|SPO";

    let mut message = er7::parse(text)?;
    let report = Redactor::new(Policy::patient_identifiers()).redact(&mut message);

    for change in &report.changes {
        println!("{:<18} {}", change.path.to_string(), change.action);
    }

    // One row per leaf that actually changed — so a name in three
    // components is three rows, and a repeated field is one row per
    // repetition.
    let paths: Vec<String> = report.changes.iter().map(|c| c.path.to_string()).collect();
    assert!(paths.contains(&"PID[1]-5[1].1.1".to_string()));
    assert!(paths.contains(&"PID[1]-5[1].3.1".to_string()));
    assert!(paths.contains(&"PID[1]-13[2].1.1".to_string()));

    // Every path is fully qualified, which means it is also a valid
    // `er7 --query` argument: paste one in to see what is there now.
    for change in &report.changes {
        assert!(message.query(&change.path.to_string()).is_ok());
    }

    // A report carries no values — not the old text, and not the new. A
    // log line quoting the old value puts the patient's name into the log.
    let printed = report.to_string();
    for value in ["EVERYWOMAN", "PATID1234", "19610615", "BOSTON"] {
        assert!(!printed.contains(value));
    }

    // And nothing that was not there contributes a row: this message has
    // no GT1 segment, so the guarantor rules matched nothing, which is not
    // an error.
    assert!(!paths.iter().any(|p| p.starts_with("GT1")));

    println!("\n{} positions changed", report.len());
    Ok(())
}

examples/redact_absent_empty_null.rs (line 27)

fn main() -> Result<(), er7_redact::Error> {
    // PID-1 has a value, PID-2 was sent blank, PID-3 is the explicit null,
    // and PID-4 onwards was never sent at all.
    let text = "MSH|^~\\&|LAB\rPID|1||\"\"";

    let policy = Policy::accept_all()
        .with("PID-1", Action::redacted())?
        .with("PID-2", Action::redacted())?
        .with("PID-3", Action::redacted())?
        .with("PID-9", Action::redacted())?;

    let mut message = er7::parse(text)?;
    let report = Redactor::new(policy).redact(&mut message);

    // Only the field that carried a value changed.
    assert_eq!(message.to_er7(), "MSH|^~\\&|LAB\rPID|REDACTED||\"\"");
    assert_eq!(report.len(), 1);

    // Why each of the other three was left alone:
    //
    // PID-2 was empty. Writing REDACTED into it would invent a value, and
    // would announce that one used to be there — which is a disclosure.
    assert!(message.segment("PID").unwrap().field(2).unwrap().is_empty());
    //
    // PID-3 is the explicit null: an instruction to the receiver to clear
    // its stored value, not patient data. Overwriting it would turn
    // "clear this" into a value, and leave a withdrawn record standing.
    assert!(message.segment("PID").unwrap().field(3).unwrap().is_null());
    //
    // PID-9 was never sent. Redaction does not lengthen a segment to reach
    // a position that is not there: padding would change what the message
    // says, and eleven new trailing pipes would announce the redaction.
    assert!(message.segment("PID").unwrap().field(9).is_none());

    // To *make* a position null — to tell the receiver to clear it — ask
    // for that, which is the one action that changes the shape of a
    // message, because an HL7 null is a single `""`.
    let mut message = er7::parse("MSH|^~\\&|LAB\rPID|1||9||SMITH^JOHN")?;
    let policy = Policy::accept_all().with("PID-5", Action::Null)?;
    Redactor::new(policy).redact(&mut message);
    assert_eq!(message.to_er7(), "MSH|^~\\&|LAB\rPID|1||9||\"\"");

    // Compare with `clear`, which says nothing rather than saying "delete".
    let mut message = er7::parse("MSH|^~\\&|LAB\rPID|1||9||SMITH^JOHN")?;
    let policy = Policy::accept_all().with("PID-5", Action::Clear)?;
    Redactor::new(policy).redact(&mut message);
    assert_eq!(message.to_er7(), "MSH|^~\\&|LAB\rPID|1||9||^");

    println!("absent, empty, and null all survived redaction unchanged");
    Ok(())
}

examples/reject_by_default.rs (line 49)

fn main() -> Result<(), er7_redact::Error> {
    let text = "MSH|^~\\&|LAB|ACME|EHR|CLINIC|20260815120000||ORU^R01|MSG9|P|2.5\r\
                PID|1||PATID1234||EVERYWOMAN^EVE||19610615|F\r\
                OBX|1|NM|2093-3^Cholesterol^LN||187|mg/dL|100-199|H|||F\r\
                ZPD|1|LOCAL^EXTENSION^SEGMENT";

    // Rejecting by default covers every leaf no rule named; a `keep` rule
    // accepts a position, exempting it from that. A rejecting rule would
    // beat the `keep` whichever order the two were written in (D19).
    let policy = Policy::all_but_the_header()
        .with("OBX-2", Action::Keep)? // value type
        .with("OBX-3", Action::Keep)? // observation identifier
        .with("OBX-5", Action::Keep)? // the number the test asserts on
        .with("OBX-6", Action::Keep)?; // units

    let mut message = er7::parse(text)?;
    let report = Redactor::new(policy).redact(&mut message);
    println!("{}\n", message.to_er7().replace('\r', "\n"));

    // The header is untouched, so the message still routes and still says
    // which version it is.
    assert_eq!(message.query("MSH-9")?.as_deref(), Some("ORU^R01"));
    assert_eq!(message.version().as_deref(), Some("2.5"));

    // The result is intact, because four rules said so.
    assert_eq!(message.query("OBX-3.2")?.as_deref(), Some("Cholesterol"));
    assert_eq!(message.query("OBX-5")?.as_deref(), Some("187"));

    // Everything else is gone — including the local segment, which no
    // curated policy could have known about.
    assert_eq!(message.query("PID-5.1")?.as_deref(), Some("REDACTED"));
    assert_eq!(message.query("ZPD-2.1")?.as_deref(), Some("REDACTED"));

    // The cost: values a positional policy would have kept are gone too.
    assert_eq!(message.query("PID-8")?.as_deref(), Some("REDACTED"));
    assert_eq!(message.query("OBX-8")?.as_deref(), Some("REDACTED"));

    println!("{} positions changed", report.len());

    // And what this posture is really for: a payload that is not ER7 at
    // all has no positions to name, so the policy says outright what
    // becomes of it. The curated policy above refuses one, which is what
    // makes the CLI exit non-zero rather than write it out.
    let redactor = Redactor::new(Policy::all_but_the_header());
    assert_eq!(redactor.unrecognised("{\"name\": \"EVERYWOMAN\"}"), None);

    // `Policy::reject_all` masks it whole instead — nothing routable
    // survives, and neither does anything else.
    let redactor = Redactor::new(Policy::reject_all());
    assert_eq!(
        redactor.unrecognised("EVERYWOMAN").as_deref(),
        Some("**********")
    );
    Ok(())
}

Trait Implementations

impl Clone for Report

fn clone(&self) -> Report

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Report

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

Formats the value using the given formatter.

impl Default for Report

fn default() -> Report

Returns the “default value” for a type.

impl Display for Report

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

One change per line. See Change for the row format.

impl Eq for Report

impl PartialEq for Report

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Report