Struct Diagnostic

pub struct Diagnostic { /* private fields */ }

Implementations

impl Diagnostic

pub fn warn(title: String, message: String) -> Self

pub fn error(title: String, message: String) -> Self

impl Diagnostic

pub fn render_report(&self, colored: bool) -> Result<String>

pub fn as_miette_error(&self) -> &Arc<Error>

pub fn message(&self) -> String

pub fn severity(&self) -> Severity

pub fn module_identifier(&self) -> Option<Identifier>

pub fn with_module_identifier( self, module_identifier: Option<Identifier>, ) -> Self

pub fn loc(&self) -> Option<&DependencyLocation>

pub fn with_loc(self, loc: Option<DependencyLocation>) -> Self

pub fn file(&self) -> Option<&Utf8Path>

pub fn with_file(self, file: Option<Utf8PathBuf>) -> Self

pub fn hide_stack(&self) -> Option<bool>

pub fn with_hide_stack(self, hide_stack: Option<bool>) -> Self

pub fn chunk(&self) -> Option<u32>

pub fn with_chunk(self, chunk: Option<u32>) -> Self

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

pub fn with_stack(self, stack: Option<String>) -> Self

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

pub fn with_details(self, details: Option<String>) -> Self

Methods from Deref<Target = Error>

pub fn chain(&self) -> Chain<'_>

An iterator of the chain of source errors contained by this Report.

This iterator will visit every error in the cause chain of this error object, beginning with the error that this error object was created from.

Example

use miette::Report;
use std::io;

pub fn underlying_io_error_kind(error: &Report) -> Option<io::ErrorKind> {
    for cause in error.chain() {
        if let Some(io_error) = cause.downcast_ref::<io::Error>() {
            return Some(io_error.kind());
        }
    }
    None
}

pub fn root_cause(&self) -> &(dyn Error + 'static)

The lowest level cause of this error — this error’s cause’s cause’s cause etc.

The root cause is the last error in the iterator produced by chain().

pub fn is<E>(&self) -> bool

where E: Display + Debug + Send + Sync + 'static,

Returns true if E is the type held by this error object.

For errors constructed from messages, this method returns true if E matches the type of the message D or the type of the error on which the message has been attached. For details about the interaction between message and downcasting, see here.

pub fn downcast_ref<E>(&self) -> Option<&E>

where E: Display + Debug + Send + Sync + 'static,

Downcast this error object by reference.

Example

// If the error was caused by redaction, then return a tombstone instead
// of the content.
match root_cause.downcast_ref::<DataStoreError>() {
    Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
    None => Err(error),
}

pub fn handler(&self) -> &(dyn ReportHandler + 'static)

Get a reference to the Handler for this Report.

Trait Implementations

impl Archive for Diagnostic

type Archived = <Unsupported as ArchiveWith<Diagnostic>>::Archived

The archived representation of this type.

type Resolver = <Unsupported as ArchiveWith<Diagnostic>>::Resolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for Diagnostic

fn clone(&self) -> Diagnostic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diagnostic

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

Formats the value using the given formatter.

impl Deref for Diagnostic

type Target = Report

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<__D> Deserialize<Diagnostic, __D> for <Unsupported as ArchiveWith<Diagnostic>>::Archived

where __D: Fallible + ?Sized, Unsupported: DeserializeWith<<Unsupported as ArchiveWith<Diagnostic>>::Archived, Diagnostic, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Diagnostic, __D::Error>

Deserializes using the given deserializer

impl From<Arc<Report>> for Diagnostic

fn from(value: Arc<Error>) -> Self

Converts to this type from the input type.

impl From<Box<dyn Diagnostic + Sync + Send>> for Diagnostic

fn from(value: Box<dyn Diagnostic + Send + Sync>) -> Self

Converts to this type from the input type.

impl From<Report> for Diagnostic

fn from(value: Error) -> Self

Converts to this type from the input type.

impl<__S> Serialize<__S> for Diagnostic

where __S: Fallible + ?Sized, Unsupported: SerializeWith<Diagnostic, __S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.