Struct hyper::header::HeaderName

pub struct HeaderName { /* private fields */ }

Represents an HTTP header field name

Header field names identify the header. Header sets may include multiple headers with the same name. The HTTP specification defines a number of standard headers, but HTTP messages may include non-standard header names as well as long as they adhere to the specification.

HeaderName is used as the HeaderMap key. Constants are available for all standard header names in the header module.

Representation

HeaderName represents standard header names using an enum, as such they will not require an allocation for storage. All custom header names are lower cased upon conversion to a HeaderName value. This avoids the overhead of dynamically doing lower case conversion during the hash code computation and the comparison operation.

Implementations

impl HeaderName

pub fn from_bytes(src: &[u8]) -> Result<HeaderName, InvalidHeaderName>

Converts a slice of bytes to an HTTP header name.

This function normalizes the input.

pub fn from_lowercase(src: &[u8]) -> Result<HeaderName, InvalidHeaderName>

Converts a slice of bytes to an HTTP header name.

This function expects the input to only contain lowercase characters. This is useful when decoding HTTP/2.0 or HTTP/3.0 headers. Both require that all headers be represented in lower case.

Examples

// Parsing a lower case header
let hdr = HeaderName::from_lowercase(b"content-length").unwrap();
assert_eq!(CONTENT_LENGTH, hdr);

// Parsing a header that contains uppercase characters
assert!(HeaderName::from_lowercase(b"Content-Length").is_err());

pub const fn from_static(src: &'static str) -> HeaderName

Converts a static string to a HTTP header name.

This function requires the static string to only contain lowercase characters, numerals and symbols, as per the HTTP/2.0 specification and header names internal representation within this library.

Panics

This function panics when the static string is a invalid header.

Until Allow panicking in constants makes its way into stable, the panic message at compile-time is going to look cryptic, but should at least point at your header value:

error: any use of this value will cause an error
    --> http/src/header/name.rs:1241:13
     |
1241 |             ([] as [u8; 0])[0]; // Invalid header name
     |             ^^^^^^^^^^^^^^^^^^
     |             |
     |             index out of bounds: the length is 0 but the index is 0
     |             inside `http::HeaderName::from_static` at http/src/header/name.rs:1241:13
     |             inside `INVALID_NAME` at src/main.rs:3:34
     |
    ::: src/main.rs:3:1
     |
3    | const INVALID_NAME: HeaderName = HeaderName::from_static("Capitalized");
     | ------------------------------------------------------------------------

Examples

// Parsing a standard header
let hdr = HeaderName::from_static("content-length");
assert_eq!(CONTENT_LENGTH, hdr);

// Parsing a custom header
let CUSTOM_HEADER: &'static str = "custom-header";

let a = HeaderName::from_lowercase(b"custom-header").unwrap();
let b = HeaderName::from_static(CUSTOM_HEADER);
assert_eq!(a, b);

// Parsing a header that contains invalid symbols(s):
HeaderName::from_static("content{}{}length"); // This line panics!

// Parsing a header that contains invalid uppercase characters.
let a = HeaderName::from_static("foobar");
let b = HeaderName::from_static("FOOBAR"); // This line panics!

pub fn as_str(&self) -> &str

Returns a str representation of the header.

The returned string will always be lower case.

Trait Implementations

impl AsRef<[u8]> for HeaderName

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

Performs the conversion.

impl AsRef<str> for HeaderName

pub fn as_ref(&self) -> &str

Performs the conversion.

impl Borrow<str> for HeaderName

pub fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for HeaderName

pub fn clone(&self) -> HeaderName

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HeaderName

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

Formats the value using the given formatter.

impl Display for HeaderName

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

Formats the value using the given formatter.

impl<'a> From<&'a HeaderName> for HeaderName

pub fn from(src: &'a HeaderName) -> HeaderName

Performs the conversion.

impl From<HeaderName> for HeaderValue

pub fn from(h: HeaderName) -> HeaderValue

Performs the conversion.

impl FromStr for HeaderName

type Err = InvalidHeaderName

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<HeaderName, InvalidHeaderName>

Parses a string s to return a value of this type.

impl Hash for HeaderName

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<&'a HeaderName> for HeaderName

pub fn eq(&self, other: &&'a HeaderName) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a str> for HeaderName

pub fn eq(&self, other: &&'a str) -> bool

Performs a case-insensitive comparison of the string against the header name

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<HeaderName> for &'a HeaderName

pub fn eq(&self, other: &HeaderName) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<HeaderName> for &'a str

pub fn eq(&self, other: &HeaderName) -> bool

Performs a case-insensitive comparison of the string against the header name

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<HeaderName> for str

pub fn eq(&self, other: &HeaderName) -> bool

Performs a case-insensitive comparison of the string against the header name

Examples

use http::header::CONTENT_LENGTH;

assert_eq!(CONTENT_LENGTH, "content-length");
assert_eq!(CONTENT_LENGTH, "Content-Length");
assert_ne!(CONTENT_LENGTH, "content length");

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<HeaderName> for HeaderName

pub fn eq(&self, other: &HeaderName) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &HeaderName) -> bool

This method tests for !=.

impl PartialEq<str> for HeaderName

pub fn eq(&self, other: &str) -> bool

Performs a case-insensitive comparison of the string against the header name

Examples

use http::header::CONTENT_LENGTH;

assert_eq!(CONTENT_LENGTH, "content-length");
assert_eq!(CONTENT_LENGTH, "Content-Length");
assert_ne!(CONTENT_LENGTH, "content length");

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> TryFrom<&'a [u8]> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

pub fn try_from(
    s: &'a [u8]
) -> Result<HeaderName, <HeaderName as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a String> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

pub fn try_from(
    s: &'a String
) -> Result<HeaderName, <HeaderName as TryFrom<&'a String>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

pub fn try_from(
    s: &'a str
) -> Result<HeaderName, <HeaderName as TryFrom<&'a str>>::Error>

Performs the conversion.

impl TryFrom<String> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

pub fn try_from(
    s: String
) -> Result<HeaderName, <HeaderName as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<Vec<u8, Global>> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

pub fn try_from(
    vec: Vec<u8, Global>
) -> Result<HeaderName, <HeaderName as TryFrom<Vec<u8, Global>>>::Error>

Performs the conversion.

impl AsHeaderName for HeaderName

impl<'a> AsHeaderName for &'a HeaderName

impl Eq for HeaderName

impl<'a> IntoHeaderName for &'a HeaderName

impl IntoHeaderName for HeaderName

impl StructuralEq for HeaderName

impl StructuralPartialEq for HeaderName