pub struct Request<'a> { /* private fields */ }
Expand description
container for dynamic type provided by Error’s default Service impl
Implementations§
Source§impl Request<'_>
impl Request<'_>
Sourcepub fn request_ref<C>(&self) -> Option<&C>where
C: 'static,
pub fn request_ref<C>(&self) -> Option<&C>where
C: 'static,
request a reference of concrete type from dynamic container. Error would provide your application’s global state to it.
§Examples
use std::{convert::Infallible, fmt};
use xitca_web::{
error::{Error, Request},
handler::handler_service,
http::WebResponse,
service::Service,
App, WebContext
};
let app = App::new()
.at("/", handler_service(handler))
.with_state(String::from("996")); // application has a root state of String type.
// handler function returns custom error type
async fn handler(_: &WebContext<'_, String>) -> Result<&'static str, MyError> {
Err(MyError)
}
// a self defined error type and necessary error implements.
#[derive(Debug)]
struct MyError;
impl fmt::Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("my error")
}
}
impl std::error::Error for MyError {}
impl From<MyError> for Error {
fn from(e: MyError) -> Self {
Self::from_service(e)
}
}
// Assuming application state is needed in error handler then this is the Service impl
// you want to write
impl<'r> Service<WebContext<'r, Request<'r>>> for MyError {
type Response = WebResponse;
type Error = Infallible;
async fn call(&self, ctx: WebContext<'r, Request<'r>>) -> Result<Self::Response, Self::Error> {
// error::Request is able to provide application's state reference with runtime type casting.
if let Some(state) = ctx.state().request_ref::<String>() {
assert_eq!(state, "996");
}
todo!()
}
}
Auto Trait Implementations§
impl<'a> Freeze for Request<'a>
impl<'a> !RefUnwindSafe for Request<'a>
impl<'a> !Send for Request<'a>
impl<'a> !Sync for Request<'a>
impl<'a> Unpin for Request<'a>
impl<'a> !UnwindSafe for Request<'a>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more