Struct xitca_web::WebContext

impl<'a, C, B> WebContext<'a, C, B>

pub fn reborrow(&mut self) -> WebContext<'_, C, B>

Reborrow Self so the ownership of WebRequest is not lost.

§Note:

Reborrow is not pure and receiver of it can mutate Self in any way they like.

§Example:

// a function need ownership of request but not return it in output.
fn handler(req: WebContext<'_>) -> Result<(), ()> {
    Err(())
}

// use reborrow to avoid pass request by value.
match handler(req.reborrow()) {
    // still able to access request after handler return.
    Ok(_) => assert_eq!(req.state(), &()),
    Err(_) => assert_eq!(req.state(), &())
}

pub fn state(&self) -> &C

Get an immutable reference of App state

pub fn req(&self) -> &WebRequest<()>

Get an immutable reference of WebRequest

pub fn req_mut(&mut self) -> &mut WebRequest<()>

Get a mutable reference of WebRequest

pub fn body(&self) -> Ref<'_, B>

Get a immutable reference of RequestBody

pub fn body_borrow_mut(&self) -> RefMut<'_, B>

Get a mutable reference of RequestBody

pub fn body_get_mut(&mut self) -> &mut B

Get a mutable reference of RequestBody This API takes &mut WebRequest so it bypass runtime borrow checker and therefore has zero runtime overhead.

pub fn take_request(&mut self) -> WebRequest
where B: Default,

pub fn into_response<ResB: Into<ResponseBody>>(self, body: ResB) -> WebResponse

Transform self to a WebResponse with given body type.

The heap allocation of request would be re-used.

pub fn as_response<ResB: Into<ResponseBody>>( &mut self, body: ResB ) -> WebResponse

Transform &mut self to a WebResponse with given body type.

The heap allocation of request would be re-used.

Trait Implementations§

impl<C, B, T> BorrowReq<T> for WebContext<'_, C, B>
where Request<RequestExt<()>>: BorrowReq<T>,

fn borrow(&self) -> &T

impl<C, B, T> BorrowReqMut<T> for WebContext<'_, C, B>
where Request<RequestExt<()>>: BorrowReqMut<T>,

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for &'a WebRequest<()>

type Type<'b> = &'b Request<RequestExt<()>>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for &'a RequestExt<()>

type Type<'b> = &'b RequestExt<()>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for &'a SocketAddr

type Type<'b> = &'b SocketAddr

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for &'a Uri

type Type<'b> = &'b Uri

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for &'a WebContext<'a, C, B>
where C: 'static, B: 'static,

type Type<'b> = &'b WebContext<'b, C, B>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for ()

type Type<'b> = ()

type Error = Error<C>

async fn from_request(_: &'a WebContext<'r, C, B>) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for (Bytes, Limit<LIMIT>)
where B: BodyStream + Default,

type Type<'b> = (Bytes, Limit<LIMIT>)

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for (BytesMut, Limit<LIMIT>)
where B: BodyStream + Default,

type Type<'b> = (BytesMut, Limit<LIMIT>)

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for (Vec<u8>, Limit<LIMIT>)
where B: BodyStream + Default,

type Type<'b> = (Vec<u8>, Limit<LIMIT>)

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Body
where B: BodyStream + Default,

type Type<'b> = Body

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Bytes
where B: BodyStream + Default,

type Type<'b> = Bytes

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for BytesMut
where B: BodyStream + Default,

type Type<'b> = BytesMut

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, K> FromRequest<'a, WebContext<'r, C, B>> for CookieJar<K>
where K: for<'a2, 'r2> FromRequest<'a2, WebContext<'r2, C, B>, Error = Error<C>>,

type Type<'b> = CookieJar<K>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for ExtensionKey

type Type<'b> = ExtensionKey

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for ExtensionOwn<T>
where T: Send + Sync + Clone + 'static,

type Type<'b> = ExtensionOwn<T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for ExtensionRef<'a, T>
where T: Send + Sync + 'static,

type Type<'b> = ExtensionRef<'b, T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for ExtensionsRef<'a>

type Type<'b> = ExtensionsRef<'b>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for Form<T, LIMIT>
where B: BodyStream + Default, T: for<'de> Deserialize<'de>,

type Type<'b> = Form<T, LIMIT>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, const HEADER_NAME: usize> FromRequest<'a, WebContext<'r, C, B>> for HeaderRef<'a, HEADER_NAME>

