[−][src]Struct http_types::Request

pub struct Request { /* fields omitted */ }

An HTTP request.

Examples

use http_types::{Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body("Hello, Nori!");

Implementations

impl Request[src]

pub fn new<U>(method: Method, url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug, [src]

Create a new request.

pub fn set_peer_addr(&mut self, peer_addr: Option<impl ToString>)[src]

Sets a string representation of the peer address of this request. This might take the form of an ip/fqdn and port or a local socket address.

pub fn set_local_addr(&mut self, local_addr: Option<impl ToString>)[src]

Sets a string representation of the local address that this request was received on. This might take the form of an ip/fqdn and port, or a local socket address.

pub fn peer_addr(&self) -> Option<&str>[src]

Get the peer socket address for the underlying transport, if that information is available for this request.

pub fn local_addr(&self) -> Option<&str>[src]

Get the local socket address for the underlying transport, if that information is available for this request.

pub fn remote(&self) -> Option<&str>[src]

Get the remote address for this request. This is determined in the following priority:

  1. Forwarded header for key
  2. The first X-Forwarded-For header
  3. Peer address of the transport

pub fn host(&self) -> Option<&str>[src]

Get the destination host for this request. This is determined in the following priority:

  1. Forwarded header host key
  2. The first X-Forwarded-Host header
  3. Host header
  4. URL domain, if any

pub fn method(&self) -> Method[src]

Get the HTTP method

pub fn set_method(&mut self, method: Method)[src]

Set the HTTP method.

pub fn url(&self) -> &Url[src]

Get a reference to the url.

Examples

use http_types::{Url, Method, Request, Response, StatusCode};
let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
assert_eq!(req.url().scheme(), "https");

pub fn url_mut(&mut self) -> &mut Url[src]

Get a mutable reference to the url.

Examples

use http_types::{Url, Method, Request, Response, StatusCode};
let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
req.url_mut().set_scheme("http");
assert_eq!(req.url().scheme(), "http");

pub fn set_body(&mut self, body: impl Into<Body>)[src]

Set the request body.

Examples

use http_types::{Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body("Hello, Nori!");

pub fn replace_body(&mut self, body: impl Into<Body>) -> Body[src]

Swaps the value of the body with another body, without deinitializing either one.

Examples

use http_types::{Body, Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body("Hello, Nori!");
let mut body: Body = req.replace_body("Hello, Chashu!");

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

pub fn swap_body(&mut self, body: &mut Body)[src]

Replace the request body with a new body, and return the old body.

Examples

use http_types::{Body, Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body("Hello, Nori!");
let mut body = "Hello, Chashu!".into();
req.swap_body(&mut body);

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

pub fn take_body(&mut self) -> Body[src]

Take the request body, replacing it with an empty body.

Examples

use http_types::{Body, Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body("Hello, Nori!");
let mut body: Body = req.take_body();

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

pub async fn body_string(self) -> Result<String>[src]

Read the body as a string.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_string or using the Request's AsyncRead implementation to read the body.

Examples

use http_types::{Body, Url, Method, Request};
use async_std::io::Cursor;

let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());

let cursor = Cursor::new("Hello Nori");
let body = Body::from_reader(cursor, None);
req.set_body(body);
assert_eq!(&req.body_string().await.unwrap(), "Hello Nori");

pub async fn body_bytes(self) -> Result<Vec<u8>>[src]

Read the body as bytes.

This consumes the Request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_bytes or using the Request's AsyncRead implementation to read the body.

Examples

use http_types::{Body, Url, Method, Request};

let bytes = vec![1, 2, 3];
let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body(Body::from_bytes(bytes));

let bytes = req.body_bytes().await?;
assert_eq!(bytes, vec![1, 2, 3]);

pub async fn body_json<T: DeserializeOwned>(self) -> Result<T>[src]

Read the body as JSON.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_json or using the Request's AsyncRead implementation to read the body.

Examples

use http_types::{Body, Url, Method, Request};
use http_types::convert::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct Cat { name: String }

let cat = Cat { name: String::from("chashu") };
let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body(Body::from_json(&cat)?);

let cat: Cat = req.body_json().await?;
assert_eq!(&cat.name, "chashu");

pub async fn body_form<T: DeserializeOwned>(self) -> Result<T>[src]

Read the body as x-www-form-urlencoded.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_json or using the Request's AsyncRead implementation to read the body.

Examples

use http_types::{Body, Url, Method, Request};
use http_types::convert::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct Cat { name: String }

let cat = Cat { name: String::from("chashu") };
let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
req.set_body(Body::from_form(&cat)?);

let cat: Cat = req.body_form().await?;
assert_eq!(&cat.name, "chashu");

pub fn header(&self, name: impl Into<HeaderName>) -> Option<&HeaderValues>[src]

Get an HTTP header.

pub fn header_mut(
    &mut self,
    name: impl Into<HeaderName>
) -> Option<&mut HeaderValues>[src]

Get a mutable reference to a header.

pub fn remove_header(
    &mut self,
    name: impl Into<HeaderName>
) -> Option<HeaderValues>[src]

Remove a header.

pub fn insert_header(
    &mut self,
    name: impl Into<HeaderName>,
    values: impl ToHeaderValues
) -> Option<HeaderValues>[src]

Set an HTTP header.

Examples

use http_types::{Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
req.insert_header("Content-Type", "text/plain");

pub fn append_header(
    &mut self,
    name: impl Into<HeaderName>,
    values: impl ToHeaderValues
)[src]

Append a header to the headers.

Unlike insert this function will not override the contents of a header, but insert a header if there aren't any. Or else append to the existing list of headers.

Examples

use http_types::{Url, Method, Request};

let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
req.append_header("Content-Type", "text/plain");

pub fn set_content_type(&mut self, mime: Mime) -> Option<HeaderValues>[src]

Set the response MIME.

pub fn content_type(&self) -> Option<Mime>[src]

Get the current content type

pub fn len(&self) -> Option<usize>[src]

Get the length of the body stream, if it has been set.

This value is set when passing a fixed-size object into as the body. E.g. a string, or a buffer. Consumers of this API should check this value to decide whether to use Chunked encoding, or set the response length.

pub fn is_empty(&self) -> Option<bool>[src]

Returns true if the request has a set body stream length of zero, false otherwise.

pub fn version(&self) -> Option<Version>[src]

Get the HTTP version, if one has been set.

Examples

use http_types::{Url, Method, Request, Version};

let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
assert_eq!(req.version(), None);

req.set_version(Some(Version::Http2_0));
assert_eq!(req.version(), Some(Version::Http2_0));

pub fn set_version(&mut self, version: Option<Version>)[src]

Set the HTTP version.

Examples

use http_types::{Url, Method, Request, Version};

let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
req.set_version(Some(Version::Http2_0));

pub fn send_trailers(&mut self) -> Sender[src]

Sends trailers to the a receiver.

pub async fn recv_trailers<'_>(&'_ mut self) -> Receiver[src]

Receive trailers from a sender.

pub fn iter(&self) -> Iter[src]

An iterator visiting all header pairs in arbitrary order.

pub fn iter_mut(&mut self) -> IterMut[src]

An iterator visiting all header pairs in arbitrary order, with mutable references to the values.

pub fn header_names(&self) -> Names[src]

An iterator visiting all header names in arbitrary order.

pub fn header_values(&self) -> Values[src]

An iterator visiting all header values in arbitrary order.

pub fn ext(&self) -> &Extensions[src]

Returns a reference to the existing local state.

pub fn ext_mut(&mut self) -> &mut Extensions[src]

Returns a mutuable reference to the existing local state.

Examples

use http_types::{Url, Method, Request, Version};

let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
req.ext_mut().insert("hello from the extension");
assert_eq!(req.ext().get(), Some(&"hello from the extension"));

pub fn query<T: DeserializeOwned>(&self) -> Result<T>[src]

Get the URL querystring.

Examples

use http_types::{Url, Method, Request};
use http_types::convert::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Index {
    page: u32
}

let req = Request::new(Method::Get, Url::parse("https://httpbin.org/get?page=2").unwrap());
let Index { page } = req.query()?;
assert_eq!(page, 2);

pub fn set_query(&mut self, query: &impl Serialize + ?Sized) -> Result<()>[src]

Set the URL querystring.

Examples

use http_types::{Url, Method, Request};
use http_types::convert::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Index {
    page: u32
}

let query = Index { page: 2 };
let mut req = Request::new(Method::Get, Url::parse("https://httpbin.org/get?page=2").unwrap());
req.set_query(&query)?;
assert_eq!(req.url().query(), Some("page=2"));
assert_eq!(req.url().as_str(), "https://httpbin.org/get?page=2");

Trait Implementations

impl AsMut<Headers> for Request[src]

impl AsRef<Headers> for Request[src]

impl AsyncBufRead for Request[src]

impl AsyncRead for Request[src]

impl Clone for Request[src]

fn clone(&self) -> Self[src]

Clone the request, resolving the body to Body::empty() and removing extensions.

impl Debug for Request[src]

impl From<Request> for Body[src]

impl<'_> Index<&'_ str> for Request[src]

type Output = HeaderValues

The returned type after indexing.

fn index(&self, name: &str) -> &HeaderValues[src]

Returns a reference to the value corresponding to the supplied name.

Panics

Panics if the name is not present in Request.

impl Index<HeaderName> for Request[src]

type Output = HeaderValues

The returned type after indexing.

fn index(&self, name: HeaderName) -> &HeaderValues[src]

Returns a reference to the value corresponding to the supplied name.

Panics

Panics if the name is not present in Request.

impl IntoIterator for Request[src]

type Item = (HeaderName, HeaderValues)

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter[src]

Returns a iterator of references over the remaining items.

impl<'a> IntoIterator for &'a Request[src]

type Item = (&'a HeaderName, &'a HeaderValues)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

impl<'a> IntoIterator for &'a mut Request[src]

type Item = (&'a HeaderName, &'a mut HeaderValues)

The type of the elements being iterated over.

type IntoIter = IterMut<'a>

Which kind of iterator are we turning this into?

impl<'__pin> Unpin for Request where
    __Origin<'__pin>: Unpin, [src]

Auto Trait Implementations

impl !RefUnwindSafe for Request

impl Send for Request

impl Sync for Request

impl !UnwindSafe for Request

Blanket Implementations

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

impl<R> AsyncBufReadExt for R where
    R: AsyncBufRead + ?Sized, [src]

impl<R> AsyncReadExt for R where
    R: AsyncRead + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> BufReadExt for T where
    T: AsyncBufRead + ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<I> IntoIterator for I where
    I: Iterator, [src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> ReadExt for T where
    T: AsyncRead + ?Sized, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.