Struct RawPathParams

pub struct RawPathParams(/* private fields */);

Extractor that will get captures from the URL without deserializing them.

In general you should prefer to use Path as it is higher level, however RawPathParams is suitable if just want the raw params without deserializing them and thus saving some allocations.

Any percent encoded parameters will be automatically decoded. The decoded parameters must be valid UTF-8, otherwise RawPathParams will fail and return a 400 Bad Request response.

Example

use axum::{
    extract::RawPathParams,
    routing::get,
    Router,
};

async fn users_teams_show(params: RawPathParams) {
    for (key, value) in &params {
        println!("{key:?} = {value:?}");
    }
}

let app = Router::new().route("/users/:user_id/team/:team_id", get(users_teams_show));

Implementations

impl RawPathParams

pub fn iter(&self) -> RawPathParamsIter<'_>

Get an iterator over the path parameters.

Trait Implementations

impl Debug for RawPathParams

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

Formats the value using the given formatter.

impl<S> FromRequestParts<S> for RawPathParams

where S: Send + Sync,

type Rejection = RawPathParamsRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>( parts: &'life0 mut Parts, _state: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform the extraction.

impl<'a> IntoIterator for &'a RawPathParams

type Item = (&'a str, &'a str)

The type of the elements being iterated over.

type IntoIter = RawPathParamsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes