Trait hdk::prelude::holochain_serialized_bytes::serde::de::StdError

pub trait StdError: Debug + Display {
    // Provided methods
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    fn description(&self) -> &str { ... }
    fn cause(&self) -> Option<&dyn Error> { ... }
    fn provide<'a>(&'a self, request: &mut Request<'a>) { ... }
}

Error is a trait representing the basic expectations for error values, i.e., values of type E in Result<T, E>.

Errors must describe themselves through the Display and Debug traits. Error messages are typically concise lowercase sentences without trailing punctuation:

let err = "NaN".parse::<u32>().unwrap_err();
assert_eq!(err.to_string(), "invalid digit found in string");

Errors may provide cause information. Error::source() is generally used when errors cross “abstraction boundaries”. If one module must report an error that is caused by an error from a lower-level module, it can allow accessing that error via Error::source(). This makes it possible for the high-level module to provide its own errors while also revealing some of the implementation for debugging.

Provided Methods

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

Examples

use std::error::Error;
use std::fmt;

#[derive(Debug)]
struct SuperError {
    source: SuperErrorSideKick,
}

impl fmt::Display for SuperError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperError is here!")
    }
}

impl Error for SuperError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&self.source)
    }
}

#[derive(Debug)]
struct SuperErrorSideKick;

impl fmt::Display for SuperErrorSideKick {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperErrorSideKick is here!")
    }
}

impl Error for SuperErrorSideKick {}

fn get_super_error() -> Result<(), SuperError> {
    Err(SuperError { source: SuperErrorSideKick })
}

fn main() {
    match get_super_error() {
        Err(e) => {
            println!("Error: {e}");
            println!("Caused by: {}", e.source().unwrap());
        }
        _ => println!("No error"),
    }
}

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() {
    // Print `e` itself, no need for description().
    eprintln!("Error: {e}");
}

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

Used in conjunction with Request::provide_value and Request::provide_ref to extract references to member variables from dyn Error trait objects.

Example

#![feature(error_generic_member_access)]
#![feature(error_in_core)]
use core::fmt;
use core::error::{request_ref, Request};

#[derive(Debug)]
enum MyLittleTeaPot {
    Empty,
}

#[derive(Debug)]
struct MyBacktrace {
    // ...
}

impl MyBacktrace {
    fn new() -> MyBacktrace {
        // ...
    }
}

#[derive(Debug)]
struct Error {
    backtrace: MyBacktrace,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Example Error")
    }
}

impl std::error::Error for Error {
    fn provide<'a>(&'a self, request: &mut Request<'a>) {
        request
            .provide_ref::<MyBacktrace>(&self.backtrace);
    }
}

fn main() {
    let backtrace = MyBacktrace::new();
    let error = Error { backtrace };
    let dyn_error = &error as &dyn std::error::Error;
    let backtrace_ref = request_ref::<MyBacktrace>(dyn_error).unwrap();

    assert!(core::ptr::eq(&error.backtrace, backtrace_ref));
    assert!(request_ref::<MyLittleTeaPot>(dyn_error).is_none());
}

Implementations

impl dyn Error

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

where T: Error + 'static,

Returns true if the inner type is the same as T.

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

where T: Error + 'static,

Returns some reference to the inner value if it is of type T, or None if it isn’t.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

Returns some mutable reference to the inner value if it is of type T, or None if it isn’t.

impl dyn Error + Send

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

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

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

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

impl dyn Error + Send + Sync

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

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

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

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

impl dyn Error

pub fn sources(&self) -> Source<'_>

🔬This is a nightly-only experimental API. (error_iter)

Returns an iterator starting with the current error and continuing with recursively calling Error::source.

If you want to omit the current error and only use its sources, use skip(1).

Examples

#![feature(error_iter)]
use std::error::Error;
use std::fmt;

#[derive(Debug)]
struct A;

#[derive(Debug)]
struct B(Option<Box<dyn Error + 'static>>);

impl fmt::Display for A {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "A")
    }
}

impl fmt::Display for B {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "B")
    }
}

impl Error for A {}

