Struct `HeaderName`

struct HeaderName { ... }

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`

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

Converts a slice of bytes to an HTTP header name.

This function normalizes the input.

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

# use http::header::*;

// 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());

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

# use http::header::*;
// 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);

# use http::header::*;
#
// 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!

fn as_str(self: &Self) -> &str

Returns a str representation of the header.

The returned string will always be lower case.

`impl AsHeaderName for super::name::HeaderName`

`impl AsRef for HeaderName`

fn as_ref(self: &Self) -> &[u8]

`impl AsRef for HeaderName`

fn as_ref(self: &Self) -> &str

`impl Borrow for HeaderName`

fn borrow(self: &Self) -> &str

`impl Clone for HeaderName`

fn clone(self: &Self) -> HeaderName

`impl Debug for HeaderName`

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

`impl Display for HeaderName`

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

`impl Eq for HeaderName`

`impl Freeze for HeaderName`

`impl FromStr for HeaderName`

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

`impl Hash for HeaderName`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl IntoHeaderName for super::name::HeaderName`

`impl PartialEq for HeaderName`

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

`impl PartialEq for HeaderName`

fn eq(self: &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");

`impl RefUnwindSafe for HeaderName`

`impl Send for HeaderName`

`impl StructuralPartialEq for HeaderName`

`impl Sync for HeaderName`

`impl TryFrom for HeaderName`

fn try_from(vec: Vec<u8>) -> Result<Self, <Self as >::Error>

`impl TryFrom for HeaderName`

fn try_from(s: String) -> Result<Self, <Self as >::Error>

`impl Unpin for HeaderName`

`impl UnwindSafe for HeaderName`

`impl<'a> From for HeaderName`

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

`impl<'a> PartialEq for HeaderName`

fn eq(self: &Self, other: &&'a str) -> bool: Performs a case-insensitive comparison of the string against the header name

`impl<'a> PartialEq for HeaderName`

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

`impl<'a> TryFrom for HeaderName`

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

`impl<'a> TryFrom for HeaderName`

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

`impl<'a> TryFrom for HeaderName`

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

`impl<T> Any for HeaderName`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for HeaderName`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for HeaderName`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for HeaderName`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for HeaderName`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for HeaderName`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for HeaderName`

fn to_string(self: &Self) -> String

`impl<T, U> Into for HeaderName`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for HeaderName`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for HeaderName`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>