Struct DiagnosticReport 

pub struct DiagnosticReport { /* private fields */ }

Implementations

impl DiagnosticReport

pub fn reason(&self) -> &str

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

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

pub fn context(&self) -> &[OperationContext]

pub fn render(&self) -> String

Render this report as a human-readable diagnostic string.

Example

use orion_error::{StructError, UnifiedReason};

let err = StructError::from(UnifiedReason::validation_error())
    .with_detail("field `email` is required");
let report = err.report();
let output = report.render();
assert!(output.contains("reason:"));
assert!(output.contains("validation"));

pub fn redacted(&self, policy: &impl RedactPolicy) -> Self

Return a redacted copy of this report.

Example

use orion_error::{StructError, UnifiedReason};
use orion_error::report::RedactPolicy;

struct HidePosition;

impl RedactPolicy for HidePosition {
    fn redact_value(&self, key: Option<&str>, value: &str) -> Option<String> {
        if key == Some("position") {
            Some("<hidden>".to_string())
        } else {
            Some(value.to_string())
        }
    }
}

let report = StructError::from(UnifiedReason::validation_error())
    .with_position("src/main.rs:42")
    .report()
    .redacted(&HidePosition);

assert_eq!(report.position(), Some("<hidden>"));

pub fn render_redacted(&self, policy: &impl RedactPolicy) -> String

Render this report after applying redaction.

Example

use orion_error::{StructError, UnifiedReason};
use orion_error::report::RedactPolicy;

struct HideDetail;

impl RedactPolicy for HideDetail {
    fn redact_value(&self, key: Option<&str>, value: &str) -> Option<String> {
        if key == Some("detail") {
            Some("<redacted>".to_string())
        } else {
            Some(value.to_string())
        }
    }
}

let rendered = StructError::from(UnifiedReason::validation_error())
    .with_detail("token=abc")
    .report()
    .render_redacted(&HideDetail);

assert!(rendered.contains("detail: <redacted>"));

Trait Implementations

impl Clone for DiagnosticReport

fn clone(&self) -> DiagnosticReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DiagnosticReport

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

Formats the value using the given formatter.

impl<T: DomainReason> From<&StructError<T>> for DiagnosticReport

fn from(value: &StructError<T>) -> Self

Converts to this type from the input type.

impl<T: DomainReason> From<StructError<T>> for DiagnosticReport

fn from(value: StructError<T>) -> Self

Converts to this type from the input type.

impl PartialEq for DiagnosticReport

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DiagnosticReport