Struct lair_keystore::dependencies::one_err::OneErr

pub struct OneErr(/* private fields */);

OneErr to rule them all. See crate docs for usage.

Implementations

impl OneErr

pub fn new<K>(kind: K) -> OneErr

where K: Display,

Create a new OneErr error instance.

pub fn with_message<K, M>(kind: K, message: M) -> OneErr

where K: Display, M: Display,

Create a new OneErr error instance with a message.

pub fn io_kind(&self) -> ErrorKind

Get the std::io::ErrorKind associated with this instance.

pub fn errno(&self) -> ErrNo

Get the ErrNo associated with this instance, if any.

pub fn str_kind(&self) -> &str

Get the &str kind associated with this instance. This can be more descriptive where io_kind() or errno() might return ‘Other’.

pub fn as_io(&self) -> &Error

Get a reference to the inner std::io::Error of this instance.

pub fn set_field<K, T>(&mut self, name: &K, t: T) -> &mut OneErr

where K: Display + ?Sized, T: Into<Value>,

Set an additional data field on this OneErr. Will panic on reserved names: “error”, “os”, “source”, “backtrace”, “message”.

pub fn get_message(&self) -> Option<&str>

Get the message associated with this instance, or empty string.

pub fn get_field<'lt, R, V>(&'lt self, name: R) -> Option<V>

where R: AsRef<str>, Option<V>: From<&'lt Value>,

Get the value of an additional field associated with this error, or None if no such field exists. Valid output types: &str, bool, i64, u64, and f64.

Methods from Deref<Target = Error>

pub fn raw_os_error(&self) -> Option<i32>

Returns the OS error that this error represents (if any).

If this Error was constructed via last_os_error or from_raw_os_error, then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};

fn print_os_error(err: &Error) {
    if let Some(raw_os_err) = err.raw_os_error() {
        println!("raw OS error: {raw_os_err:?}");
    } else {
        println!("Not an OS error");
    }
}

fn main() {
    // Will print "raw OS error: ...".
    print_os_error(&Error::last_os_error());
    // Will print "Not an OS error".
    print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn get_ref(&self) -> Option<&(dyn Error + Sync + Send + 'static)>

Returns a reference to the inner error wrapped by this error (if any).

If this Error was constructed via new then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: &Error) {
    if let Some(inner_err) = err.get_ref() {
        println!("Inner error: {inner_err:?}");
    } else {
        println!("No inner error");
    }
}

fn main() {
    // Will print "No inner error".
    print_error(&Error::last_os_error());
    // Will print "Inner error: ...".
    print_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn kind(&self) -> ErrorKind

Returns the corresponding ErrorKind for this error.

This may be a value set by Rust code constructing custom io::Errors, or if this io::Error was sourced from the operating system, it will be a value inferred from the system’s error encoding. See last_os_error for more details.

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: Error) {
    println!("{:?}", err.kind());
}

fn main() {
    // As no error has (visibly) occurred, this may print anything!
    // It likely prints a placeholder for unidentified (non-)errors.
    print_error(Error::last_os_error());
    // Will print "AddrInUse".
    print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
}

Trait Implementations

impl AsRef<Error> for OneErr

fn as_ref(&self) -> &Error

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for OneErr

fn clone(&self) -> OneErr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OneErr

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

Formats the value using the given formatter.

impl Deref for OneErr

type Target = Error

The resulting type after dereferencing.

fn deref(&self) -> &<OneErr as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for OneErr

fn deserialize<D>( deserializer: D, ) -> Result<OneErr, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OneErr

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

Formats the value using the given formatter.

impl Error for OneErr

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

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

fn description(&self) -> &str

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

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.

impl From<&OneErr> for Error

fn from(e: &OneErr) -> Error

Converts to this type from the input type.

impl From<&OneErr> for SodokenErrKind

fn from(e: &OneErr) -> SodokenErrKind

Converts to this type from the input type.

impl From<&String> for OneErr

fn from(s: &String) -> OneErr

Converts to this type from the input type.

impl From<&str> for OneErr

fn from(s: &str) -> OneErr

Converts to this type from the input type.

impl From<()> for OneErr

fn from(_: ()) -> OneErr

Converts to this type from the input type.

impl From<ErrNo> for OneErr

fn from(e: ErrNo) -> OneErr

Converts to this type from the input type.

impl From<Error> for OneErr

fn from(e: Error) -> OneErr

Converts to this type from the input type.

impl From<ErrorKind> for OneErr

fn from(k: ErrorKind) -> OneErr

Converts to this type from the input type.

impl From<OneErr> for Error

fn from(e: OneErr) -> Error

Converts to this type from the input type.

impl From<SodokenErrKind> for OneErr

fn from(k: SodokenErrKind) -> OneErr

Converts to this type from the input type.

impl From<String> for OneErr

fn from(s: String) -> OneErr

Converts to this type from the input type.

impl From<i32> for OneErr

fn from(e: i32) -> OneErr

Converts to this type from the input type.

impl FromStr for OneErr

type Err = OneErr

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<OneErr, <OneErr as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for OneErr

fn eq(&self, oth: &OneErr) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OneErr

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OneErr