Struct actix_http::header::HeaderValue

pub struct HeaderValue { /* private fields */ }

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.

Implementations

impl HeaderValue

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

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.

Until Allow panicking in constants makes its way into stable, the panic message at compile-time is going to look cryptic, but should at least point at your header value:

error: any use of this value will cause an error
  --> http/src/header/value.rs:67:17
   |
67 |                 ([] as [u8; 0])[0]; // Invalid header value
   |                 ^^^^^^^^^^^^^^^^^^
   |                 |
   |                 index out of bounds: the length is 0 but the index is 0
   |                 inside `HeaderValue::from_static` at http/src/header/value.rs:67:17
   |                 inside `INVALID_HEADER` at src/main.rs:73:33
   |
  ::: src/main.rs:73:1
   |
73 | const INVALID_HEADER: HeaderValue = HeaderValue::from_static("жsome value");
   | ----------------------------------------------------------------------------

Examples

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

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

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

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>

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_maybe_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue>

where T: AsRef<[u8]> + 'static,

Attempt to convert a Bytes buffer to a HeaderValue.

This will try to prevent a copy if the type passed is the type used internally, and will copy the data if it is not.

pub unsafe fn from_maybe_shared_unchecked<T>(src: T) -> HeaderValue

where T: AsRef<[u8]> + 'static,

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>

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

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

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

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

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)

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

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. By marking header values as sensitive, components using this crate can be instructed to treat them with special care for security reasons. For example, caches can avoid storing sensitive values, and HPACK encoders used by HTTP/2.0 implementations can choose not to compress them.

Additionally, sensitive values will be masked by the Debug implementation of HeaderValue.

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

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

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

impl Clone for HeaderValue

fn clone(&self) -> HeaderValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HeaderValue

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

Formats the value using the given formatter.

impl<'a> From<&'a HeaderValue> for HeaderValue

fn from(t: &'a HeaderValue) -> HeaderValue

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<i16> for HeaderValue

fn from(num: i16) -> HeaderValue

Converts to this type from the input type.

impl From<i32> for HeaderValue

fn from(num: i32) -> HeaderValue

Converts to this type from the input type.

impl From<i64> for HeaderValue

fn from(num: i64) -> HeaderValue

Converts to this type from the input type.

impl From<isize> for HeaderValue

fn from(num: isize) -> HeaderValue

Converts to this type from the input type.

impl From<u16> for HeaderValue

fn from(num: u16) -> HeaderValue

Converts to this type from the input type.

impl From<u32> for HeaderValue

fn from(num: u32) -> HeaderValue

Converts to this type from the input type.

impl From<u64> for HeaderValue

fn from(num: u64) -> HeaderValue

Converts to this type from the input type.

impl From<usize> for HeaderValue

fn from(num: usize) -> HeaderValue

Converts to this type from the input type.

impl FromStr for HeaderValue

type Err = InvalidHeaderValue

The associated error which can be returned from parsing.

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

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

impl Hash for HeaderValue

fn hash<__H>(&self, state: &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 Ord for HeaderValue

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'a, T> PartialEq<&'a T> for HeaderValue

where HeaderValue: PartialEq<T>, T: ?Sized,

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

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

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

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

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

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

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

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

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

where HeaderValue: PartialOrd<T>, T: ?Sized,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<[u8]> for HeaderValue

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<HeaderValue> for [u8]

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<HeaderValue> for str

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<String> for HeaderValue

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<str> for HeaderValue

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for HeaderValue

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<&'a [u8]> for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<'a> TryFrom<&'a String> for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<'a> TryFrom<&'a str> for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<String> for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

fn try_from( t: String, ) -> Result<HeaderValue, <HeaderValue as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<Vec<u8>> for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryIntoHeaderValue for &HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

fn try_into_value(self) -> Result<HeaderValue, Self::Error>

Try to convert value to a HeaderValue.

impl TryIntoHeaderValue for HeaderValue

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

fn try_into_value(self) -> Result<HeaderValue, Self::Error>

Try to convert value to a HeaderValue.

impl Eq for HeaderValue