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

    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 Eq for HeaderName`

[src]

###

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

[src]

####

`fn eq(&self, other: &HeaderName) -> 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<HeaderName> for str`

[src]

####

`fn eq(&self, other: &HeaderName) -> 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<'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 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<'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 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 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 Borrow<str> for HeaderName`

[src]

####

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

[src]

Immutably borrows from an owned value. Read more

###

`impl From<HeaderName> for Bytes`

[src]

####

`fn from(name: HeaderName) -> Bytes`

[src]

Performs the conversion.

###

`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 AsRef<[u8]> for HeaderName`

[src]

####
ⓘImportant traits for &'a [u8]

### Important traits for &'a [u8]

`impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]`

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

[src]

Performs the conversion.

###

`impl AsRef<str> for HeaderName`

[src]

####

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

[src]

Performs the conversion.

###

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

[src]

###

`impl IntoHeaderName for HeaderName`

[src]

###

`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<'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<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 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 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<'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 Debug for HeaderName`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

`impl AsHeaderName for HeaderName`

[src]

###

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

[src]

## Auto Trait Implementations

###

`impl Send for HeaderName`

###

`impl Sync for HeaderName`

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