Struct Request 

pub struct Request {
    pub method: HttpMethod,
    pub uri: Uri,
    pub version: Version,
    pub headers: Headers,
    pub body: Body,
    pub extensions: HashMap<String, String>,
    pub path_params: HashMap<String, String>,
    pub cookies: HashMap<String, Cookie>,
    pub form_data: Option<HashMap<String, String>>,
    pub multipart: Option<MultipartForm>,
}

HTTP request type

Fields

method: HttpMethod

uri: Uri

version: Version

headers: Headers

body: Body

extensions: HashMap<String, String>

path_params: HashMap<String, String>

Path parameters extracted from route matching

cookies: HashMap<String, Cookie>

Parsed cookies

form_data: Option<HashMap<String, String>>

Parsed form data (URL-encoded)

multipart: Option<MultipartForm>

Parsed multipart form data

Implementations

impl Request

pub fn new(method: HttpMethod, uri: Uri) -> Self

Create a new request

pub fn path(&self) -> &str

Get the path from the URI

pub fn query(&self) -> Option<&str>

Get query parameters

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

Get a path parameter by name

pub fn params(&self) -> &HashMap<String, String>

Get all path parameters

pub fn set_params(&mut self, params: HashMap<String, String>)

Set path parameters (used internally by routing system)

pub async fn json<T>(&self) -> Result<T>

where T: for<'de> Deserialize<'de>,

Parse JSON body

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

Get body as text

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

Get cookie by name

pub fn cookies(&self) -> &HashMap<String, Cookie>

Get all cookies

pub fn parse_cookies(&mut self) -> Result<()>

Parse cookies from headers

pub fn form(&self, name: &str) -> Option<&str>

Get form field value

pub fn form_data(&self) -> Option<&HashMap<String, String>>

Get all form data

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

Parse URL-encoded form data

pub fn multipart(&self) -> Option<&MultipartForm>

Get multipart form data

pub fn query_params(&self) -> HashMap<String, String>

Parse query parameters into a HashMap

pub fn query_param(&self, name: &str) -> Option<String>

Get a single query parameter by name

pub fn accepts(&self, content_type: &str) -> bool

Check if request accepts a specific content type

pub fn content_type(&self) -> Option<&str>

Get the content type of the request

pub fn is_json(&self) -> bool

Check if this is a JSON request

pub fn is_form(&self) -> bool

Check if this is a form request

pub fn is_multipart(&self) -> bool

Check if this is a multipart request

pub fn remote_addr(&self) -> Option<&str>

Get remote IP address (best effort)

pub fn user_agent(&self) -> Option<&str>

Get user agent

pub fn path_param(&self, name: &str) -> Option<&str>

Get path parameter by name

pub fn path_params(&self) -> &HashMap<String, String>

Get all path parameters

pub fn set_path_param( &mut self, name: impl Into<String>, value: impl Into<String>, )

Set a path parameter (used by router)

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

Parse multipart form data

Trait Implementations

impl Debug for Request

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

Formats the value using the given formatter.

impl SessionExt for Request

fn session(&self, manager: &SessionManager) -> Session

Get or create session