# actix_web::http::header::HeaderName - Rust
API documentation for the Rust `HeaderName` struct in crate `actix_web`.
Keywords: rust, rustlang, rust-lang, HeaderName

# [−] [src] Struct actix_web::http::header::HeaderName

    pub struct HeaderName { /* fields omitted */ }

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.

## Methods

###

`impl HeaderName`

[src]

####

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

[src]

Converts a slice of bytes to an HTTP header name.

This function normalizes the input.

####

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

[src]

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 headers. The HTTP/2.0 specification requires 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 fn from_static(src: &'static str) -> HeaderName`

[src]

Converts a static string to a HTTP header name.

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

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.

# 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`

[src]

Returns a `str` representation of the header.

The returned string will always be lower case.

## Trait Implementations

###

`impl Debug for HeaderName`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

`impl Hash for HeaderName`

[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl Eq for HeaderName`

[src]

###

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

[src]

####

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

[src]

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

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

1.0.0
[src]

This method tests for `!=`.

###

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

[src]

####

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

[src]

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

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

1.0.0
[src]

This method tests for `!=`.

###

`impl PartialEq<HeaderName> for HeaderName`

[src]

####

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

[src]

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

####

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

[src]

This method tests for `!=`.

###

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

[src]

####

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

[src]

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

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

1.0.0
[src]

This method tests for `!=`.

###

`impl PartialEq<str> for HeaderName`

[src]

####

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

[src]

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

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

1.0.0
[src]

This method tests for `!=`.

###

`impl Display for HeaderName`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

`impl FromStr for HeaderName`

[src]

#### `type Err = InvalidHeaderName`

The associated error which can be returned from parsing.

####

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

[src]

Parses a string `s` to return a value of this type. Read more

###

`impl AsRef<str> for HeaderName`

[src]

####

`fn as_ref(&self) -> &str`

[src]

Performs the conversion.

###

`impl AsRef<[u8]> for HeaderName`

[src]

####

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

[src]

Performs the conversion.

###

`impl<'a> HttpTryFrom<&'a str> for HeaderName`

[src]

#### `type Error = InvalidHeaderName`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<HeaderName> for HeaderValue`

[src]

#### `type Error = InvalidHeaderValue`

Associated error with the conversion this implementation represents.

####

`fn try_from( name: HeaderName ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<HeaderName>>::Error>`

[src]

###

`impl<'a> HttpTryFrom<&'a HeaderName> for HeaderName`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( t: &'a HeaderName ) -> Result<HeaderName, <HeaderName as HttpTryFrom<&'a HeaderName>>::Error>`

[src]

###

`impl<'a> HttpTryFrom<&'a [u8]> for HeaderName`

[src]

#### `type Error = InvalidHeaderName`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<Bytes> for HeaderName`

[src]

#### `type Error = InvalidHeaderNameBytes`

Associated error with the conversion this implementation represents.

####

`fn try_from( bytes: Bytes ) -> Result<HeaderName, <HeaderName as HttpTryFrom<Bytes>>::Error>`

[src]

###

`impl HttpTryFrom<HeaderName> for HeaderName`

[src]

#### `type Error = Error`

Associated error with the conversion this implementation represents.

####

`fn try_from( t: HeaderName ) -> Result<HeaderName, <HeaderName as HttpTryFrom<HeaderName>>::Error>`

[src]

###

`impl From<HeaderName> for HeaderValue`

[src]

####

`fn from(h: HeaderName) -> HeaderValue`

[src]

Performs the conversion.

###

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

[src]

####

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

[src]

Performs the conversion.

###

`impl Clone for HeaderName`

[src]

####

`fn clone(&self) -> HeaderName`

[src]

Returns a copy of the value. Read more

####

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

1.0.0
[src]

Performs copy-assignment from `source`. Read more

###

`impl IntoHeaderName for HeaderName`

[src]

###

`impl<'a> IntoHeaderName for &'a HeaderName`

[src]

###

`impl<'a> AsHeaderName for &'a HeaderName`

[src]

###

`impl AsHeaderName for HeaderName`

[src]

###

`impl Borrow<str> for HeaderName`

[src]

####

`fn borrow(&self) -> &str`

[src]

Immutably borrows from an owned value. Read more

## Auto Trait Implementations

###

`impl Send for HeaderName`

###

`impl Sync for HeaderName`

## Blanket Implementations

###

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

[src]

#### `type Owned = T`

####

`fn to_owned(&self) -> T`

[src]

Creates owned data from borrowed data, usually by cloning. Read more

####

`fn clone_into(&self, target: &mut T)`

[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

###

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

[src]

####

`fn to_string(&self) -> String`

[src]

Converts the given value to a `String`. Read more

###

`impl<T> From for T`

[src]

####

`fn from(t: T) -> T`

[src]

Performs the conversion.

###

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

[src]

####

`fn into(self) -> U`

[src]

Performs the conversion.

###

`impl<T, U> TryFrom for T where T: From<U>,`

[src]

#### `type Error = !`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

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

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

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

[src]

####

`fn borrow(&self) -> &T`

[src]

Immutably borrows from an owned value. Read more

###

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

[src]

####

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

[src]

Mutably borrows from an owned value. Read more

###

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

[src]

#### `type Error = <U as TryFrom<T>>::Error`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

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

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

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

[src]

####

`fn get_type_id(&self) -> TypeId`

[src]

🔬 This is a nightly-only experimental API. (`get_type_id`)

this method will likely be replaced by an associated static

Gets the `TypeId` of `self`. Read more

###

`impl<T> Erased for T`

###

`impl<Q, K> Equivalent for Q where K: Borrow<Q> + ?Sized, Q: Eq + ?Sized,`

[src]

####

`fn equivalent(&self, key: &K) -> bool`

[src]

Compare self to `key` and return `true` if they are equal.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)