Struct spa_rs::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 for TypedHeader<T> where
    T: Clone, 

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 for TypedHeader<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Deref for TypedHeader<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<TypedHeader<T> as Deref>::Target

Dereferences the value.

impl<T, B> FromRequest<B> for TypedHeader<T> where
    T: Header,
    B: Send, 

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<'life0, 'async_trait>(
    req: &'life0 mut RequestParts<B>
) -> Pin<Box<dyn Future<Output = Result<TypedHeader<T>, <TypedHeader<T> as FromRequest<B>>::Rejection>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    TypedHeader<T>: 'async_trait, 

Perform the extraction.

impl<T> IntoResponse for TypedHeader<T> where
    T: Header, 

fn into_response(self) -> Response<UnsyncBoxBody<Bytes, Error>>

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, <TypedHeader<T> as IntoResponseParts>::Error>

Set parts of the response

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