Struct StructError 

pub struct StructError<T: DomainReason> { /* private fields */ }

Implementations

impl<T: DomainReason> StructError<T>

pub fn imp(&self) -> &StructErrorImpl<T>

pub fn reason(&self) -> &T

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

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

pub fn new( reason: T, detail: Option<String>, position: Option<String>, context: Vec<OperationContext>, ) -> Self

impl<T: DomainReason> StructError<T>

pub fn with_std_source<E>(self, source: E) -> Self

where E: StdError + Send + Sync + 'static,

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

where S: IntoSourcePayload,

pub fn with_struct_source<R>(self, source: StructError<R>) -> Self

where R: DomainReason,

pub fn source_ref(&self) -> Option<&(dyn StdError + 'static)>

pub fn root_cause(&self) -> Option<&(dyn StdError + 'static)>

pub fn source_frames(&self) -> &[SourceFrame]

pub fn source_payload(&self) -> Option<SourcePayloadRef<'_>>

pub fn source_payload_kind(&self) -> Option<SourcePayloadKind>

pub fn root_cause_frame(&self) -> Option<&SourceFrame>

pub fn context_metadata(&self) -> ErrorMetadata

pub fn context_metadata_at(&self, index: usize) -> Option<&ErrorMetadata>

pub fn source_chain(&self) -> Vec<String>

pub fn into_std(self) -> OwnedStdStructError<T>

pub fn into_boxed_std(self) -> Box<dyn StdError + Send + Sync + 'static>

pub fn into_dyn_std(self) -> OwnedDynStdStructError

where T: DomainReason,

pub fn as_std(&self) -> StdStructRef<'_, T>

pub fn display_chain(&self) -> String

where T: Debug + Display + 'static,

impl<T: DomainReason> StructError<T>

pub fn builder(reason: T) -> StructErrorBuilder<T>

pub fn with_position(self, position: impl Into<String>) -> Self

pub fn with_context<C: Into<OperationContext>>(self, context: C) -> Self

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

pub fn with_detail(self, detail: impl Into<String>) -> Self

pub fn err<V>(self) -> Result<V, Self>

pub fn action_main(&self) -> Option<String>

pub fn locator_main(&self) -> Option<String>

pub fn path_segments(&self) -> Vec<String>

pub fn target_path(&self) -> Option<String>

impl<T> StructError<T>

where T: DomainReason + ErrorIdentityProvider,

pub fn identity_snapshot(&self) -> ErrorIdentity

Build an ErrorIdentity from this error.

impl<T: DomainReason> StructError<T>

pub fn report(&self) -> DiagnosticReport

Build a DiagnosticReport from this error.

The report carries human-readable reason, detail, context, and source frames — no identity or protocol data.

Example

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

let err = StructError::from(UnifiedReason::validation_error())
    .with_detail("field `email` is required");

let report: DiagnosticReport = err.report();
assert!(report.reason().contains("validation"));
assert_eq!(report.detail(), Some("field `email` is required"));

pub fn into_report(self) -> DiagnosticReport

Consume this error and return its human-readable diagnostic report.

Example

use orion_error::{StructError, UnifiedReason};

let report = StructError::from(UnifiedReason::validation_error())
    .with_detail("field `email` is required")
    .into_report();

assert!(report.reason().contains("validation"));
assert_eq!(report.detail(), Some("field `email` is required"));

pub fn report_redacted(&self, policy: &impl RedactPolicy) -> DiagnosticReport

Build a redacted DiagnosticReport using the provided policy.

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 report = StructError::from(UnifiedReason::validation_error())
    .with_detail("token=abc")
    .report_redacted(&HideDetail);

assert_eq!(report.detail(), Some("<redacted>"));

pub fn render(&self) -> String

Render this error as a human-readable diagnostic string.

Delegates to DiagnosticReport::render().

Example

use orion_error::StructError;
use orion_error::reason::UnifiedReason;

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

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

Render a redacted human-readable diagnostic string.

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")
    .render_redacted(&HideDetail);

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

impl<T: DomainReason + ErrorIdentityProvider> StructError<T>

pub fn exposure( &self, exposure_policy: &impl ExposurePolicy, ) -> ErrorProtocolSnapshot

Build an ErrorProtocolSnapshot by combining identity, exposure decision, and diagnostic report in one pass.

This is the primary entry point for protocol-level error output. Requires ErrorIdentityProvider (provided by #[derive(OrionError)]).

Example

use orion_error::protocol::DefaultExposurePolicy;
use orion_error::{StructError, UnifiedReason};

let err = StructError::from(UnifiedReason::system_error())
    .with_detail("disk full");
let proto = err.exposure(&DefaultExposurePolicy);
assert_eq!(proto.identity.code, "sys.io_error");
assert_eq!(proto.decision.http_status, 500);

pub fn into_exposure( self, exposure_policy: &impl ExposurePolicy, ) -> ErrorProtocolSnapshot

Consume this error and return its protocol/exposure snapshot.

Example

use orion_error::protocol::DefaultExposurePolicy;
use orion_error::{StructError, UnifiedReason};

let proto = StructError::from(UnifiedReason::system_error())
    .with_detail("disk full")
    .into_exposure(&DefaultExposurePolicy);

assert_eq!(proto.identity.code, "sys.io_error");
assert_eq!(proto.decision.http_status, 500);

Trait Implementations

impl<T: Clone + DomainReason> Clone for StructError<T>

fn clone(&self) -> StructError<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R1, R2> ConvStructError<R2> for StructError<R1>

where R1: DomainReason, R2: DomainReason + From<R1>,

fn conv(self) -> StructError<R2>

impl<T: Debug + DomainReason> Debug for StructError<T>

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

Formats the value using the given formatter.

impl<T: DomainReason> Display for StructError<T>

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

Formats the value using the given formatter.

impl<T> ErrorIdentityProvider for StructError<T>

where T: DomainReason + ErrorIdentityProvider,

fn stable_code(&self) -> &'static str

fn error_category(&self) -> ErrorCategory

impl<T: DomainReason> ErrorWith for StructError<T>

fn position<S: Into<String>>(self, pos: S) -> Self

fn with_context<C: Into<OperationContext>>(self, ctx: C) -> Self

fn doing<S: Into<String>>(self, desc: S) -> Self

where Self: Sized,

fn at<C: Into<OperationContext>>(self, ctx: C) -> Self

where Self: Sized,

impl<'a, R> From<&'a StructError<R>> for StdStructRef<'a, R>

where R: DomainReason,

fn from(value: &'a StructError<R>) -> 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<R> From<StructError<R>> for OwnedDynStdStructError

where R: DomainReason,

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

Converts to this type from the input type.

impl<R> From<StructError<R>> for OwnedStdStructError<R>

where R: DomainReason,

fn from(value: StructError<R>) -> 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<T> From<T> for StructError<T>

where T: DomainReason,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: DomainReason> PartialEq for StructError<T>

fn eq(&self, other: &Self) -> 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.