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

    pub struct HeaderValue { /* fields omitted */ }

Represents an HTTP header field value.

In practice, HTTP header field values are usually valid ASCII. However, the HTTP spec allows for a header value to contain opaque bytes as well. In this case, the header field value is not able to be represented as a string.

To handle this, the `HeaderValue` is useable as a type and can be compared with strings and implements `Debug`. A `to_str` fn is provided that returns an `Err` if the header value contains non visible ascii characters.

## Methods

###

`impl HeaderValue`

[src]

####

`pub fn from_static(src: &'static str) -> HeaderValue`

[src]

Convert a static string to a `HeaderValue`.

This function will not perform any copying, however the string is checked to ensure that no invalid characters are present. Only visible ASCII characters (32-127) are permitted.

# Panics

This function panics if the argument contains invalid header value characters.

# Examples

    let val = HeaderValue::from_static("hello");
    assert_eq!(val, "hello");

####

`pub fn from_str(src: &str) -> Result<HeaderValue, InvalidHeaderValue>`

[src]

Attempt to convert a string to a `HeaderValue`.

If the argument contains invalid header value characters, an error is returned. Only visible ASCII characters (32-127) are permitted. Use `from_bytes` to create a `HeaderValue` that includes opaque octets (128-255).

This function is intended to be replaced in the future by a `TryFrom` implementation once the trait is stabilized in std.

# Examples

    let val = HeaderValue::from_str("hello").unwrap();
    assert_eq!(val, "hello");

An invalid value

    let val = HeaderValue::from_str("\n");
    assert!(val.is_err());

####

`pub fn from_name(name: HeaderName) -> HeaderValue`

[src]

Converts a HeaderName into a HeaderValue

Since every valid HeaderName is a valid HeaderValue this is done infallibly.

# Examples

    let val = HeaderValue::from_name(ACCEPT);
    assert_eq!(val, HeaderValue::from_bytes(b"accept").unwrap());

####

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

[src]

Attempt to convert a byte slice to a `HeaderValue`.

If the argument contains invalid header value bytes, an error is returned. Only byte values between 32 and 255 (inclusive) are permitted, excluding byte 127 (DEL).

This function is intended to be replaced in the future by a `TryFrom` implementation once the trait is stabilized in std.

# Examples

    let val = HeaderValue::from_bytes(b"hello\xfa").unwrap();
    assert_eq!(val, &b"hello\xfa"[..]);

An invalid value

    let val = HeaderValue::from_bytes(b"\n");
    assert!(val.is_err());

####

`pub fn from_shared(src: Bytes) -> Result<HeaderValue, InvalidHeaderValueBytes>`

[src]

Attempt to convert a `Bytes` buffer to a `HeaderValue`.

If the argument contains invalid header value bytes, an error is returned. Only byte values between 32 and 255 (inclusive) are permitted, excluding byte 127 (DEL).

This function is intended to be replaced in the future by a `TryFrom` implementation once the trait is stabilized in std.

####

`pub unsafe fn from_shared_unchecked(src: Bytes) -> HeaderValue`

[src]

Convert a `Bytes` directly into a `HeaderValue` without validating.

This function does NOT validate that illegal bytes are not contained within the buffer.

####

`pub fn to_str(&self) -> Result<&str, ToStrError>`

[src]

Yields a `&str` slice if the `HeaderValue` only contains visible ASCII chars.

This function will perform a scan of the header value, checking all the characters.

# Examples

    let val = HeaderValue::from_static("hello");
    assert_eq!(val.to_str().unwrap(), "hello");

####

`pub fn len(&self) -> usize`

[src]

Returns the length of `self`.

This length is in bytes.

# Examples

    let val = HeaderValue::from_static("hello");
    assert_eq!(val.len(), 5);

####

`pub fn is_empty(&self) -> bool`

[src]

Returns true if the `HeaderValue` has a length of zero bytes.

# Examples

    let val = HeaderValue::from_static("");
    assert!(val.is_empty());

    let val = HeaderValue::from_static("hello");
    assert!(!val.is_empty());

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

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

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

`pub fn as_bytes(&self) -> &[u8]`

[src]

Converts a `HeaderValue` to a byte slice.

# Examples

    let val = HeaderValue::from_static("hello");
    assert_eq!(val.as_bytes(), b"hello");

####

`pub fn set_sensitive(&mut self, val: bool)`

[src]

Mark that the header value represents sensitive information.

# Examples

    let mut val = HeaderValue::from_static("my secret");

    val.set_sensitive(true);
    assert!(val.is_sensitive());

    val.set_sensitive(false);
    assert!(!val.is_sensitive());

####

`pub fn is_sensitive(&self) -> bool`

[src]

Returns `true` if the value represents sensitive data.

Sensitive data could represent passwords or other data that should not be stored on disk or in memory. This setting can be used by components like caches to avoid storing the value. HPACK encoders must set the header field to never index when `is_sensitive` returns true.

