flams_router_vscode::components::server_fn::axum_export::http::request

Struct Request

pub struct Request<T> {
    head: Parts,
    body: T,
}

Expand description

Represents an HTTP request.

An HTTP request consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec<u8>, a Stream of byte chunks, or a value that has been deserialized.

§Examples

Creating a Request to send

use http::{Request, Response};

let mut request = Request::builder()
    .uri("https://www.rust-lang.org/")
    .header("User-Agent", "my-awesome-agent/1.0");

if needs_awesome_header() {
    request = request.header("Awesome", "yes");
}

let response = send(request.body(()).unwrap());

fn send(req: Request<()>) -> Response<()> {
    // ...
}

Inspecting a request to see what was sent.

use http::{Request, Response, StatusCode};

fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
    if req.uri() != "/awesome-url" {
        return Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(())
    }

    let has_awesome_header = req.headers().contains_key("Awesome");
    let body = req.body();

    // ...
}

Deserialize a request of bytes via json:

use http::Request;
use serde::de;

fn deserialize<T>(req: Request<Vec<u8>>) -> serde_json::Result<Request<T>>
    where for<'de> T: de::Deserialize<'de>,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::from_slice(&body)?;
    Ok(Request::from_parts(parts, body))
}

Or alternatively, serialize the body of a request to json

use http::Request;
use serde::ser;

fn serialize<T>(req: Request<T>) -> serde_json::Result<Request<Vec<u8>>>
    where T: ser::Serialize,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::to_vec(&body)?;
    Ok(Request::from_parts(parts, body))
}

Fields§

§head: Parts§body: T

Implementations§

§

impl Request<()>

pub fn builder() -> Builder

Creates a new builder-style object to manufacture a Request

This method returns an instance of Builder which can be used to create a Request.

§Examples

let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

