Struct 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

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.

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:
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) -> &str

Returns a str representation of the header.

The returned string will always be lower case.

Trait Implementations

impl AsHeaderName for HeaderName

impl AsRef<[u8]> for HeaderName

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

impl AsRef<str> for HeaderName

fn as_ref(&self) -> &str

impl Borrow<str> for HeaderName

fn borrow(&self) -> &str

impl Clone for HeaderName

fn clone(&self) -> HeaderName

impl Debug for HeaderName

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

impl Display for HeaderName

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

impl Eq for HeaderName

impl From<&HeaderName> for HeaderName

fn from(src: &HeaderName) -> HeaderName

impl FromStr for HeaderName

type Err = InvalidHeaderName;
fn from_str(s: &str) -> Result<HeaderName, InvalidHeaderName>

impl Hash for HeaderName

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

impl IntoHeaderName for HeaderName

impl PartialEq for HeaderName

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

impl PartialEq<&HeaderName> for HeaderName

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

impl PartialEq<&str> for HeaderName

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

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

impl PartialEq<str> for HeaderName

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");

impl StructuralPartialEq for HeaderName

impl TryFrom<&String> for HeaderName

type Error = InvalidHeaderName;
fn try_from(s: &String) -> Result<Self, Self::Error>

impl TryFrom<&[u8]> for HeaderName

type Error = InvalidHeaderName;
fn try_from(s: &[u8]) -> Result<Self, Self::Error>

impl TryFrom<&str> for HeaderName

type Error = InvalidHeaderName;
fn try_from(s: &str) -> Result<Self, Self::Error>

impl TryFrom<String> for HeaderName

type Error = InvalidHeaderName;
fn try_from(s: String) -> Result<Self, Self::Error>

impl TryFrom<Vec<u8>> for HeaderName

type Error = InvalidHeaderName;
fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error>

Auto Trait Implementations

impl !Freeze for HeaderName

impl RefUnwindSafe for HeaderName

impl Send for HeaderName

impl Sync for HeaderName

impl Unpin for HeaderName

impl UnsafeUnpin for HeaderName

impl UnwindSafe for HeaderName

Blanket Implementations

impl<T> Any for HeaderName where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for HeaderName where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for HeaderName where T: ?Sized,

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

impl<T> CloneToUninit for HeaderName where T: Clone,

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

impl<T> From<T> for HeaderName

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for HeaderName where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T> ToString for HeaderName where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for HeaderName where U: From<T>,

fn into(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<U> for HeaderName where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for HeaderName where U: TryFrom<T>,

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