Struct Error

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

type erased error object. can be used for dynamic access to error’s debug/display info. it also support upcasting and downcasting.

Examples:

use std::{convert::Infallible, error, fmt};

use xitca_web::{error::Error, http::WebResponse, service::Service, WebContext};

// concrete error type
#[derive(Debug)]
struct Foo;

// implement debug and display format.
impl fmt::Display for Foo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("Foo")
    }
}

// implement Error trait
impl error::Error for Foo {}

// implement Service trait for http response generating.
impl<'r, C> Service<WebContext<'r, C>> for Foo {
    type Response = WebResponse;
    type Error = Infallible;

    async fn call(&self, _: WebContext<'r, C>) -> Result<Self::Response, Self::Error> {
        Ok(WebResponse::default())
    }
}

async fn handle_error<C>(ctx: WebContext<'_, C>) where C: 'static {
    // construct error object.
    let e = Error::from_service(Foo);

    // format and display error
    println!("{e:?}");
    println!("{e}");

    // generate http response.
    let res = Service::call(&e, ctx).await.unwrap();
    assert_eq!(res.status().as_u16(), 200);

    // upcast error to trait object of std::error::Error
    let e = e.upcast();
     
    // downcast error object to concrete type again
    assert!(e.downcast_ref::<Foo>().is_some());
}

Implementations

impl Error

pub fn from_service<S>(s: S) -> Self

where S: for<'r> Service<WebContext<'r, Request<'r>>, Response = WebResponse, Error = Infallible> + Error + Send + Sync + 'static,

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

upcast Error to trait object for advanced error handling. See std::error::Error for usage

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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.

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

impl From<BodyOverFlow> for Error

fn from(e: BodyOverFlow) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<EncodingError> for Error

fn from(e: EncodingError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<ErrorStatus> for Error

fn from(e: ErrorStatus) -> Self

Converts to this type from the input type.

impl From<ExtensionNotFound> for Error

fn from(e: ExtensionNotFound) -> Self

Converts to this type from the input type.

impl From<HeaderNotFound> for Error

fn from(e: HeaderNotFound) -> Self

Converts to this type from the input type.

impl From<Infallible> for Error

fn from(e: Infallible) -> Self

Converts to this type from the input type.

impl From<InvalidHeaderValue> for Error

fn from(e: InvalidHeaderValue) -> Self

Converts to this type from the input type.

impl From<MatchError> for Error

fn from(e: MatchError) -> Self

Converts to this type from the input type.

impl From<MethodNotAllowed> for Error

fn from(e: MethodNotAllowed) -> Self

Converts to this type from the input type.

impl From<ParseError> for Error

fn from(e: ParseError) -> Self

Converts to this type from the input type.

impl<E> From<Pipeline<Box<dyn Any + Send>, E>> for Error

where E: Into<Error>,

fn from(e: CatchUnwindError<E>) -> Self

Converts to this type from the input type.

impl<F, S> From<Pipeline<F, S>> for Error

where F: Into<Error>, S: Into<Error>,

fn from(pipe: PipelineE<F, S>) -> Self

Converts to this type from the input type.

impl<E> From<RouterError<E>> for Error

where E: Into<Self>,

fn from(e: RouterError<E>) -> Self

Converts to this type from the input type.

impl From<StatusCode> for Error

fn from(e: StatusCode) -> Self

Converts to this type from the input type.

impl From<ThreadJoinError> for Error

fn from(e: ThreadJoinError) -> Self

Converts to this type from the input type.

impl From<ToStrError> for Error

fn from(e: ToStrError) -> Self

Converts to this type from the input type.

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Error

type Response = Response<ResponseBody>

type Error = Error

async fn respond( self, _: WebContext<'r, C, B>, ) -> Result<Self::Response, Self::Error>

generate response from given request.

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

where Self: Sized,

map response type and mutate it’s state. default to pass through without any modification.

impl<'r, C> Service<WebContext<'r, C>> for Error

where C: 'static,

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Infallible

The Err part of output future.

async fn call( &self, ctx: WebContext<'r, C>, ) -> Result<Self::Response, Self::Error>