Struct tide::Request

pub struct Request<State> { /* fields omitted */ }

An HTTP request.

The Request gives endpoints access to basic information about the incoming request, route parameters, and various ways of accessing the request's body.

Requests also provide extensions, a type map primarily used for low-level communication between middleware and endpoints.

Implementations

impl<State> Request<State>

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

Access the request's HTTP method.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|req: Request<()>| async move {
    assert_eq!(req.method(), http_types::Method::Get);
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

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

Access the request's full URI method.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|req: Request<()>| async move {
    assert_eq!(req.url(), &"/".parse::<tide::http::Url>().unwrap());
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

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

Access the request's HTTP version.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|req: Request<()>| async move {
    assert_eq!(req.version(), Some(http_types::Version::Http1_1));
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

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

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

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

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

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

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

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

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

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

Get the request content type as a Mime.

This gets the request Content-Type header.

Read more on MDN

#[must_use]pub fn header(&self, key: impl Into<HeaderName>) -> Option<&HeaderValues>

Get an HTTP header.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|req: Request<()>| async move {
    assert_eq!(req.header("X-Forwarded-For").unwrap(), "127.0.0.1");
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

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

Get a mutable reference to a header.

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

Set an HTTP header.

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

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.

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

Remove a header.

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

An iterator visiting all header pairs in arbitrary order.

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

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

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

An iterator visiting all header names in arbitrary order.

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

An iterator visiting all header values in arbitrary order.

#[must_use]pub fn ext<T: Send + Sync + 'static>(&self) -> Option<&T>

Get a request extension value.

pub fn set_ext<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T>

Set a request extension value.

#[must_use]pub fn state(&self) -> &State

Access application scoped state.

pub fn param<T: FromStr>(&self, key: &str) -> Result<T, T::Err>

Extract and parse a route parameter by name.

Returns the results of parsing the parameter according to the inferred output type T.

The name should not include the leading : or the trailing * (if any).

Errors

Yields an Err if the parameter was found but failed to parse as an instance of type T.

Panics

Panic if key is not a parameter for the route.

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

Get the URL querystring.

pub fn take_body(&mut self) -> Body

Take the request body as a Body.

pub async fn body_bytes<'_>(&'_ mut self) -> Result<Vec<u8>>

Reads the entire request body into a byte buffer.

This method can be called after the body has already been read, but will produce an empty buffer.

Errors

Any I/O error encountered while reading the body is immediately returned as an Err.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|mut req: Request<()>| async move {
    let _body: Vec<u8> = req.body_bytes().await.unwrap();
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

pub async fn body_string<'_>(&'_ mut self) -> Result<String>

Reads the entire request body into a string.

This method can be called after the body has already been read, but will produce an empty buffer.

Errors

Any I/O error encountered while reading the body is immediately returned as an Err.

If the body cannot be interpreted as valid UTF-8, an Err is returned.

Examples

use tide::Request;

let mut app = tide::new();
app.at("/").get(|mut req: Request<()>| async move {
    let _body: String = req.body_string().await.unwrap();
    Ok("")
});
app.listen("127.0.0.1:8080").await?;

pub async fn body_json<'_, T: DeserializeOwned>(&'_ mut self) -> Result<T>

Reads and deserialized the entire request body via json.

Errors

Any I/O error encountered while reading the body is immediately returned as an Err.

If the body cannot be interpreted as valid json for the target type T, an Err is returned.

pub async fn body_form<'_, T: DeserializeOwned>(&'_ mut self) -> Result<T>

Parse the request body as a form.

#[must_use]pub fn cookie(&self, name: &str) -> Option<Cookie<'static>>

returns a Cookie by name of the cookie.

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

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.

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

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

Trait Implementations

impl<State> AsMut<Headers> for Request<State>

fn as_mut(&mut self) -> &mut Headers

Performs the conversion.

impl<State> AsMut<Request> for Request<State>

fn as_mut(&mut self) -> &mut Request

Performs the conversion.

impl<State> AsRef<Headers> for Request<State>

fn as_ref(&self) -> &Headers

Performs the conversion.

impl<State> AsRef<Request> for Request<State>

fn as_ref(&self) -> &Request

Performs the conversion.

impl<State> AsyncRead for Request<State>

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<State: Debug> Debug for Request<State>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'_, State> Index<&'_ str> for Request<State>

type Output = HeaderValues

The returned type after indexing.

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

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

Panics

Panics if the name is not present in Request.

impl<State> Index<HeaderName> for Request<State>

type Output = HeaderValues

The returned type after indexing.

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

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

Panics

Panics if the name is not present in Request.

impl<State> Into<Request> for Request<State>

fn into(self) -> Request

Performs the conversion.

impl<State: Send + Sync + 'static> Into<Response> for Request<State>

fn into(self) -> Response

Performs the conversion.

impl<State> IntoIterator for Request<State>

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

Returns a iterator of references over the remaining items.

impl<'a, State> IntoIterator for &'a Request<State>

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, State> IntoIterator for &'a mut Request<State>

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.