type Type<'b> = HeaderRef<'b, HEADER_NAME>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for Json<T, LIMIT>
where B: BodyStream + Default, T: for<'de> Deserialize<'de>,

type Type<'b> = Json<T, LIMIT>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for LazyForm<T, LIMIT>
where B: BodyStream + Default, T: Deserialize<'static>,

type Type<'b> = LazyForm<T, LIMIT>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for LazyJson<T, LIMIT>
where B: BodyStream + Default, T: Deserialize<'static>,

type Type<'b> = LazyJson<T, LIMIT>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for LazyParams<'a, T>

type Type<'b> = LazyParams<'b, T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for LazyQuery<'a, T>
where T: Deserialize<'static>,

type Type<'b> = LazyQuery<'b, T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Method

type Type<'b> = Method

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Multipart
where B: BodyStream + Default,

type Type<'b> = Multipart

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for Option<T>
where T: FromRequest<'a, WebContext<'r, C, B>>,

type Type<'b> = Option<<T as FromRequest<'a, WebContext<'r, C, B>>>::Type<'b>>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, T, C, B> FromRequest<'a, WebContext<'r, C, B>> for Params<T>
where T: for<'de> Deserialize<'de>,

type Type<'b> = Params<T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for ParamsRef<'a>

type Type<'b> = ParamsRef<'b>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for PathOwn

type Type<'b> = PathOwn

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for PathRef<'a>

type Type<'b> = PathRef<'b>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, K> FromRequest<'a, WebContext<'r, C, B>> for Private<K>
where K: for<'a2, 'r2> FromRequest<'a2, WebContext<'r2, C, B>, Error = Error<C>> + Into<Key>,

type Type<'b> = Private<K>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for Query<T>
where T: for<'de> Deserialize<'de>,

type Type<'b> = Query<T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for WebRequest<()>

type Type<'b> = Request<RequestExt<()>>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for RequestExt<()>

type Type<'b> = RequestExt<()>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T, E> FromRequest<'a, WebContext<'r, C, B>> for Result<T, E>
where T: FromRequest<'a, WebContext<'r, C, B>, Error = E>,

type Type<'b> = Result<<T as FromRequest<'a, WebContext<'r, C, B>>>::Type<'b>, <T as FromRequest<'a, WebContext<'r, C, B>>>::Error>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, K> FromRequest<'a, WebContext<'r, C, B>> for Signed<K>
where K: for<'a2, 'r2> FromRequest<'a2, WebContext<'r2, C, B>, Error = Error<C>> + Into<Key>,

type Type<'b> = Signed<K>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for SocketAddr

type Type<'b> = SocketAddr

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for StateKey
where C: Borrow<Self>,

type Type<'b> = StateKey

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for StateOwn<T>
where C: Borrow<T>, T: Clone,

type Type<'b> = StateOwn<T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B, T> FromRequest<'a, WebContext<'r, C, B>> for StateRef<'a, T>
where C: Borrow<T>, T: ?Sized + 'static,

type Type<'b> = StateRef<'b, T>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for String
where B: BodyStream + Default,

type Type<'b> = String

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Uri

type Type<'b> = Uri

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for UriOwn

type Type<'b> = UriOwn

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for UriRef<'a>

type Type<'b> = UriRef<'b>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for Vec<u8>
where B: BodyStream + Default,

type Type<'b> = Vec<u8>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for WebSocket
where C: 'static, B: BodyStream + Default + 'static,

type Type<'b> = WebSocket

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<C, B, I, Res, Err> IntoObject<I, ()> for WebContext<'_, C, B>
where C: 'static, B: 'static, I: Service + RouteGen + Send + Sync + 'static, I::Response: for<'r> Service<WebContext<'r, C, B>, Response = Res, Error = Err> + 'static,

type Object = RouteObject<(), Box<dyn for<'r> ServiceObject<WebContext<'r, C, B>, Response = Res, Error = Err>>, ::Error>

The type-erased form of I.

fn into_object(inner: I) -> Self::Object

Constructs Self::Object from I.

impl<'r, C, B> Responder<WebContext<'r, C, B>> for &'static str

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, const N: usize> Responder<WebContext<'r, C, B>> for [(HeaderName, HeaderValue); N]

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for (HeaderName, HeaderValue)

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Box<str>

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Infallible

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Infallible

