Struct axum::TypedHeader

pub struct TypedHeader<T>(pub T);

Extractor and response that works with typed header values from headers.

As extractor

In general, it’s recommended to extract only the needed headers via TypedHeader rather than removing all headers with the HeaderMap extractor.

use axum::{
    TypedHeader,
    headers::UserAgent,
    routing::get,
    Router,
};

async fn users_teams_show(
    TypedHeader(user_agent): TypedHeader<UserAgent>,
) {
    // ...
}

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

As response

use axum::{
    TypedHeader,
    response::IntoResponse,
    headers::ContentType,
};

async fn handler() -> (TypedHeader<ContentType>, &'static str) {
    (
        TypedHeader(ContentType::text_utf8()),
        "Hello, World!",
    )
}

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for TypedHeader<T>

fn clone(&self) -> TypedHeader<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TypedHeader<T>

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

Formats the value using the given formatter.

impl<T> Deref for TypedHeader<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for TypedHeader<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, S> FromRequestParts<S> for TypedHeader<T>

where T: Header, S: Send + Sync,

type Rejection = TypedHeaderRejection

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<T> IntoResponse for TypedHeader<T>

where T: Header,

fn into_response(self) -> Response

Create a response.

impl<T> IntoResponseParts for TypedHeader<T>

where T: Header,

type Error = Infallible

The type returned in the event of an error.

fn into_response_parts( self, res: ResponseParts ) -> Result<ResponseParts, Self::Error>

Set parts of the response

impl<T: Copy> Copy for TypedHeader<T>