impl Error for B {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.0.as_ref().map(|e| e.as_ref())
    }
}

let b = B(Some(Box::new(A)));

// let err : Box<Error> = b.into(); // or
let err = &b as &(dyn Error);

let mut iter = err.sources();

assert_eq!("B".to_string(), iter.next().unwrap().to_string());
assert_eq!("A".to_string(), iter.next().unwrap().to_string());
assert!(iter.next().is_none());
assert!(iter.next().is_none());

impl dyn Error + Send

pub fn downcast<T>( self: Box<dyn Error + Send> ) -> Result<Box<T>, Box<dyn Error + Send>>

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

impl dyn Error

pub fn downcast<T>(self: Box<dyn Error>) -> Result<Box<T>, Box<dyn Error>>

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

impl dyn Error + Send + Sync

pub fn downcast<T>( self: Box<dyn Error + Send + Sync> ) -> Result<Box<T>, Box<dyn Error + Send + Sync>>

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

Trait Implementations

impl<'a> From<&str> for Box<dyn Error + 'a>

fn from(err: &str) -> Box<dyn Error + 'a>

Converts a str into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>

Converts a str into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, E> From<E> for Box<dyn Error + 'a>

where E: Error + 'a,

fn from(err: E) -> Box<dyn Error + 'a>

Converts a type of Error into a box of dyn Error.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "An error")
    }
}

impl Error for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a, E> From<E> for Box<dyn Error + Send + Sync + 'a>

where E: Error + Send + Sync + 'a,

fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>

Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "An error")
    }
}

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<String> for Box<dyn Error + 'a>

fn from(str_err: String) -> Box<dyn Error + 'a>

Converts a String into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>

fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>

Converts a String into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl Value for dyn Error

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.

impl Value for dyn Error + Send

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.

impl Value for dyn Error + Send + Sync

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.

impl Value for dyn Error + Sync

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.

Implementors

impl !Error for &str

impl Error for ActionError

impl Error for CloneIdError

impl Error for CounterSigningError

impl Error for EntryError

impl Error for HostFnApiError

impl Error for ScheduleError

impl Error for SecurePrimitiveError

impl Error for TimestampError

impl Error for ZomeError

impl Error for SerializedBytesError

impl Error for Infallible

impl Error for VarError

impl Error for RecvTimeoutError

impl Error for std::sync::mpsc::TryRecvError

impl Error for DecodeError

impl Error for CStrCheckError

impl Error for NonZeroCheckError

impl Error for StrCheckError

impl Error for RoundingError

impl Error for DataValueCastFailure

impl Error for LookupError

impl Error for RegisterMappingError

impl Error for CodegenError

impl Error for SetError

impl Error for gimli::read::Error

impl Error for ConvertError

impl Error for gimli::write::Error

impl Error for HoloHashError

impl Error for GetTimezoneError

impl Error for GossipError

impl Error for leb128::read::Error

impl Error for BernoulliError

impl Error for WeightedError

impl Error for RegAllocError

impl Error for region::error::Error

impl Error for SharedDeserializeMapError

impl Error for OffsetError

impl Error for AllocScratchError

impl Error for SharedSerializeMapError

impl Error for BufferSerializerError

impl Error for FixedSizeScratchError

impl Error for ArchiveError

impl Error for DefaultValidatorError

impl Error for SharedError

impl Error for AsStringError

impl Error for LockError

impl Error for UnixTimestampError

impl Error for rmp_serde::decode::Error

impl Error for rmp_serde::encode::Error

impl Error for BytesReadError

impl Error for NumValueReadError

impl Error for ValueReadError

impl Error for MmapError

impl Error for StatsError

impl Error for url::parser::ParseError

impl Error for wasmer_compiler::engine::error::InstantiationError

impl Error for wasmer_compiler::engine::error::LinkError

impl Error for CompileError

impl Error for DeserializeError

impl Error for ImportError

impl Error for MemoryError

impl Error for ParseCpuFeatureError

impl Error for PreInstantiationError

impl Error for SerializeError

impl Error for wasmer_types::error::WasmError

