Struct highnoon::request::Request

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

An incoming request

Implementations

impl<S: State> Request<S>

pub fn state(&self) -> &S

Get a reference to the App's state

pub fn context(&self) -> &S::Context

Get a reference to the request's context

pub fn context_mut(&mut self) -> &mut S::Context

Get a mut reference to the request's context

pub fn method(&self) -> &Method

Get the HTTP method being used by this request

pub fn uri(&self) -> &Uri

Get the URI that was used for this request

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

Parse the URI query string into an instance of T that derives Deserialize.

(To get the raw query string access it via req.uri().query()). If there is no query string, deserialize an empty string.

pub fn header<T: Header>(&self) -> Option<T>

Get a typed header from the request (See also headers)

pub fn headers(&self) -> &HeaderMap<HeaderValue>

Get all headers as a HeaderMap

pub fn cookies(&self) -> Result<CookieJar>

Get the request's cookies

pub fn param(&self, param: &str) -> Result<&str>

Get a route parameter (eg. :key or *key segments in the URI path)

If the parameter is not present, logs an error and returns a 400 Bad Request to the client

pub fn params(&self) -> &Params

Get all route parameters

pub async fn body_mut(&mut self) -> Result<&mut Body>

Get the request body as a hyper::Body

pub async fn reader(&mut self) -> Result<impl Read + '_>

Get a reader to read the request body

(This does buffer the whole body into memory, but not necessarily contiguous memory). If you need to protect against malicious clients you should access the body via body_mut

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

Get the request body as raw bytes in a Vec<u8>

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

Get the request body as UTF-8 data in String

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

Get the request body as JSON and deserialize into T.

If deserialization fails, log an error and return 400 Bad Request. (If this logic is not appropriate, consider using reader and using serde_json directly)

pub fn remote_addr(&self) -> &SocketAddr

Get the address of the remote peer.

This method uses the network level address only and hence may be incorrect if you are behind a proxy. (This does not check for any Forwarded headers etc...)

Trait Implementations

impl<S> HasSession for Request<S> where
    S: State,
    S::Context: HasSession, 

Implement HasSession on requests where the Context has sessions

fn session(&mut self) -> &mut Session

Get a reference to the Session for this current request