breez_sdk_liquid::lightning_125::bitcoin::hashes::serde::ser

Trait StdError

1.0.0 · Source

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>) { ... }
}

Expand description

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§

1.30.0 · Source

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

Returns 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"),
    }
}

1.0.0 · Source

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}");
}

1.0.0 · Source

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

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

Source

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)]
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());
}

Trait StdErrorCopy item path

Provided Methods§

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

§Examples

fn description(&self) -> &str

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

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

§Example

Implementations§

impl dyn Error

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error + Send

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error + Sync + Send

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error

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

§Examples

impl dyn Error

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

impl dyn Error + Send

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

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,

Trait Implementations§

impl AsRef<dyn Error> for Error

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

impl AsRef<dyn Error + Sync + Send> for Error

fn as_ref(&self) -> &(dyn Error + Sync + Send + 'static)

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

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

§Examples

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

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

§Examples

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

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

§Examples

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>

§Examples

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

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

§Examples

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>

§Examples

impl From<Error> for Box<dyn Error>

fn from(error: Error) -> Box<dyn Error>

impl From<Error> for Box<dyn Error + Send>

fn from(error: Error) -> Box<dyn Error + Send>

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

fn from(error: Error) -> Box<dyn Error + Sync + Send>

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

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

§Examples

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

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

§Examples

impl Value for dyn Error

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

impl Value for dyn Error + Send

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

impl Value for dyn Error + Sync + Send

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

impl Value for dyn Error + Sync

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

Implementors§

impl !Error for &str

impl Error for breez_sdk_liquid::bitcoin::bech32::Error

impl Error for breez_sdk_liquid::bitcoin::blockdata::block::Bip34Error

impl Error for breez_sdk_liquid::bitcoin::blockdata::locktime::Error

impl Error for breez_sdk_liquid::bitcoin::blockdata::locktime::OperationError

impl Error for breez_sdk_liquid::bitcoin::blockdata::script::Error

Trait StdError

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

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

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

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

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

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