Note that sensitivity is not factored into equality or ordering.

# Examples

    let mut val = HeaderValue::from_static("my secret");

    val.set_sensitive(true);
    assert!(val.is_sensitive());

    val.set_sensitive(false);
    assert!(!val.is_sensitive());

## Trait Implementations

###

`impl Ord for HeaderValue`

[src]

####

`fn cmp(&self, other: &HeaderValue) -> Ordering`

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl From<u64> for HeaderValue`

[src]

####

`fn from(num: u64) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<HeaderValue> for Bytes`

[src]

####

`fn from(value: HeaderValue) -> Bytes`

[src]

Performs the conversion.

###

`impl From<i64> for HeaderValue`

[src]

####

`fn from(num: i64) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<usize> for HeaderValue`

[src]

####

`fn from(num: usize) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<i32> for HeaderValue`

[src]

####

`fn from(num: i32) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<HeaderName> for HeaderValue`

[src]

####

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

[src]

Performs the conversion.

###

`impl From<i16> for HeaderValue`

[src]

####

`fn from(num: i16) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<isize> for HeaderValue`

[src]

####

`fn from(num: isize) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<u32> for HeaderValue`

[src]

####

`fn from(num: u32) -> HeaderValue`

[src]

Performs the conversion.

###

`impl From<u16> for HeaderValue`

[src]

####

`fn from(num: u16) -> HeaderValue`

[src]

Performs the conversion.

###

`impl Debug for HeaderValue`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

`impl Eq for HeaderValue`

[src]

###

`impl FromStr for HeaderValue`

[src]

#### `type Err = InvalidHeaderValue`

The associated error which can be returned from parsing.

####

`fn from_str(s: &str) -> Result<HeaderValue, <HeaderValue as FromStr>::Err>`

[src]

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

###

`impl PartialOrd<HeaderValue> for [u8]`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<[u8]> for HeaderValue`

[src]

####

`fn partial_cmp(&self, other: &[u8]) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<str> for HeaderValue`

[src]

####

`fn partial_cmp(&self, other: &str) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<HeaderValue> for str`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<'a, T> PartialOrd<&'a T> for HeaderValue where T: ?Sized, HeaderValue: PartialOrd<T>,`

[src]

####

`fn partial_cmp(&self, other: &&'a T) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<'a> PartialOrd<HeaderValue> for &'a str`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<HeaderValue> for HeaderValue`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<HeaderValue> for String`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue`

[src]

####

`fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl PartialOrd<String> for HeaderValue`

[src]

####

`fn partial_cmp(&self, other: &String) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

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

1.0.0
[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

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

1.0.0
[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

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

1.0.0
[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

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

1.0.0
[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl HttpTryFrom<HeaderValue> for HeaderValue`

[src]

#### `type Error = Error`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<u64> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: u64 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<u64>>::Error>`

[src]

###

`impl HttpTryFrom<u32> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: u32 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<u32>>::Error>`

[src]

###

`impl HttpTryFrom<usize> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: usize ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<usize>>::Error>`

[src]

###

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

[src]

#### `type Error = InvalidHeaderValue`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<Bytes> for HeaderValue`

[src]

#### `type Error = InvalidHeaderValueBytes`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<i32> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: i32 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<i32>>::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<u16> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: u16 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<u16>>::Error>`

[src]

###

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

[src]

#### `type Error = InvalidHeaderValue`

Associated error with the conversion this implementation represents.

####

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

[src]

###

`impl HttpTryFrom<isize> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: isize ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<isize>>::Error>`

[src]

###

`impl HttpTryFrom<i16> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: i16 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<i16>>::Error>`

[src]

###

`impl HttpTryFrom<i64> for HeaderValue`

[src]

#### `type Error = Never`

Associated error with the conversion this implementation represents.

####

`fn try_from( num: i64 ) -> Result<HeaderValue, <HeaderValue as HttpTryFrom<i64>>::Error>`

[src]

###

`impl AsRef<[u8]> for HeaderValue`

[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 PartialEq<HeaderValue> for [u8]`

[src]

####

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

[src]

####

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

[src]

####

`fn eq(&self, other: &String) -> 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<HeaderValue> for &'a HeaderValue`

[src]

####

`fn eq(&self, other: &HeaderValue) -> 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<[u8]> for HeaderValue`

[src]

####

`fn eq(&self, other: &[u8]) -> 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<HeaderValue> for HeaderValue`

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

`fn eq(&self, other: &HeaderValue) -> 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, T> PartialEq<&'a T> for HeaderValue where T: ?Sized, HeaderValue: PartialEq<T>,`

[src]

####

`fn eq(&self, other: &&'a T) -> 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 Clone for HeaderValue`

[src]

####

`fn clone(&self) -> HeaderValue`

[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 Hash for HeaderValue`

[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

## Auto Trait Implementations

###

`impl Send for HeaderValue`

###

`impl Sync for HeaderValue`

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