Struct Problem 

pub struct Problem {
    pub causes: ThinVec<Cause>,
}

A problem is a simple wrapper for an error causation chain.

Each link in the chain is a Cause, which is itself a simple wrapper for a CapturedError. Each cause can have any number of attachments.

Though you can iterate a problem directly to access its causes, often it is easier to use one of the many convenience functions in the ProblemImplementation and Causes traits.

Note that this type does not itself implement Error directly, but you can use into_error if compatibility is needed.

For more information and usage examples see the Problemo home page.

Fields

causes: ThinVec<Cause>

Causes in order of causation from top to root.

Implementations

impl Problem

pub fn new(error: CapturedError) -> Self

Constructor.

pub fn into_error(self) -> ProblemAsError

Add support for Error.

Take care to avoid adding it into a Problem’s causation chain.

pub fn via<ErrorT>(self, error: ErrorT) -> Self

where ErrorT: 'static + Error + Send + Sync,

Adds the error to the top of the causation chain.

pub fn with<AttachmentT>(self, attachment: AttachmentT) -> Self

where AttachmentT: Any + Send + Sync,

Attach to the top cause.

pub fn with_once<AttachmentT>(self, attachment: AttachmentT) -> Self

where AttachmentT: Any + Send + Sync,

Attach only if we don’t already have one of the same type.

pub fn maybe_with<AttachmentT>(self, attachment: Option<AttachmentT>) -> Self

where AttachmentT: Any + Send + Sync,

Attach to the top cause if Some.

pub fn maybe_with_once<AttachmentT>( self, attachment: Option<AttachmentT>, ) -> Self

where AttachmentT: Any + Send + Sync,

Attach to the top cause if Some and we don’t already have one of the same type.

pub fn with_location(self) -> Self

Attach a Location (via Location::caller) if we don’t already have one.

pub fn with_backtrace(self) -> Self

Attach a backtrace if we don’t already have one.

pub fn into_problems(self) -> Problems

Convert into Problems.

Will return the first cause that is a Problems, otherwise will return a new Problems with just self.

Note that this is identical to calling Problems::from(problem).

Trait Implementations

impl Attachments for Problem

fn attachments(&self) -> impl Iterator<Item = &CapturedAttachment>

Iterate attachments.

fn attachments_of_type<'this, AttachmentT>( &'this self, ) -> impl Iterator<Item = &'this AttachmentT>

where AttachmentT: 'static,

Iterate attachments of a type.

fn attachment_of_type<AttachmentT>(&self) -> Option<&AttachmentT>

where AttachmentT: 'static,

First attachment of a type.

impl AttachmentsMut for Problem

fn attachments_mut(&mut self) -> impl Iterator<Item = &mut CapturedAttachment>

Iterate attachments.

fn attach<AttachmentT>(&mut self, attachment: AttachmentT)

where AttachmentT: Any + Send + Sync,

Add an attachment.

fn attachments_of_type_mut<'this, AttachmentT>( &'this mut self, ) -> impl Iterator<Item = &'this mut AttachmentT>

where AttachmentT: 'static,

Iterate attachments of a type.

fn attachment_of_type_mut<AttachmentT>(&mut self) -> Option<&mut AttachmentT>

where AttachmentT: 'static,

First attachment of a type.

fn must_attachment_of_type_mut<AttachmentT, DefaultT>( &mut self, default: DefaultT, ) -> &mut AttachmentT

where AttachmentT: 'static + Send + Sync, DefaultT: FnOnce() -> AttachmentT,

First attachment of a type.

fn attach_once<AttachmentT>(&mut self, attachment: AttachmentT)

where AttachmentT: 'static + Send + Sync,

Add an attachment only if we don’t already have one of its type.

fn attach_location_once(&mut self)

Add a Location (via Location::caller) attachment if we don’t already have one.

fn attach_backtrace_once(&mut self)

Available on crate feature backtrace-external only.

Add a backtrace attachment if we don’t already have one.

impl Causes for Problem

fn problem(&self) -> &Problem

The problem that owns this causation chain.

fn iter_causes(&self) -> impl Iterator<Item = &Cause>

Iterate causes in order of causation.

fn iter_causes_with_error_type<ErrorT>( &self, ) -> impl Iterator<Item = CauseRef<'_, ErrorT>>

where ErrorT: 'static + Error,

Iterate causes with an error of a type.

fn iter_causes_until_error_type<ErrorT>(&self) -> impl Iterator<Item = &Cause>

where ErrorT: 'static + Error,

Iterate causes in order of causation until (but not including) a cause with an error of a type.

fn iter_causes_from_error_type<ErrorT>(&self) -> impl Iterator<Item = &Cause>

where ErrorT: 'static + Error,

Iterate causes in order of causation from a cause with an error of a type.

fn iter_causes_with_error<ErrorT>( &self, error: &ErrorT, ) -> impl Iterator<Item = CauseRef<'_, ErrorT>>

