Trait bdk_chain::bitcoin::hashes::serde::ser::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 + Sync + 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

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 + Sync + Send

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

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

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.

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 + Sync + Send + 'a>

fn from(err: &str) -> Box<dyn Error + Sync + Send + '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 + Sync + Send + 'a>

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

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

fn from(err: E) -> Box<dyn Error + Sync + Send + '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 + Sync + Send + 'a>

fn from(err: String) -> Box<dyn Error + Sync + Send + '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))

Implementors

impl !Error for &str

impl Error for ApplyHeaderError

impl Error for CalculateFeeError

impl Error for FromScriptError

impl Error for P2shError

impl Error for bdk_chain::bitcoin::address::ParseError

impl Error for ParseAmountError

impl Error for bdk_chain::bitcoin::base58::Error

impl Error for ParseAlphabetError

impl Error for bdk_chain::bitcoin::base64::DecodeError

impl Error for DecodeSliceError

impl Error for EncodeSliceError

impl Error for bdk_chain::bitcoin::bip32::Error

impl Error for bdk_chain::bitcoin::bip152::Error

impl Error for bdk_chain::bitcoin::bip158::Error

impl Error for Bip34Error

impl Error for ValidationError

impl Error for bdk_chain::bitcoin::blockdata::script::Error

impl Error for bdk_chain::bitcoin::blockdata::script::witness_program::Error

impl Error for FromStrError

impl Error for TryFromInstructionError

impl Error for ParseOutPointError

impl Error for bdk_chain::bitcoin::consensus::encode::Error

impl Error for FromHexError

impl Error for bdk_chain::bitcoin::ecdsa::Error

impl Error for PrefixedHexError

impl Error for UnprefixedHexError

impl Error for bdk_chain::bitcoin::key::FromSliceError

impl Error for FromWifError

impl Error for ParseCompressedPublicKeyError

impl Error for ParsePublicKeyError

impl Error for MerkleBlockError

impl Error for bdk_chain::bitcoin::psbt::Error

impl Error for ExtractTxError

impl Error for GetKeyError

impl Error for bdk_chain::bitcoin::psbt::IndexOutOfBoundsError

impl Error for PsbtParseError

impl Error for SignError

impl Error for bdk_chain::bitcoin::secp256k1::Error

impl Error for BernoulliError

impl Error for WeightedError

impl Error for AnnexError

impl Error for P2wpkhError

impl Error for PrevoutsIndexError

impl Error for bdk_chain::bitcoin::sighash::TaprootError

impl Error for MessageSignatureError

impl Error for HiddenNodesError

impl Error for IncompleteBuilderError

impl Error for SigFromSliceError

impl Error for TaprootBuilderError

impl Error for bdk_chain::bitcoin::taproot::TaprootError

impl Error for HexToArrayError

impl Error for HexToBytesError

impl Error for Infallible

impl Error for VarError

impl Error for RecvTimeoutError

impl Error for TryRecvError

impl Error for !

impl Error for AlterCheckPointError

impl Error for CannotConnectError

impl Error for MissingGenesisError

impl Error for bdk_chain::bitcoin::address::InvalidBase58PayloadLengthError

impl Error for InvalidLegacyPrefixError

impl Error for LegacyAddressTooLongError

impl Error for NetworkValidationError

impl Error for UnknownAddressTypeError

impl Error for UnknownHrpError

impl Error for IncorrectChecksumError

impl Error for TooShortError

impl Error for bdk_chain::bitcoin::base58::InvalidCharacterError

impl Error for bdk_chain::bitcoin::bip32::InvalidBase58PayloadLengthError

impl Error for TxIndexOutOfRangeError

impl Error for bdk_chain::bitcoin::blockdata::locktime::absolute::ConversionError

impl Error for ParseHeightError

impl Error for ParseTimeError

impl Error for DisabledLockTimeError

impl Error for IncompatibleHeightError

