Struct `Request`

struct Request<'headers, 'buf> { ... }

A parsed Request.

The optional values will be None if a parse was not complete, and did not parse the associated property. This allows you to inspect the parts that could be parsed, before reading more, in case you wish to exit early.

Example

let buf = b"GET /404 HTTP/1.1\r\nHost:";
let mut headers = [httparse::EMPTY_HEADER; 16];
let mut req = httparse::Request::new(&mut headers);
let res = req.parse(buf).unwrap();
if res.is_partial() {
    match req.path {
        Some(ref path) => {
            // check router for path.
            // /404 doesn't exist? we could stop parsing
        },
        None => {
            // must read more and parse again
        }
    }
}

Fields

method: Option<&'buf str>: The request method, such as GET.
path: Option<&'buf str>: The request path, such as /about-us.
version: Option<u8>: The request minor version, such as 1 for HTTP/1.1.
headers: &'headers mut [Header<'buf>]: The request headers.

Implementations

`impl<'h, 'b> Request<'h, 'b>`

fn new(headers: &'h mut [Header<'b>]) -> Request<'h, 'b>

Creates a new Request, using a slice of headers you allocate.

fn parse_with_uninit_headers(self: &mut Self, buf: &'b [u8], headers: &'h mut [MaybeUninit<Header<'b>>]) -> Result<usize>

Try to parse a buffer of bytes into the Request, except use an uninitialized slice of Headers.

For more information, see parse

fn parse(self: &mut Self, buf: &'b [u8]) -> Result<usize>

Try to parse a buffer of bytes into the Request.

Returns byte offset in buf to start of HTTP body.

`impl<'headers, 'buf> Debug for Request<'headers, 'buf>`

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

`impl<'headers, 'buf> Eq for Request<'headers, 'buf>`

`impl<'headers, 'buf> Freeze for Request<'headers, 'buf>`

`impl<'headers, 'buf> PartialEq for Request<'headers, 'buf>`

fn eq(self: &Self, other: &Request<'headers, 'buf>) -> bool

`impl<'headers, 'buf> RefUnwindSafe for Request<'headers, 'buf>`

`impl<'headers, 'buf> Send for Request<'headers, 'buf>`

`impl<'headers, 'buf> StructuralPartialEq for Request<'headers, 'buf>`

`impl<'headers, 'buf> Sync for Request<'headers, 'buf>`

`impl<'headers, 'buf> Unpin for Request<'headers, 'buf>`

`impl<'headers, 'buf> UnsafeUnpin for Request<'headers, 'buf>`

`impl<'headers, 'buf> UnwindSafe for Request<'headers, 'buf>`

`impl<T> Any for Request<'headers, 'buf>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Request<'headers, 'buf>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Request<'headers, 'buf>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Request<'headers, 'buf>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Request<'headers, 'buf>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Request<'headers, 'buf>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Request<'headers, 'buf>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>