Struct HttpWhatever

pub struct HttpWhatever { /* private fields */ }

An almost-drop-in replacement for snafu::Whatever with the following benefits:

• Conforms to the async magic incantation Send + Sync + 'static and so is thread-safe and async-safe
• Can be transformed into an http::Response using information from the error to complete the response
• A public new constructor that facilitates better ergonomics in certain error situations.
• A public parts method to retrieve the three parts of the error.

Otherwise it is exactly the same as snafu::Whatever and can be used in exactly the same way.

(almost-drop-in because, obviously, you have to use HttpWhatever as your error type).

Implementations

impl HttpWhatever

pub fn parts(&self) -> (&str, &str, StatusCode)

Return the three parts of the message as a 3-element tuple.

The three parts are

• The message as a string slice
• the domain as a string slice
• the HTTP status code as a http::StatusCode

This method is useful if you wish to construct a customized response from the error, but still want the categorization that this error type allows.

pub fn details(&self) -> String

Return a String that provides the to_string() output of this error and all nested sources.

pub fn as_http_response<B>(&self) -> Response<B>

where B: Default,

Return an http::Response<B> representation of the error, with a body generated from the default method of the generic body type.

Panics

Technically the function will panic if, internally, it cannot build the response, but since the parts of the response are already verified, and the Body is only created with B::default(), that isn’t actually possible.

pub fn as_http_string_response<B>(&self) -> Response<B>

where B: From<String>,

Return an http::Response<B> representation of the error, with a string body generated from the into method of the generic body type.

The string in the response body will be of the format

<message> (application domain: <domain>)

The content-type header of the response will be text/plain.

Panics

Technically the function will panic if, internally, it cannot build the response, but since the parts of the response are already verified, and the Body is only created with B::from(String), that isn’t actually possible.

pub fn as_http_json_response<B>(&self) -> Response<B>

where B: From<String>,

Return an http::Response<B> representation of the error, with a JSON body generated from the into method.

The string in the response body will be of the format

{"message":"<message>","domain":"<domain>"}

The content-type header of the response will be application/json.

Panics

Technically the function will panic if, internally, it cannot build the response, but since the parts of the response are already verified, and the Body is only created with B::from(String), that isn’t actually possible.

pub fn new(message: impl Display) -> Self

Create a new HttpWhatever from the input string.

The input string should conform to the structure documented in the crate documentation.

Trait Implementations

impl Debug for HttpWhatever

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

Formats the value using the given formatter.

impl Display for HttpWhatever

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

Formats the value using the given formatter.

impl Error for HttpWhatever

where Self: Debug + Display,

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 source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

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 ErrorCompat for HttpWhatever

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

fn iter_chain(&self) -> ChainCompat<'_, '_>

where Self: AsErrorSource,

Returns an iterator for traversing the chain of errors, starting with the current error and continuing with recursive calls to Error::source.

impl FromString for HttpWhatever

type Source = Box<dyn Error + Sync + Send>

The underlying error

fn without_source(message: String) -> Self

Create a brand new error from the given string

fn with_source(error: Self::Source, message: String) -> Self

Wrap an existing error with the given string