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.

Standard header constants can be used for equality checks. They cannot be used as const patterns on stable Rust because HeaderName implements semantic, case-insensitive PartialEq manually. If Rust stabilizes the structural matching support needed for this representation, these constants can become pattern-matchable again.

Representation

HeaderName represents standard header names using an enum, as such they will not require an allocation for storage. Header names preserve their original casing while equality, ordering and hashing continue to use HTTP’s case-insensitive header-name semantics.

Implementations

impl HeaderName

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

Converts a slice of bytes to an HTTP header name.

This function preserves the original header-name spelling while using HTTP’s case-insensitive semantics for equality and hashing.

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 preserves the original header-name spelling while using HTTP’s case-insensitive semantics for equality and hashing.

Panics

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

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_bytes(b"Custom-Header").unwrap();
let b = HeaderName::from_static(CUSTOM_HEADER);
assert_eq!(a, b);

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

pub fn as_str(&self) -> &str

Returns a str representation of the header.

Standard headers are returned in their normalized lowercase spelling. Custom headers are returned in their original spelling.

pub fn as_original_str(&self) -> Cow<'_, str>

Returns the preserved spelling of the header name.

Standard headers with mixed or uppercase spelling may need to rebuild their original casing from the compact case mask, so this returns Cow. For display-only use, prefer Self::display_original.

pub fn as_lower_str(&self) -> Cow<'_, str>

Returns the lowercase spelling of the header name.

This borrows for standard headers and already-lowercase custom headers. Custom headers with uppercase ASCII letters are lowercased into an owned string. For display-only use, prefer Self::display_lowercase.

pub fn display_original(&self) -> OriginalHeaderName<'_>

Returns a display adapter that writes the preserved header spelling.

pub fn display_lowercase(&self) -> LowercaseHeaderName<'_>

Returns a display adapter that writes the lowercase header spelling.

This is useful for HTTP/2 and HTTP/3 diagnostics or formatting. It does not allocate.

pub fn standard(&self) -> Option<StandardHeader>

Returns the standard header represented by this name, if this is a standard header.

pub fn write_original<B>(&self, dst: &mut B)

where B: BufMut,

Write the original header spelling represented by this name.

For HTTP/2 and HTTP/3 use Self::write_lowercase instead.

pub fn write_lowercase<B>(&self, dst: &mut B)

where B: BufMut,

Write the lowercase wire representation required by HTTP/2 and HTTP/3.

Trait Implementations

impl AsHeaderName for HeaderName

impl AsHeaderName for &HeaderName

impl AsRef<[u8]> for HeaderName

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

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for HeaderName

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for HeaderName

fn clone(&self) -> HeaderName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HeaderName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HeaderName

fn deserialize<D>( deserializer: D, ) -> Result<HeaderName, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for HeaderName

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

Formats the value using the given formatter.

impl Eq for HeaderName

impl From<&HeaderName> for HeaderName

fn from(src: &HeaderName) -> HeaderName

Converts to this type from the input type.

impl From<HeaderName> for HeaderValue

fn from(h: HeaderName) -> HeaderValue

Converts to this type from the input type.

impl From<StandardName> for HeaderName

fn from(src: StandardName) -> HeaderName

Converts to this type from the input type.

impl FromStr for HeaderName

type Err = InvalidHeaderName

The associated error which can be returned from parsing.

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

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

impl Hash for HeaderName

fn hash<H>(&self, hasher: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoHeaderName for HeaderName

impl IntoHeaderName for &HeaderName

impl IntoHeaderName for HeaderName

impl PartialEq for HeaderName

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&HeaderName> for HeaderName

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&HeaderName> for str

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&HeaderName> for String

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&String> for HeaderName

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for HeaderName

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<HeaderName> for &HeaderName

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<HeaderName> for str

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

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

Examples

use rama_http_types::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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<HeaderName> for &str

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<HeaderName> for String

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<HeaderName> for &String

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for HeaderName

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for &HeaderName

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 rama_http_types::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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for &HeaderName

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for HeaderName

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&HeaderName> for ClientHint

type Error = ClientHintParsingError

The type returned in the event of a conversion error.

fn try_from( name: &HeaderName, ) -> Result<ClientHint, <ClientHint as TryFrom<&HeaderName>>::Error>

Performs the conversion.

impl TryFrom<&String> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&[u8]> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&str> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<HeaderName> for ClientHint

type Error = ClientHintParsingError

The type returned in the event of a conversion error.

fn try_from( name: HeaderName, ) -> Result<ClientHint, <ClientHint as TryFrom<HeaderName>>::Error>

Performs the conversion.

impl TryFrom<String> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Vec<u8>> for HeaderName

type Error = InvalidHeaderName

The type returned in the event of a conversion error.

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

Performs the conversion.