Lines Matching full:request
1 //! HTTP request types.
4 //! `Request` type itself as well as a builder to create requests. Typically
5 //! you'll import the `http::Request` type rather than reaching into this
10 //! Creating a `Request` to send
13 //! use http::{Request, Response};
15 //! let mut request = Request::builder()
20 //! request = request.header("Awesome", "yes");
23 //! let response = send(request.body(()).unwrap());
29 //! fn send(req: Request<()>) -> Response<()> {
35 //! Inspecting a request to see what was sent.
38 //! use http::{Request, Response, StatusCode};
40 //! fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
64 /// Represents an HTTP request.
66 /// An HTTP request consists of a head and a potentially optional body. The body
73 /// Creating a `Request` to send
76 /// use http::{Request, Response};
78 /// let mut request = Request::builder()
83 /// request = request.header("Awesome", "yes");
86 /// let response = send(request.body(()).unwrap());
92 /// fn send(req: Request<()>) -> Response<()> {
98 /// Inspecting a request to see what was sent.
101 /// use http::{Request, Response, StatusCode};
103 /// fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
118 /// Deserialize a request of bytes via json:
124 /// use http::Request;
127 /// fn deserialize<T>(req: Request<Vec<u8>>) -> serde_json::Result<Request<T>>
132 /// Ok(Request::from_parts(parts, body))
138 /// Or alternatively, serialize the body of a request to json
144 /// use http::Request;
147 /// fn serialize<T>(req: Request<T>) -> serde_json::Result<Request<Vec<u8>>>
152 /// Ok(Request::from_parts(parts, body))
157 pub struct Request<T> { struct
162 /// Component parts of an HTTP `Request` argument
164 /// The HTTP request head consists of a method, uri, version, and a set of
167 /// The request's method
170 /// The request's URI
173 /// The request's version
176 /// The request's headers
179 /// The request's extensions
185 /// An HTTP request builder
187 /// This type can be used to construct an instance or `Request`
194 impl Request<()> { implementation
195 /// Creates a new builder-style object to manufacture a `Request`
198 /// create a `Request`.
204 /// let request = Request::builder()
219 /// create a `Request`.
226 /// let request = Request::get("https://www.rust-lang.org/")
242 /// create a `Request`.
249 /// let request = Request::put("https://www.rust-lang.org/")
265 /// create a `Request`.
272 /// let request = Request::post("https://www.rust-lang.org/")
288 /// create a `Request`.
295 /// let request = Request::delete("https://www.rust-lang.org/")
311 /// create a `Request`.
318 /// let request = Request::options("https://www.rust-lang.org/")
321 /// # assert_eq!(*request.method(), Method::OPTIONS);
335 /// create a `Request`.
342 /// let request = Request::head("https://www.rust-lang.org/")
358 /// create a `Request`.
365 /// let request = Request::connect("https://www.rust-lang.org/")
381 /// create a `Request`.
388 /// let request = Request::patch("https://www.rust-lang.org/")
403 /// create a `Request`.
410 /// let request = Request::trace("https://www.rust-lang.org/")
423 impl<T> Request<T> { implementation
424 /// Creates a new blank `Request` with the body
426 /// The component parts of this request will be set to their default, e.g.
433 /// let request = Request::new("hello world");
435 /// assert_eq!(*request.method(), Method::GET);
436 /// assert_eq!(*request.body(), "hello world");
439 pub fn new(body: T) -> Request<T> { in new()
440 Request { in new()
446 /// Creates a new `Request` with the given components parts and body.
452 /// let request = Request::new("hello world");
453 /// let (mut parts, body) = request.into_parts();
456 /// let request = Request::from_parts(parts, body);
459 pub fn from_parts(parts: Parts, body: T) -> Request<T> { in from_parts()
460 Request { in from_parts()
472 /// let request: Request<()> = Request::default();
473 /// assert_eq!(*request.method(), Method::GET);
486 /// let mut request: Request<()> = Request::default();
487 /// *request.method_mut() = Method::PUT;
488 /// assert_eq!(*request.method(), Method::PUT);
501 /// let request: Request<()> = Request::default();
502 /// assert_eq!(*request.uri(), *"/");
515 /// let mut request: Request<()> = Request::default();
516 /// *request.uri_mut() = "/hello".parse().unwrap();
517 /// assert_eq!(*request.uri(), *"/hello");
530 /// let request: Request<()> = Request::default();
531 /// assert_eq!(request.version(), Version::HTTP_11);
544 /// let mut request: Request<()> = Request::default();
545 /// *request.version_mut() = Version::HTTP_2;
546 /// assert_eq!(request.version(), Version::HTTP_2);
559 /// let request: Request<()> = Request::default();
560 /// assert!(request.headers().is_empty());
574 /// let mut request: Request<()> = Request::default();
575 /// request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
576 /// assert!(!request.headers().is_empty());
589 /// let request: Request<()> = Request::default();
590 /// assert!(request.extensions().get::<i32>().is_none());
604 /// let mut request: Request<()> = Request::default();
605 /// request.extensions_mut().insert("hello");
606 /// assert_eq!(request.extensions().get(), Some(&"hello"));
619 /// let request: Request<String> = Request::default();
620 /// assert!(request.body().is_empty());
633 /// let mut request: Request<String> = Request::default();
634 /// request.body_mut().push_str("hello world");
635 /// assert!(!request.body().is_empty());
642 /// Consumes the request, returning just the body.
647 /// # use http::Request;
648 /// let request = Request::new(10);
649 /// let body = request.into_body();
657 /// Consumes the request returning the head and body parts.
663 /// let request = Request::new(());
664 /// let (parts, body) = request.into_parts();
672 /// Consumes the request returning a new request with body mapped to the
679 /// let request = Request::builder().body("some string").unwrap();
680 /// let mapped_request: Request<&[u8]> = request.map(|b| {
687 pub fn map<F, U>(self, f: F) -> Request<U> in map()
691 Request { in map()
698 impl<T: Default> Default for Request<T> { implementation
699 fn default() -> Request<T> { in default()
700 Request::new(T::default()) in default()
704 impl<T: fmt::Debug> fmt::Debug for Request<T> { implementation
706 f.debug_struct("Request") in fmt()
745 /// Creates a new default instance of `Builder` to construct a `Request`.
752 /// let req = request::Builder::new()
762 /// Set the HTTP method for this request.
771 /// let req = Request::builder()
788 /// Get the HTTP Method for this request.
797 /// let mut req = Request::builder();
807 /// Set the URI for this request.
816 /// let req = Request::builder()
832 /// Get the URI for this request
841 /// let mut req = Request::builder();
851 /// Set the HTTP version for this request.
860 /// let req = Request::builder()
872 /// Get the HTTP version for this request
881 /// let mut req = Request::builder();
891 /// Appends a header to this request builder.
903 /// let req = Request::builder()
924 /// Get header on this request builder.
930 /// # use http::Request;
931 /// let req = Request::builder()
942 /// Get headers on this request builder.
949 /// # use http::{header::HeaderValue, Request};
950 /// let mut req = Request::builder();
971 /// let req = Request::builder()
989 /// Get a reference to the extensions for this request builder.
996 /// # use http::Request;
997 /// let req = Request::builder().extension("My Extension").extension(5u32);
1006 /// Get a mutable reference to the extensions for this request builder.
1013 /// # use http::Request;
1014 /// let mut req = Request::builder().extension("My Extension");
1025 /// constructed `Request`.
1040 /// let request = Request::builder()
1044 pub fn body<T>(self, body: T) -> Result<Request<T>> { in body()
1046 Request { in body()
1080 let request = Request::builder().body("some string").unwrap(); in it_can_map_a_body_from_one_type_to_another() localVariable
1081 let mapped_request = request.map(|s| { in it_can_map_a_body_from_one_type_to_another()