Struct actix_web::HttpRequest

pub struct HttpRequest { /* fields omitted */ }

An HTTP Request

Methods

impl HttpRequest

pub fn head(&self) -> &RequestHead

This method returns reference to the request head

pub fn uri(&self) -> &Uri

Request's uri.

pub fn method(&self) -> &Method

Read the Request method.

pub fn version(&self) -> Version

Read the Request Version.

pub fn path(&self) -> &str

The target path of this Request.

pub fn query_string(&self) -> &str

The query string in the URL.

E.g., id=10

pub fn match_info(&self) -> &Path<Url>

Get a reference to the Path parameters.

Params is a container for url parameters. A variable segment is specified in the form {identifier}, where the identifier can be used later in a request handler to access the matched value for that segment.

pub fn config(&self) -> &AppConfig

App config

pub fn app_data<T: 'static>(&self) -> Option<Data<T>>

Get an application data stored with App::data() method during application configuration.

pub fn url_for<U, I>(
    &self,
    name: &str,
    elements: U
) -> Result<Url, UrlGenerationError> where
    U: IntoIterator<Item = I>,
    I: AsRef<str>, 

Generate url for named resource

fn index(req: HttpRequest) -> HttpResponse {
    let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
    HttpResponse::Ok().into()
}

fn main() {
    let app = App::new()
        .service(web::resource("/test/{one}/{two}/{three}")
             .name("foo")  // <- set resource name, then it could be used in `url_for`
             .route(web::get().to(|| HttpResponse::Ok()))
        );
}

pub fn url_for_static(&self, name: &str) -> Result<Url, UrlGenerationError>

Generate url for named resource

This method is similar to HttpRequest::url_for() but it can be used for urls that do not contain variable parts.

pub fn connection_info(&self) -> Ref<ConnectionInfo>

Get ConnectionInfo for the current request.

Methods from Deref<Target = RequestHead>

pub fn extensions(&self) -> Ref<Extensions>

Message extensions

pub fn extensions_mut(&self) -> RefMut<Extensions>

Mutable reference to a the message's extensions

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

Read the message headers.

pub fn connection_type(&self) -> ConnectionType

Connection type

pub fn upgrade(&self) -> bool

Connection upgrade status

pub fn chunked(&self) -> bool

Get response body chunking state

Trait Implementations

impl<P> FromRequest<P> for HttpRequest

It is possible to get HttpRequest as an extractor handler parameter

Example

use actix_web::{web, App, HttpRequest};

/// extract `Thing` from request
fn index(req: HttpRequest) -> String {
   format!("Got thing: {:?}", req)
}

fn main() {
    let app = App::new().service(
        web::resource("/users/{first}").route(
            web::get().to(index))
    );
}

type Error = Error

The associated error which can be returned.

type Future = Result<Self, Error>

Future that resolves to a Self

fn from_request(req: &mut ServiceFromRequest<P>) -> Self::Future

Convert request to a Self

impl Clone for HttpRequest

fn clone(&self) -> HttpRequest

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpRequest

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

Formats the value using the given formatter.

impl Deref for HttpRequest

type Target = RequestHead

The resulting type after dereferencing.

fn deref(&self) -> &RequestHead

Dereferences the value.

impl HttpMessage for HttpRequest

type Stream = ()

Type of message payload stream

fn headers(&self) -> &HeaderMap

Returns Request's headers.

fn extensions(&self) -> Ref<Extensions>

Request extensions

fn extensions_mut(&self) -> RefMut<Extensions>

Mutable reference to a the request's extensions

fn take_payload(&mut self) -> Payload<Self::Stream>

Message payload stream

fn content_type(&self) -> &str

Read the request content type. If request does not contain Content-Type header, empty str get returned.

fn encoding(
    &self
) -> Result<&'static (dyn Encoding + 'static + Sync + Send), ContentTypeError>

Get content type encoding

fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError>

Convert the request content type to a known mime type.

fn chunked(&self) -> Result<bool, ParseError>

Check if request has chunked transfer encoding

fn cookies(&self) -> Result<Ref<Vec<Cookie<'static>>>, ParseError>

Load request cookies.

fn cookie(&self, name: &str) -> Option<Cookie<'static>>

Return request cookie.