impl Error for IncompatibleTimeError

impl Error for TimeOverflowError

impl Error for PushBytesError

impl Error for bdk_chain::bitcoin::blockdata::script::witness_version::TryFromError

impl Error for bdk_chain::bitcoin::blockdata::transaction::IndexOutOfBoundsError

impl Error for InputsIndexError

impl Error for OutputsIndexError

impl Error for ContainsPrefixError

impl Error for MissingPrefixError

impl Error for bdk_chain::bitcoin::io::Error

impl Error for InvalidAddressVersionError

impl Error for bdk_chain::bitcoin::key::InvalidBase58PayloadLengthError

impl Error for UncompressedPublicKeyError

impl Error for ParseNetworkError

impl Error for UnknownChainHashError

impl Error for CommandStringError

impl Error for ParseMagicError

impl Error for UnknownMagicError

impl Error for bdk_chain::bitcoin::parse::ParseIntError

impl Error for bdk_chain::bitcoin::secp256k1::hashes::FromSliceError

impl Error for ReadError

impl Error for bdk_chain::bitcoin::secp256k1::rand::Error

impl Error for bdk_chain::bitcoin::secp256k1::scalar::OutOfRangeError

impl Error for InvalidParityValue

impl Error for InvalidSighashTypeError

impl Error for NonStandardSighashTypeError

impl Error for PrevoutsKindError

impl Error for PrevoutsSizeError

impl Error for SighashTypeParseError

impl Error for SingleMissingOutputError

impl Error for InvalidLengthError

impl Error for InvalidCharError

impl Error for OddLengthStringError

impl Error for bdk_chain::bitcoin::hashes::serde::de::value::Error

impl Error for UnorderedKeyError

impl Error for 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 core::num::error::ParseIntError

impl Error for TryFromIntError

impl Error for ParseBoolError

impl Error for 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 getrandom::error::Error

impl Error for serde_json::error::Error

impl Error for AbsLockTimeError

impl Error for AnalysisError

impl Error for CharError

impl Error for CheckedHrpstringError

impl Error for ChecksumError

impl Error for CodeLengthError

impl Error for ConversionError

impl Error for DecodeError

impl Error for DecodeError

impl Error for DescriptorKeyParseError

impl Error for EncodeError

impl Error for EncodeError

impl Error for EncodeIoError

impl Error for Error

impl Error for Error

impl Error for Error

impl Error for Error

impl Error for Error

impl Error for Error

impl Error for Error

impl Error for FromCharError

impl Error for FromSqlError

impl Error for InputError

impl Error for InputTooLargeError

impl Error for InvalidCharacterError

impl Error for InvalidWitnessVersionError

impl Error for KeyParseError

impl Error for LiftError

impl Error for MissingDigitsError

impl Error for OutOfRangeError

impl Error for OutputUpdateError

impl Error for PaddingError

impl Error for ParseDenominationError

impl Error for ParseError

impl Error for ParseError

impl Error for ParseThresholdError

impl Error for PolicyError

impl Error for PossiblyConfusingDenominationError

impl Error for RelLockTimeError

impl Error for SegwitCodeLengthError

impl Error for SegwitHrpstringError

impl Error for SighashError

impl Error for ThresholdError

impl Error for TooPreciseError

impl Error for TryFromError

impl Error for UncheckedHrpstringError

impl Error for UnknownDenominationError

impl Error for UtxoUpdateError

impl Error for WitnessLengthError

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<E> Error for bdk_chain::bitcoin::consensus::DecodeError<E>

where E: Debug,

impl<E> Error for SigningDataError<E>

where E: Error + 'static,

impl<K: Debug> Error for InsertDescriptorError<K>

impl<T> Error for TrySendError<T>

impl<T> Error for TryLockError<T>

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 SendError<T>

impl<T> Error for PoisonError<T>

impl<W> Error for IntoInnerError<W>

where W: Send + Debug,

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