Struct WebContext

pub struct WebContext<'a, C = (), B = RequestBody> { /* private fields */ }

web context type focus on stateful and side effect based request data access.

Implementations

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 async fn extract<'r, T>(&'r self) -> Result<T, T::Error>

where T: FromRequest<'r, Self>,

extract typed data from WebContext. type must impl FromRequest trait. this is a shortcut method that avoiding explicit import of mentioned trait.

Examples

async fn extract(ctx: WebContext<'_, usize>) {
    // extract state from context.
    let StateRef(state1) = ctx.extract().await.unwrap();

    // equivalent of above method with explicit trait import.
    use xitca_web::handler::FromRequest;
    let StateRef(state2) = StateRef::<'_, usize>::from_request(&ctx).await.unwrap();

    // two extractors will return the same type and data state.
    assert_eq!(state1, state2);
}

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

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

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

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

type Type<'b> = &'b HeaderMap

type Error = Error

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 Method

type Type<'b> = &'b Method

type Error = Error

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

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

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

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

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

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

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

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

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

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

where B: BodyStream + Default,

type Type<'b> = Body<B>

type Error = Error

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

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

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

type Type<'b> = CookieJar<K>

type Error = Error

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

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

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

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

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

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 HeaderMap

type Type<'b> = HeaderMap

type Error = Error

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

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

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

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

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

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

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

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

where B: BodyStream + Default,

type Type<'b> = Multipart<B>

type Error = Error

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

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

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

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

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

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> + Into<Key>,

type Type<'b> = Private<K>

type Error = Error

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

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

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

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

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> + Into<Key>,

type Type<'b> = Signed<K>

type Error = Error

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

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

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: BorrowState<T>, T: Clone,

type Type<'b> = StateOwn<T>

type Error = Error

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: BorrowState<T>, T: ?Sized + 'static,

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

type Error = Error

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

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

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

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

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

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

where C: 'static, B: BodyStream + Default + 'static,

type Type<'b> = WebSocket<B>

type Error = Error

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>, Error = Err, Response = Res>>, <I as Service>::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

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

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

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

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

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

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

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

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

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

where T: Serialize,

type Response = Response<ResponseBody>

type Error = Error

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

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

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

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

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

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

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: From<E> + From<Err>,

type Response = Res

type Error = Error

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

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

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

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

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

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

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

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>

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

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

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<B>>, 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

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

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>