impl Error for TrapCode

impl Error for WaiterError

impl Error for Trap

impl Error for wasmer::errors::InstantiationError

impl Error for wasmer::errors::LinkError

impl Error for ExportError

impl Error for MemoryAccessError

impl Error for IoCompileError

impl Error for !

impl Error for hdk::prelude::WasmError

impl Error for WrongActionError

impl Error for UnorderedKeyError

impl Error for alloc::collections::TryReserveError

impl Error for FromVecWithNulError

impl Error for IntoStringError

impl Error for NulError

impl Error for FromUtf8Error

impl Error for FromUtf16Error

impl Error for LayoutError

impl Error for AllocError

impl Error for TryFromSliceError

impl Error for BorrowError

impl Error for BorrowMutError

impl Error for CharTryFromError

impl Error for ParseCharError

impl Error for DecodeUtf16Error

impl Error for TryFromCharError

impl Error for FromBytesUntilNulError

impl Error for FromBytesWithNulError

impl Error for core::fmt::Error

impl Error for AddrParseError

impl Error for ParseFloatError

impl Error for ParseIntError

impl Error for TryFromIntError

impl Error for ParseBoolError

impl Error for core::str::error::Utf8Error

impl Error for TryFromFloatSecsError

impl Error for JoinPathsError

impl Error for WriterPanicked

impl Error for std::io::error::Error

impl Error for StripPrefixError

impl Error for ExitStatusError

impl Error for RecvError

impl Error for AccessError

impl Error for SystemTimeError

impl Error for BoolCheckError

impl Error for CharCheckError

impl Error for StructCheckError

impl Error for TupleStructCheckError

impl Error for chrono::format::ParseError

impl Error for ParseMonthError

impl Error for OutOfRange

impl Error for OutOfRangeError

impl Error for ParseWeekdayError

impl Error for VerifierError

impl Error for VerifierErrors

impl Error for futures_channel::mpsc::SendError

impl Error for futures_channel::mpsc::TryRecvError

impl Error for Canceled

impl Error for EnterError

impl Error for SpawnError

impl Error for Aborted

impl Error for getrandom::error::Error

impl Error for Errors

impl Error for indexmap::TryReserveError

impl Error for ReadError

impl Error for rand_core::error::Error

impl Error for ThreadPoolBuildError

impl Error for serde_json::error::Error

impl Error for simdutf8::basic::Utf8Error

impl Error for simdutf8::compat::Utf8Error

impl Error for SetGlobalDefaultError

impl Error for ParseLevelError

impl Error for ParseLevelFilterError

impl Error for MiddlewareError

impl Error for PageCountOutOfRange

impl Error for RuntimeError

impl Error for BinaryReaderError

impl Error for wast::error::Error

impl Error for wat::Error

impl Error for hdk::prelude::holochain_serialized_bytes::serde::de::value::Error

impl<'a, E> Error for DecodeStringError<'a, E>

where E: RmpReadErr,

impl<'a, K, V> Error for alloc::collections::btree::map::entry::OccupiedError<'a, K, V>

where K: Debug + Ord, V: Debug,

impl<'a, K, V> Error for std::collections::hash::map::OccupiedError<'a, K, V>

where K: Debug, V: Debug,

impl<'a, T> Error for &'a T

where T: Error + ?Sized,

impl<C> Error for HashIndexError<C>

where C: Error + 'static,

impl<C, D> Error for CheckDeserializeError<C, D>

where C: Error + 'static, D: Error + 'static,

impl<E> Error for ValueWriteError<E>

where E: RmpWriteErr,

impl<K, V> Error for LeafNodeEntryError<K, V>

where K: Error + 'static, V: Error + 'static,

impl<K, V> Error for ArchivedEntryError<K, V>

where K: Error + 'static, V: Error + 'static,

impl<K, V, C> Error for ArchivedBTreeMapError<K, V, C>

where K: Error + 'static, V: Error + 'static, C: Error + 'static,

impl<K, V, C> Error for HashMapError<K, V, C>