where ErrorT: 'static + Error + PartialEq,

Iterate causes with the error.

fn iter_causes_with_attachment_type<AttachmentT>( &self, ) -> impl Iterator<Item = (&Cause, &AttachmentT)>

where AttachmentT: 'static,

Iterate causes with an attachment of a type.

fn cause_with_error_type<ErrorT>(&self) -> Option<CauseRef<'_, ErrorT>>

where ErrorT: 'static + Error,

The first cause with an error of a type.

fn cause_with_error<ErrorT>( &self, error: &ErrorT, ) -> Option<CauseRef<'_, ErrorT>>

where ErrorT: 'static + Error + PartialEq,

The first cause with the error.

fn cause_with_attachment_type<AttachmentT>( &self, ) -> Option<(&Cause, &AttachmentT)>

where AttachmentT: 'static,

The first cause with an attachment of a type.

fn iter_errors(&self) -> impl Iterator<Item = &CapturedError>

Iterate errors in order of causation.

fn iter_errors_of_type<ErrorT>(&self) -> impl Iterator<Item = &ErrorT>

where ErrorT: 'static + Error,

Iterate errors of a type in order of causation.

fn error_of_type<ErrorT>(&self) -> Option<&ErrorT>

where ErrorT: 'static + Error,

The first error of a type.

fn has_error_type<ErrorT>(&self) -> bool

where ErrorT: 'static + Error,

Whether we have an error of a type in the causation chain.

fn has_error<ErrorT>(&self, error: &ErrorT) -> bool

where ErrorT: 'static + Error + PartialEq,

Whether we have the error in the causation chain.

impl Debug for Problem

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

Formats the value using the given formatter.

impl Default for Problem

fn default() -> Self

Returns the “default value” for a type.

impl Display for Problem

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

Formats the value using the given formatter.

impl From<&Problem> for ExitCode

fn from(problem: &Problem) -> Self

Converts to this type from the input type.

impl<ErrorT> From<ErrorT> for Problem

where ErrorT: 'static + Error + Send + Sync,

fn from(error: ErrorT) -> Self

Converts to this type from the input type.

impl From<Problem> for Error

Available on crate feature anyhow only.

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl From<Problem> for Error

Available on crate feature wasmtime only.

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl From<Problem> for ExitCode

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl From<Problem> for ProblemAsError

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl From<Problem> for Problems

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl From<Problem> for SerdeProblem

Available on crate feature serde only.

fn from(problem: Problem) -> Self

Converts to this type from the input type.

impl FromIterator<Problem> for Problems

fn from_iter<IntoIteratorT>(iterator: IntoIteratorT) -> Self

where IntoIteratorT: IntoIterator<Item = Problem>,

Creates a value from an iterator.

impl Into<Error> for Problem

fn into(self) -> Error

Converts this type into the (usually inferred) input type.

impl<'this> IntoIterator for &'this Problem

Available on crate feature thin-vec only.

type Item = &'this Cause

The type of the elements being iterated over.

type IntoIter = Iter<'this, Cause>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'this> IntoIterator for &'this mut Problem

Available on crate feature thin-vec only.

type Item = &'this mut Cause

The type of the elements being iterated over.

type IntoIter = IterMut<'this, Cause>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Problem

Available on crate feature thin-vec only.

type Item = Cause

The type of the elements being iterated over.

type IntoIter = IntoIter<Cause>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoProblem for Problem

fn into_problem(self) -> Problem

Into a Problem.

impl PartialEq for Problem

fn eq(&self, other: &Problem) -> 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 PartialOrd for Problem

fn partial_cmp(&self, other: &Problem) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ProblemImplementation for Problem

Available on crate feature thin-vec only.

fn depth(&self) -> usize

The length of the causation chain.

fn get(&self, depth: usize) -> Option<&Cause>

A cause in the causation chain.

fn get_mut(&mut self, depth: usize) -> Option<&mut Cause>

A cause in the causation chain.

fn top(&self) -> Option<&Cause>

The top of the causation chain.

fn top_mut(&mut self) -> Option<&mut Cause>

The top of the causation chain.

fn root(&self) -> Option<&Cause>

The root of the causation chain.

fn root_mut(&mut self) -> Option<&mut Cause>

The root of the causation chain.

fn add_top(&mut self, cause: Cause)

Adds to the top of the causation chain.

fn under(self, problem: Problem) -> Self

Inserts our causation chain under that of the given one.

fn above(self, problem: Problem) -> Self

Appends our causation chain above that of the given one.

impl WithExitCode for Problem

fn with_exit_code<ExitCodeT>(self, exit_code: ExitCodeT) -> Self

where ExitCodeT: Into<ExitCode>,

With an ExitCode attachment.

fn with_failure_exit_code(self) -> Self

With an ExitCode::FAILURE attachment.

fn with_success_exit_code(self) -> Self

With an ExitCode::SUCCESS attachment.

impl Eq for Problem

impl StructuralPartialEq for Problem