Struct HeaderRef

pub struct HeaderRef<'a, const HEADER_NAME: usize>(/* private fields */);

typed header extractor.

on success HeaderRef will be received in handler function where it can be dereference to HeaderValue type.

on failure HeaderNotFound error would be returned which would generate a “400 BadRequest” http response.

Example

use xitca_web::{
    handler::{
        handler_service,
        header::{self, HeaderRef}
    },
    App
};

// a handle function expecting content_type header.
async fn handle(header: HeaderRef<'_, { header::CONTENT_TYPE }>) -> &'static str {
    // dereference HeaderRef to operate on HeaderValue.
    println!("{:?}", header.to_str());
    ""
}

App::new()
    .at("/", handler_service(handle))

Methods from Deref<Target = HeaderValue>

pub fn to_str(&self) -> Result<&str, ToStrError>

Yields a &str slice if the HeaderValue only contains visible ASCII chars.

This function will perform a scan of the header value, checking all the characters.

Examples

let val = HeaderValue::from_static("hello");
assert_eq!(val.to_str().unwrap(), "hello");

pub fn len(&self) -> usize

Returns the length of self.

This length is in bytes.

Examples

let val = HeaderValue::from_static("hello");
assert_eq!(val.len(), 5);

pub fn is_empty(&self) -> bool

Returns true if the HeaderValue has a length of zero bytes.

Examples

let val = HeaderValue::from_static("");
assert!(val.is_empty());

let val = HeaderValue::from_static("hello");
assert!(!val.is_empty());

pub fn as_bytes(&self) -> &[u8]

Converts a HeaderValue to a byte slice.

Examples

let val = HeaderValue::from_static("hello");
assert_eq!(val.as_bytes(), b"hello");

pub fn is_sensitive(&self) -> bool

Returns true if the value represents sensitive data.

Sensitive data could represent passwords or other data that should not be stored on disk or in memory. By marking header values as sensitive, components using this crate can be instructed to treat them with special care for security reasons. For example, caches can avoid storing sensitive values, and HPACK encoders used by HTTP/2.0 implementations can choose not to compress them.

Additionally, sensitive values will be masked by the Debug implementation of HeaderValue.

Note that sensitivity is not factored into equality or ordering.

Examples

let mut val = HeaderValue::from_static("my secret");

val.set_sensitive(true);
assert!(val.is_sensitive());

val.set_sensitive(false);
assert!(!val.is_sensitive());

Trait Implementations

impl<const HEADER_NAME: usize> Debug for HeaderRef<'_, HEADER_NAME>

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

Formats the value using the given formatter.

impl<const HEADER_NAME: usize> Deref for HeaderRef<'_, HEADER_NAME>

type Target = HeaderValue

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, 'r, C, B, const HEADER_NAME: usize> FromRequest<'a, WebContext<'r, C, B>> for HeaderRef<'a, HEADER_NAME>

type Type<'b> = HeaderRef<'b, HEADER_NAME>

type Error = Error

async fn from_request( ctx: &'a WebContext<'r, C, B>, ) -> Result<Self, Self::Error>