where K: Error + 'static, V: Error + 'static, C: Error + 'static,

impl<K, V, C> Error for IndexMapError<K, V, C>

where K: Error + 'static, V: Error + 'static, C: Error + 'static,

impl<S, C, H> Error for CompositeSerializerError<S, C, H>

where S: Error + 'static, C: Error + 'static, H: Error + 'static,

impl<T0> Error for Tuple1CheckError<T0>

where T0: Display + Debug,

impl<T1, T0> Error for Tuple2CheckError<T1, T0>

where T1: Display + Debug, T0: Display + Debug,

impl<T2, T1, T0> Error for Tuple3CheckError<T2, T1, T0>

where T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T3, T2, T1, T0> Error for Tuple4CheckError<T3, T2, T1, T0>

where T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T4, T3, T2, T1, T0> Error for Tuple5CheckError<T4, T3, T2, T1, T0>

where T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T5, T4, T3, T2, T1, T0> Error for Tuple6CheckError<T5, T4, T3, T2, T1, T0>

where T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T6, T5, T4, T3, T2, T1, T0> Error for Tuple7CheckError<T6, T5, T4, T3, T2, T1, T0>

where T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T7, T6, T5, T4, T3, T2, T1, T0> Error for Tuple8CheckError<T7, T6, T5, T4, T3, T2, T1, T0>

where T7: Display + Debug, T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T8, T7, T6, T5, T4, T3, T2, T1, T0> Error for Tuple9CheckError<T8, T7, T6, T5, T4, T3, T2, T1, T0>

where T8: Display + Debug, T7: Display + Debug, T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Error for Tuple10CheckError<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>

where T9: Display + Debug, T8: Display + Debug, T7: Display + Debug, T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Error for Tuple11CheckError<T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>

where T10: Display + Debug, T9: Display + Debug, T8: Display + Debug, T7: Display + Debug, T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Error for Tuple12CheckError<T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>

where T11: Display + Debug, T10: Display + Debug, T9: Display + Debug, T8: Display + Debug, T7: Display + Debug, T6: Display + Debug, T5: Display + Debug, T4: Display + Debug, T3: Display + Debug, T2: Display + Debug, T1: Display + Debug, T0: Display + Debug,

impl<T> Error for std::sync::mpsc::TrySendError<T>

impl<T> Error for TryLockError<T>

impl<T> Error for EnumCheckError<T>

where T: Debug + Display,

impl<T> Error for SliceCheckError<T>

where T: Debug + Display,

impl<T> Error for Box<T>

where T: Error,

impl<T> Error for ThinBox<T>

where T: Error + ?Sized,

impl<T> Error for Arc<T>

where T: Error + ?Sized,

impl<T> Error for std::sync::mpsc::SendError<T>

impl<T> Error for PoisonError<T>

impl<T> Error for CapacityError<T>

where T: Any,

Requires features="std".

impl<T> Error for ArrayCheckError<T>

where T: Debug + Display,

impl<T> Error for futures_channel::mpsc::TrySendError<T>

where T: Any,

impl<T> Error for futures_util::io::split::ReuniteError<T>

where T: Any,

impl<T, C> Error for CheckArchiveError<T, C>

where T: Error + 'static, C: Error + 'static,

impl<T, E> Error for TryChunksError<T, E>

where E: Debug + Display,

impl<T, E> Error for TryReadyChunksError<T, E>

where E: Debug + Display,

impl<T, Item> Error for futures_util::stream::stream::split::ReuniteError<T, Item>

where T: Any,

impl<T, R, C> Error for SharedPointerError<T, R, C>

where T: Error + 'static, R: Error + 'static, C: Error + 'static,

impl<T, R, C> Error for WeakPointerError<T, R, C>

where T: Error + 'static, R: Error + 'static, C: Error + 'static,

impl<T, R, C> Error for OwnedPointerError<T, R, C>

where T: Error + 'static, R: Error + 'static, C: Error + 'static,

impl<W> Error for IntoInnerError<W>

where W: Send + Debug,

impl<const N: usize> Error for GetManyMutError<N>