Struct HttpError

pub struct HttpError { /* private fields */ }

HttpError is an error that encapsulates data to generate Http error responses.

Implementations

impl HttpError

pub const fn new() -> Self

Creates an empty HttpError with status 500.

pub const fn from_static(status_code: StatusCode, reason: &'static str) -> Self

Creates a HttpError with status code and reason. This constructor can be evaluated at compile time.

use anyhow_http::HttpError;

const BAD_REQUEST: HttpError =
    HttpError::from_static(http::StatusCode::BAD_REQUEST, "invalid request");

pub const fn from_status_code(status_code: StatusCode) -> Self

Creates a HttpError from a status code.

pub const fn with_status_code(self, status_code: StatusCode) -> Self

Sets the status code.

pub fn with_reason<S: Into<Cow<'static, str>>>(self, reason: S) -> Self

Sets the error reason.

pub fn with_source_context<C>(self, context: C) -> Self

where C: Display + Send + Sync + 'static,

Adds context to the source error. If no source is availabe a new anyhow::Error is created in its place.

pub fn with_boxed_source_err( self, err: Box<dyn StdError + Send + Sync + 'static>, ) -> Self

Set the source error from a generic error trait object.

pub fn with_source_err<E>(self, err: E) -> Self

where E: Into<Error>,

Set the source error from a generic error.

pub fn with_data<I, K, V>(self, values: I) -> Option<Self>

where I: IntoIterator<Item = (K, V)>, K: Into<String>, V: Serialize + Sync + Send + 'static,

Append to to the inner data based on one or more key-value pairs.

use anyhow_http::HttpError;

let err: HttpError = HttpError::default()
    .with_data([("key1", 1234), ("key2", 5678)])
    .unwrap();

pub fn with_key_value<K, V>(self, key: K, value: V) -> Self

where K: Into<String>, V: Serialize + Sync + Send + 'static,

Adds a key-pair value to the inner data.

pub fn with_header<K>(self, header_key: K, header_value: HeaderValue) -> Self

where K: IntoHeaderName,

pub fn get<V>(&self, key: impl AsRef<str>) -> Option<V>

where V: DeserializeOwned + Send + Sync,

Retrieves a key-pair value from the inner data.

pub fn set<K, V>(&mut self, key: K, value: V) -> Result<()>

where K: Into<String>, V: Serialize + Sync + Send + 'static,

Sets a key-pair value pair into the inner data.

pub fn status_code(&self) -> StatusCode

Returns the status code.

pub fn reason(&self) -> Option<Cow<'static, str>>

Returns the error reason if any.

pub fn source(&self) -> Option<&Error>

Returns the source error if any.

pub fn headers(&self) -> Option<&HeaderMap>

Returns the error response headers if any.

pub fn from_err<E>(err: E) -> Self

where E: Into<Error>,

Creates a HttpError from a generic error. It attempts to downcast to an underlying HttpError.

pub fn into_boxed(self) -> Box<dyn StdError + Send + Sync + 'static>

Trait Implementations

impl Debug for HttpError

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

Formats the value using the given formatter.

impl Default for HttpError

fn default() -> Self

Returns the “default value” for a type.

impl Display for HttpError

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

Formats the value using the given formatter.

impl Error for HttpError

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

Returns 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<Error> for HttpError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl PartialEq for HttpError

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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