async fn respond( self, ctx: 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>

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

impl<'r, C, B, K> Responder<WebContext<'r, C, B>> for CookieJar<K>

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Cow<'static, str>

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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, B> Responder<WebContext<'r, C, B>> for ErrorStatus

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, B, T> Responder<WebContext<'r, C, B>> for Form<T>
where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, T> Responder<WebContext<'r, C, B>> for Html<T>
where T: Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, T> Responder<WebContext<'r, C, B>> for Json<T>
where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, ResB> Responder<WebContext<'r, C, B>> for WebResponse<ResB>

type Response = Response<ResB>

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, B, ResB> Responder<WebContext<'r, C, B>> for ResponseBody<ResB>

type Response = Response<ResponseBody<ResB>>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, T, Res, Err, E> Responder<WebContext<'r, C, B>> for Result<T, E>
where T: for<'r2> Responder<WebContext<'r2, C, B>, Response = Res, Error = Err>, Error<C>: From<E> + From<Err>,

type Response = Res

type Error = Error<C>

async fn respond( self, ctx: 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, B> Responder<WebContext<'r, C, B>> for StatusCode

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B, T> Responder<WebContext<'r, C, B>> for Text<T>
where T: Into<ResponseBody>,

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

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

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Vec<(HeaderName, HeaderValue)>

type Response = Response<ResponseBody>

type Error = Error<C>

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for Vec<u8>

type Response = Response<ResponseBody>

type Error = Infallible

async fn respond( self, ctx: 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>

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

impl<'r, C, B> Responder<WebContext<'r, C, B>> for WebSocket
where B: BodyStream + 'static,

type Response = Response<ResponseBody>

type Error = Infallible

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>

impl<'r, C, B> Service<WebContext<'r, C, B>> for BodyOverFlow

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Box<dyn Error + Send + Sync>

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for EncodingError

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Infallible

The Err part of output future.

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

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

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, B> ) -> Result<Self::Response, Self::Error>

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

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, B> ) -> Result<Self::Response, Self::Error>

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

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, B> ) -> Result<Self::Response, Self::Error>

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

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for ErrorStatus

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for ExtensionNotFound

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for FromUtf8Error

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for HandshakeError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for HeaderNotFound

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Html<T>
where T: Clone + Into<ResponseBody>,

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Error<C>

The Err part of output future.

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

impl<'r, C, B> Service<WebContext<'r, C, B>> for Infallible

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Infallible

The Err part of output future.

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

impl<'r, C, B> Service<WebContext<'r, C, B>> for InvalidHeaderValue

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Json<T>
where T: Serialize + Clone,

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Error<C>

The Err part of output future.

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

impl<'r, S, C, B, Res, Err> Service<WebContext<'r, C, B>> for LimitService<S>
where B: BodyStream + Default, S: for<'r2> Service<WebContext<'r2, C, LimitBody>, Response = Res, Error = Err>,

type Response = Res

The Ok part of output future.

type Error = Err

The Err part of output future.

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

impl<'r, C, B> Service<WebContext<'r, C, B>> for MatchError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for MethodNotAllowed

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for MultipartError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for ParseError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for Redirect

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Error<C>

The Err part of output future.

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

impl<'r, C, B> Service<WebContext<'r, C, B>> for StatusCode

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for StdError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B, T> Service<WebContext<'r, C, B>> for Text<T>
where T: Into<ResponseBody> + Clone,

type Response = Response<ResponseBody>

The Ok part of output future.

type Error = Error<C>

The Err part of output future.

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

impl<'r, C, B> Service<WebContext<'r, C, B>> for ThreadJoinError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for ToStrError

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, B> Service<WebContext<'r, C, B>> for TooManyRequests

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, B> ) -> Result<Self::Response, Self::Error>

impl<'r, C, ReqB, S, ResB> Service<WebContext<'r, C, ReqB>> for TowerCompatService<S>
where S: Service<Request<CompatReqBody<RequestExt<ReqB>, C>>, Response = Response<ResB>>, ResB: Body, C: Clone + 'static, ReqB: Default,

type Response = Response<CompatResBody<ResB>>

The Ok part of output future.

type Error = <S as Service<Request<CompatReqBody<RequestExt<ReqB>, C>>>>::Error

The Err part of output future.

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

Auto Trait Implementations§

impl<'a, C = (), B = RequestBody> !RefUnwindSafe for WebContext<'a, C, B>

impl<'a, C, B> Send for WebContext<'a, C, B>
where B: Send, C: Sync,

impl<'a, C = (), B = RequestBody> !Sync for WebContext<'a, C, B>

impl<'a, C, B> Unpin for WebContext<'a, C, B>

impl<'a, C = (), B = RequestBody> !UnwindSafe for WebContext<'a, C, B>

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more