[][src]Struct http::header::HeaderValue

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.

Implementations

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_maybe_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue> where
    T: AsRef<[u8]> + 'static, 
[src]

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

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

impl Clone for HeaderValue[src]

impl Debug for HeaderValue[src]

impl Eq for HeaderValue[src]

impl<'a> From<&'a HeaderValue> for HeaderValue[src]

impl From<HeaderName> for HeaderValue[src]

impl From<i16> for HeaderValue[src]

impl From<i32> for HeaderValue[src]

impl From<i64> for HeaderValue[src]

impl From<isize> for HeaderValue[src]

impl From<u16> for HeaderValue[src]

impl From<u32> for HeaderValue[src]

impl From<u64> for HeaderValue[src]

impl From<usize> for HeaderValue[src]

impl FromStr for HeaderValue[src]

type Err = InvalidHeaderValue

The associated error which can be returned from parsing.

impl Hash for HeaderValue[src]

impl Ord for HeaderValue[src]

impl<'a, T: ?Sized> PartialEq<&'a T> for HeaderValue where
    HeaderValue: PartialEq<T>, 
[src]

impl PartialEq<[u8]> for HeaderValue[src]

impl PartialEq<HeaderValue> for HeaderValue[src]

impl PartialEq<HeaderValue> for str[src]

impl PartialEq<HeaderValue> for [u8][src]

impl PartialEq<HeaderValue> for String[src]

impl<'a> PartialEq<HeaderValue> for &'a HeaderValue[src]

impl<'a> PartialEq<HeaderValue> for &'a str[src]

impl PartialEq<String> for HeaderValue[src]

impl PartialEq<str> for HeaderValue[src]

impl<'a, T: ?Sized> PartialOrd<&'a T> for HeaderValue where
    HeaderValue: PartialOrd<T>, 
[src]

impl PartialOrd<[u8]> for HeaderValue[src]

impl PartialOrd<HeaderValue> for HeaderValue[src]

impl PartialOrd<HeaderValue> for str[src]

impl PartialOrd<HeaderValue> for [u8][src]

impl PartialOrd<HeaderValue> for String[src]

impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue[src]

impl<'a> PartialOrd<HeaderValue> for &'a str[src]

impl PartialOrd<String> for HeaderValue[src]

impl PartialOrd<str> for HeaderValue[src]

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

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a String> for HeaderValue[src]

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a str> for HeaderValue[src]

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

impl TryFrom<String> for HeaderValue[src]

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

impl TryFrom<Vec<u8>> for HeaderValue[src]

type Error = InvalidHeaderValue

The type returned in the event of a conversion error.

Auto Trait Implementations

impl RefUnwindSafe for HeaderValue

impl Send for HeaderValue

impl Sync for HeaderValue

impl Unpin for HeaderValue

impl UnwindSafe for HeaderValue

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.