pub fn get<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a GET method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn put<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a PUT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::put("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn post<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a POST method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::post("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn delete<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a DELETE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::delete("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn options<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with an OPTIONS method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::options("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn head<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a HEAD method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::head("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn connect<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a CONNECT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::connect("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn patch<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a PATCH method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::patch("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn trace<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a TRACE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

§Example


let request = Request::trace("https://www.rust-lang.org/")
    .body(())
    .unwrap();

§

impl<T> Request<T>

pub fn new(body: T) -> Request<T>

Creates a new blank Request with the body

The component parts of this request will be set to their default, e.g. the GET method, no headers, etc.

§Examples

let request = Request::new("hello world");

assert_eq!(*request.method(), Method::GET);
assert_eq!(*request.body(), "hello world");

pub fn from_parts(parts: Parts, body: T) -> Request<T>

Creates a new Request with the given components parts and body.

§Examples

let request = Request::new("hello world");
let (mut parts, body) = request.into_parts();
parts.method = Method::POST;

let request = Request::from_parts(parts, body);

pub fn method(&self) -> &Method

Returns a reference to the associated HTTP method.

§Examples

let request: Request<()> = Request::default();
assert_eq!(*request.method(), Method::GET);

pub fn method_mut(&mut self) -> &mut Method

Returns a mutable reference to the associated HTTP method.

§Examples

let mut request: Request<()> = Request::default();
*request.method_mut() = Method::PUT;
assert_eq!(*request.method(), Method::PUT);

pub fn uri(&self) -> &Uri

Returns a reference to the associated URI.

§Examples

let request: Request<()> = Request::default();
assert_eq!(*request.uri(), *"/");

pub fn uri_mut(&mut self) -> &mut Uri

Returns a mutable reference to the associated URI.

§Examples

let mut request: Request<()> = Request::default();
*request.uri_mut() = "/hello".parse().unwrap();
assert_eq!(*request.uri(), *"/hello");

pub fn version(&self) -> Version

Returns the associated version.

§Examples

let request: Request<()> = Request::default();
assert_eq!(request.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

§Examples

let mut request: Request<()> = Request::default();
*request.version_mut() = Version::HTTP_2;
assert_eq!(request.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

§Examples

let request: Request<()> = Request::default();
assert!(request.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap

Returns a mutable reference to the associated header field map.

§Examples

let mut request: Request<()> = Request::default();
request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!request.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

§Examples

let request: Request<()> = Request::default();
assert!(request.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

§Examples

let mut request: Request<()> = Request::default();
request.extensions_mut().insert("hello");
assert_eq!(request.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

§Examples

let request: Request<String> = Request::default();
assert!(request.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

§Examples

let mut request: Request<String> = Request::default();
request.body_mut().push_str("hello world");
assert!(!request.body().is_empty());

pub fn into_body(self) -> T

Consumes the request, returning just the body.

§Examples

let request = Request::new(10);
let body = request.into_body();
assert_eq!(body, 10);

pub fn into_parts(self) -> (Parts, T)

Consumes the request returning the head and body parts.

§Examples

let request = Request::new(());
let (parts, body) = request.into_parts();
assert_eq!(parts.method, Method::GET);

pub fn map<F, U>(self, f: F) -> Request
where F: FnOnce(T) -> U,

Consumes the request returning a new request with body mapped to the return type of the passed in function.

§Examples

let request = Request::builder().body("some string").unwrap();
let mapped_request: Request<&[u8]> = request.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_request.body(), &"some string".as_bytes());

Trait Implementations§

§

impl<T> Clone for Request<T>
where T: Clone,

§

fn clone(&self) -> Request<T>

Returns a duplicate of the value. Read more

Perform the extraction.

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = HandleErrorFuture

The future response value.

§

fn poll_ready( &mut self, _: &mut Context<'_>, ) -> Poll<Result<(), <HandleError<S, F, (T1, T2)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <HandleError<S, F, (T1, T2)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = HandleErrorFuture

The future response value.

§

fn poll_ready( &mut self, _: &mut Context<'_>, ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = HandleErrorFuture

The future response value.

§

fn poll_ready( &mut self, _: &mut Context<'_>, ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = HandleErrorFuture

The future response value.

§

fn poll_ready( &mut self, _: &mut Context<'_>, ) -> Poll<Result<(), <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapRequest<F, S, I, (T1,)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapRequest<F, S, I, (T1,)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapRequest<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapResponse<F, S, I, ()> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapResponse<F, S, I, ()> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapResponse<F, S, I, (T1, T2, T3, T4)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <MapResponse<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = RouteFuture<Infallible>

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <RouterAsService<'_, B> as Service<Request>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request, ) -> <RouterAsService<'_, B> as Service<Request>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2)> as Service<Request<Body>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request<Body>, ) -> <FromFn<F, S, I, (T1, T2)> as Service<Request<Body>>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<Body>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request<Body>, ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)> as Service<Request<Body>>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<Body>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request<Body>, ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Service<Request<Body>>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = Infallible

Errors produced by the service.

§

type Future = ResponseFuture

The future response value.

§

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<Body>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

§

fn call( &mut self, req: Request<Body>, ) -> <FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Service<Request<Body>>>::Future

Process the request and return the response asynchronously. Read more

§

Responses given by the service.

§

type Error = <S as Service<Request<ResBody>>>::Error

Errors produced by the service.

§

type Future = <S as Service<Request<ResBody>>>::Future

Converts self into C, using the provided parameters.

impl<F, W, T, D> Deserialize<With<T, W>, D> for F
where W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,

§

fn deserialize( &self, deserializer: &mut D, ) -> Result<With<T, W>, <D as Fallible>::Error>

Deserializes using the given deserializer

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn in_current_span(self) -> Instrumented<Self> ⓘ

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

impl<WpParam, T, U> IntoCam16Unclamped<WpParam, T> for U
where T: Cam16FromUnclamped<WpParam, U>,

Source §

type Scalar = <T as Cam16FromUnclamped<WpParam, U>>::Scalar

The number type that’s used in parameters when converting.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = 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

§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more

§

impl<T> ErasedDestructor for T
where T: 'static,

§

Struct RequestCopy item path

§Examples

Fields§

Implementations§

impl Request<()>

pub fn builder() -> Builder

§Examples

pub fn get<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn put<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn post<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn delete<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn options<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn head<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn connect<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn patch<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

pub fn trace<T>(uri: T) -> Builderwhere T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

§Example

impl<T> Request<T>

pub fn new(body: T) -> Request<T>

§Examples

pub fn from_parts(parts: Parts, body: T) -> Request<T>

§Examples

pub fn method(&self) -> &Method

§Examples

pub fn method_mut(&mut self) -> &mut Method

§Examples

pub fn uri(&self) -> &Uri

§Examples

pub fn uri_mut(&mut self) -> &mut Uri

§Examples

pub fn version(&self) -> Version

§Examples

pub fn version_mut(&mut self) -> &mut Version

§Examples

pub fn headers(&self) -> &HeaderMap

§Examples

pub fn headers_mut(&mut self) -> &mut HeaderMap

§Examples

pub fn extensions(&self) -> &Extensions

§Examples

pub fn extensions_mut(&mut self) -> &mut Extensions

§Examples

pub fn body(&self) -> &T

§Examples

pub fn body_mut(&mut self) -> &mut T

§Examples

pub fn into_body(self) -> T

§Examples

pub fn into_parts(self) -> (Parts, T)

§Examples

pub fn map<F, U>(self, f: F) -> Request<U>where F: FnOnce(T) -> U,

§Examples

Trait Implementations§

impl<T> Clone for Request<T>where T: Clone,

fn clone(&self) -> Request<T>

fn clone_from(&mut self, source: &Self)

impl<T> Debug for Request<T>where T: Debug,

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

impl<T> Default for Request<T>where T: Default,

fn default() -> Request<T>

impl<S> FromRequest<S> for Request<Body>where S: Send + Sync,

type Rejection = Infallible

async fn from_request( req: Request<Body>, _: &S, ) -> Result<Request<Body>, <Request<Body> as FromRequest<S>>::Rejection>

impl<B> Body for Request<B>where B: Body,

type Data = <B as Body>::Data

type Error = <B as Body>::Error

fn poll_frame( self: Pin<&mut Request<B>>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<<Request<B> as Body>::Data>, <Request<B> as Body>::Error>>>

fn is_end_stream(&self) -> bool

fn size_hint(&self) -> SizeHint

impl IntoClientRequest for Request<()>

fn into_client_request(self) -> Result<Request<()>, Error>

impl<B> IntoMapRequestResult<B> for Request<B>

Struct Request

pub fn get<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn put<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn post<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn delete<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn options<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn head<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn connect<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn patch<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn trace<T>(uri: T) -> Builder
where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

pub fn map<F, U>(self, f: F) -> Request<U>
where F: FnOnce(T) -> U,

impl<T> Clone for Request<T>
where T: Clone,

impl<T> Debug for Request<T>
where T: Debug,

impl<T> Default for Request<T>
where T: Default,

impl<S> FromRequest<S> for Request<Body>
where S: Send + Sync,

impl<B> Body for Request<B>
where B: Body,

impl<Error, InputStreamError, OutputStreamError> Req<Error, InputStreamError, OutputStreamError> for Request<Body>
where Error: FromServerFnError + Send, InputStreamError: FromServerFnError + Send, OutputStreamError: FromServerFnError + Send,

impl<Error, InputStreamError, OutputStreamError> Req<Error, InputStreamError, OutputStreamError> for Request<Bytes>
where Error: FromServerFnError + Send, InputStreamError: FromServerFnError + Send, OutputStreamError: FromServerFnError + Send,

fn extract<E, M>( self, ) -> impl Future<Output = Result<E, <E as FromRequest<(), M>>::Rejection>> + Send
where E: FromRequest<(), M> + 'static, M: 'static,

fn extract_with_state<E, S, M>( self, state: &S, ) -> impl Future<Output = Result<E, <E as FromRequest<S, M>>::Rejection>> + Send
where E: FromRequest<S, M> + 'static, S: Send + Sync,

fn extract_parts<E>( &mut self, ) -> impl Future<Output = Result<E, <E as FromRequestParts<()>>::Rejection>> + Send
where E: FromRequestParts<()> + 'static,

async fn extract_parts_with_state<'a, E, S>( &'a mut self, state: &'a S, ) -> Result<E, <E as FromRequestParts<S>>::Rejection>
where E: FromRequestParts<S> + 'static, S: Send + Sync,

impl<T, E, B, S> Service<Request<B>> for FromExtractor<T, E, S>
where E: FromRequestParts<S> + 'static, B: Send + 'static, T: Service<Request<B>> + Clone, <T as Service<Request<B>>>::Response: IntoResponse, S: Clone + Send + Sync + 'static,