Struct xitca_web::error::Error

pub struct Error<C = ()>(/* 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>) {
    // construct error object.
    let e = Error::<C>::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 and downcast to concrete error type again.
    // *. trait upcast is a nightly feature.
    // see https://github.com/rust-lang/rust/issues/65991 for detail
     
    // let e = &*e as &dyn error::Error;
    // assert!(e.downcast_ref::<Foo>().is_some());
}

Implementations

impl<C> Error<C>

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

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

Trait Implementations

impl<C> Debug for Error<C>

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

Formats the value using the given formatter.

impl<C> Deref for Error<C>

type Target = dyn for<'r> ErrorService<WebContext<'r, C>, Response = Response<ResponseBody>, Error = Infallible>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C> DerefMut for Error<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C> Display for Error<C>

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

Formats the value using the given formatter.

impl<C> Error for Error<C>

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

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<C> From<BodyOverFlow> for Error<C>

fn from(e: BodyOverFlow) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<C> From<EncodingError> for Error<C>

fn from(e: EncodingError) -> Self

Converts to this type from the input type.

impl<C> From<Error> for Error<C>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl<C> From<Error> for Error<C>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl<C> From<Error> for Error<C>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl<C> From<Error> for Error<C>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl<C> From<ErrorStatus> for Error<C>

fn from(e: ErrorStatus) -> Self

Converts to this type from the input type.

impl<C> From<ExtensionNotFound> for Error<C>

fn from(e: ExtensionNotFound) -> Self

Converts to this type from the input type.

impl<C> From<HeaderNotFound> for Error<C>

fn from(e: HeaderNotFound) -> Self

Converts to this type from the input type.

impl<C> From<Infallible> for Error<C>

fn from(e: Infallible) -> Self

Converts to this type from the input type.

impl<C> From<InvalidHeaderValue> for Error<C>

fn from(e: InvalidHeaderValue) -> Self

Converts to this type from the input type.

impl<C> From<MatchError> for Error<C>

fn from(e: MatchError) -> Self

Converts to this type from the input type.

impl<C> From<MethodNotAllowed> for Error<C>

fn from(e: MethodNotAllowed) -> Self

Converts to this type from the input type.

impl<C> From<ParseError> for Error<C>

fn from(e: ParseError) -> Self

Converts to this type from the input type.

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

where E: Into<Error<C>>,

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

Converts to this type from the input type.

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

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

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

Converts to this type from the input type.

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

where E: Into<Self>,

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

Converts to this type from the input type.

impl<C> From<StatusCode> for Error<C>

fn from(e: StatusCode) -> Self

Converts to this type from the input type.

impl<C> From<StdError> for Error<C>

fn from(e: StdError) -> Self

Converts to this type from the input type.

impl<C> From<ThreadJoinError> for Error<C>

fn from(e: ThreadJoinError) -> Self

Converts to this type from the input type.

impl<C> From<ToStrError> for Error<C>

fn from(e: ToStrError) -> Self

Converts to this type from the input type.

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

type Response = Response<ResponseBody>

type Error = Error<C>

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<C>

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>