796 lines
22 KiB
Rust
796 lines
22 KiB
Rust
use bytes::{Bytes, BytesMut};
|
|
|
|
use std::convert::TryFrom;
|
|
use std::error::Error;
|
|
use std::fmt::Write;
|
|
use std::str::FromStr;
|
|
use std::{cmp, fmt, mem, str};
|
|
|
|
use crate::header::name::HeaderName;
|
|
|
|
/// 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.
|
|
#[derive(Clone, Hash)]
|
|
pub struct HeaderValue {
|
|
inner: Bytes,
|
|
is_sensitive: bool,
|
|
}
|
|
|
|
/// A possible error when converting a `HeaderValue` from a string or byte
|
|
/// slice.
|
|
pub struct InvalidHeaderValue {
|
|
_priv: (),
|
|
}
|
|
|
|
/// A possible error when converting a `HeaderValue` to a string representation.
|
|
///
|
|
/// Header field values may contain opaque bytes, in which case it is not
|
|
/// possible to represent the value as a string.
|
|
#[derive(Debug)]
|
|
pub struct ToStrError {
|
|
_priv: (),
|
|
}
|
|
|
|
impl 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](https://github.com/rust-lang/rfcs/pull/2345)
|
|
/// 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:
|
|
///
|
|
/// ```text
|
|
/// 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
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_static("hello");
|
|
/// assert_eq!(val, "hello");
|
|
/// ```
|
|
#[inline]
|
|
#[allow(unconditional_panic)] // required for the panic circumvention
|
|
pub const fn from_static(src: &'static str) -> HeaderValue {
|
|
let bytes = src.as_bytes();
|
|
let mut i = 0;
|
|
while i < bytes.len() {
|
|
if !is_visible_ascii(bytes[i]) {
|
|
([] as [u8; 0])[0]; // Invalid header value
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
HeaderValue {
|
|
inner: Bytes::from_static(bytes),
|
|
is_sensitive: false,
|
|
}
|
|
}
|
|
|
|
/// 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
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_str("hello").unwrap();
|
|
/// assert_eq!(val, "hello");
|
|
/// ```
|
|
///
|
|
/// An invalid value
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_str("\n");
|
|
/// assert!(val.is_err());
|
|
/// ```
|
|
#[inline]
|
|
pub fn from_str(src: &str) -> Result<HeaderValue, InvalidHeaderValue> {
|
|
HeaderValue::try_from_generic(src, |s| Bytes::copy_from_slice(s.as_bytes()))
|
|
}
|
|
|
|
/// Converts a HeaderName into a HeaderValue
|
|
///
|
|
/// Since every valid HeaderName is a valid HeaderValue this is done infallibly.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use http::header::{HeaderValue, HeaderName};
|
|
/// # use http::header::ACCEPT;
|
|
/// let val = HeaderValue::from_name(ACCEPT);
|
|
/// assert_eq!(val, HeaderValue::from_bytes(b"accept").unwrap());
|
|
/// ```
|
|
#[inline]
|
|
pub fn from_name(name: HeaderName) -> HeaderValue {
|
|
name.into()
|
|
}
|
|
|
|
/// 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
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_bytes(b"hello\xfa").unwrap();
|
|
/// assert_eq!(val, &b"hello\xfa"[..]);
|
|
/// ```
|
|
///
|
|
/// An invalid value
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_bytes(b"\n");
|
|
/// assert!(val.is_err());
|
|
/// ```
|
|
#[inline]
|
|
pub fn from_bytes(src: &[u8]) -> Result<HeaderValue, InvalidHeaderValue> {
|
|
HeaderValue::try_from_generic(src, Bytes::copy_from_slice)
|
|
}
|
|
|
|
/// 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 fn from_maybe_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue>
|
|
where
|
|
T: AsRef<[u8]> + 'static,
|
|
{
|
|
if_downcast_into!(T, Bytes, src, {
|
|
return HeaderValue::from_shared(src);
|
|
});
|
|
|
|
HeaderValue::from_bytes(src.as_ref())
|
|
}
|
|
|
|
/// Convert a `Bytes` directly into a `HeaderValue` without validating.
|
|
///
|
|
/// This function does NOT validate that illegal bytes are not contained
|
|
/// within the buffer.
|
|
pub unsafe fn from_maybe_shared_unchecked<T>(src: T) -> HeaderValue
|
|
where
|
|
T: AsRef<[u8]> + 'static,
|
|
{
|
|
if cfg!(debug_assertions) {
|
|
match HeaderValue::from_maybe_shared(src) {
|
|
Ok(val) => val,
|
|
Err(_err) => {
|
|
panic!("HeaderValue::from_maybe_shared_unchecked() with invalid bytes");
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if_downcast_into!(T, Bytes, src, {
|
|
return HeaderValue {
|
|
inner: src,
|
|
is_sensitive: false,
|
|
};
|
|
});
|
|
|
|
let src = Bytes::copy_from_slice(src.as_ref());
|
|
HeaderValue {
|
|
inner: src,
|
|
is_sensitive: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn from_shared(src: Bytes) -> Result<HeaderValue, InvalidHeaderValue> {
|
|
HeaderValue::try_from_generic(src, std::convert::identity)
|
|
}
|
|
|
|
fn try_from_generic<T: AsRef<[u8]>, F: FnOnce(T) -> Bytes>(src: T, into: F) -> Result<HeaderValue, InvalidHeaderValue> {
|
|
for &b in src.as_ref() {
|
|
if !is_valid(b) {
|
|
return Err(InvalidHeaderValue { _priv: () });
|
|
}
|
|
}
|
|
Ok(HeaderValue {
|
|
inner: into(src),
|
|
is_sensitive: false,
|
|
})
|
|
}
|
|
|
|
/// 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
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_static("hello");
|
|
/// assert_eq!(val.to_str().unwrap(), "hello");
|
|
/// ```
|
|
pub fn to_str(&self) -> Result<&str, ToStrError> {
|
|
let bytes = self.as_ref();
|
|
|
|
for &b in bytes {
|
|
if !is_visible_ascii(b) {
|
|
return Err(ToStrError { _priv: () });
|
|
}
|
|
}
|
|
|
|
unsafe { Ok(str::from_utf8_unchecked(bytes)) }
|
|
}
|
|
|
|
/// Returns the length of `self`.
|
|
///
|
|
/// This length is in bytes.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_static("hello");
|
|
/// assert_eq!(val.len(), 5);
|
|
/// ```
|
|
#[inline]
|
|
pub fn len(&self) -> usize {
|
|
self.as_ref().len()
|
|
}
|
|
|
|
/// Returns true if the `HeaderValue` has a length of zero bytes.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_static("");
|
|
/// assert!(val.is_empty());
|
|
///
|
|
/// let val = HeaderValue::from_static("hello");
|
|
/// assert!(!val.is_empty());
|
|
/// ```
|
|
#[inline]
|
|
pub fn is_empty(&self) -> bool {
|
|
self.len() == 0
|
|
}
|
|
|
|
/// Converts a `HeaderValue` to a byte slice.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let val = HeaderValue::from_static("hello");
|
|
/// assert_eq!(val.as_bytes(), b"hello");
|
|
/// ```
|
|
#[inline]
|
|
pub fn as_bytes(&self) -> &[u8] {
|
|
self.as_ref()
|
|
}
|
|
|
|
/// Mark that the header value represents sensitive information.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let mut val = HeaderValue::from_static("my secret");
|
|
///
|
|
/// val.set_sensitive(true);
|
|
/// assert!(val.is_sensitive());
|
|
///
|
|
/// val.set_sensitive(false);
|
|
/// assert!(!val.is_sensitive());
|
|
/// ```
|
|
#[inline]
|
|
pub fn set_sensitive(&mut self, val: bool) {
|
|
self.is_sensitive = val;
|
|
}
|
|
|
|
/// 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
|
|
///
|
|
/// ```
|
|
/// # use http::header::HeaderValue;
|
|
/// let mut val = HeaderValue::from_static("my secret");
|
|
///
|
|
/// val.set_sensitive(true);
|
|
/// assert!(val.is_sensitive());
|
|
///
|
|
/// val.set_sensitive(false);
|
|
/// assert!(!val.is_sensitive());
|
|
/// ```
|
|
#[inline]
|
|
pub fn is_sensitive(&self) -> bool {
|
|
self.is_sensitive
|
|
}
|
|
}
|
|
|
|
impl AsRef<[u8]> for HeaderValue {
|
|
#[inline]
|
|
fn as_ref(&self) -> &[u8] {
|
|
self.inner.as_ref()
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for HeaderValue {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
if self.is_sensitive {
|
|
f.write_str("Sensitive")
|
|
} else {
|
|
f.write_str("\"")?;
|
|
let mut from = 0;
|
|
let bytes = self.as_bytes();
|
|
for (i, &b) in bytes.iter().enumerate() {
|
|
if !is_visible_ascii(b) || b == b'"' {
|
|
if from != i {
|
|
f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..i]) })?;
|
|
}
|
|
if b == b'"' {
|
|
f.write_str("\\\"")?;
|
|
} else {
|
|
write!(f, "\\x{:x}", b)?;
|
|
}
|
|
from = i + 1;
|
|
}
|
|
}
|
|
|
|
f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..]) })?;
|
|
f.write_str("\"")
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<HeaderName> for HeaderValue {
|
|
#[inline]
|
|
fn from(h: HeaderName) -> HeaderValue {
|
|
HeaderValue {
|
|
inner: h.into_bytes(),
|
|
is_sensitive: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! from_integers {
|
|
($($name:ident: $t:ident => $max_len:expr),*) => {$(
|
|
impl From<$t> for HeaderValue {
|
|
fn from(num: $t) -> HeaderValue {
|
|
let mut buf = if mem::size_of::<BytesMut>() - 1 < $max_len {
|
|
// On 32bit platforms, BytesMut max inline size
|
|
// is 15 bytes, but the $max_len could be bigger.
|
|
//
|
|
// The likelihood of the number *actually* being
|
|
// that big is very small, so only allocate
|
|
// if the number needs that space.
|
|
//
|
|
// The largest decimal number in 15 digits:
|
|
// It wold be 10.pow(15) - 1, but this is a constant
|
|
// version.
|
|
if num as u64 > 999_999_999_999_999_999 {
|
|
BytesMut::with_capacity($max_len)
|
|
} else {
|
|
// fits inline...
|
|
BytesMut::new()
|
|
}
|
|
} else {
|
|
// full value fits inline, so don't allocate!
|
|
BytesMut::new()
|
|
};
|
|
let _ = buf.write_str(::itoa::Buffer::new().format(num));
|
|
HeaderValue {
|
|
inner: buf.freeze(),
|
|
is_sensitive: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn $name() {
|
|
let n: $t = 55;
|
|
let val = HeaderValue::from(n);
|
|
assert_eq!(val, &n.to_string());
|
|
|
|
let n = ::std::$t::MAX;
|
|
let val = HeaderValue::from(n);
|
|
assert_eq!(val, &n.to_string());
|
|
}
|
|
)*};
|
|
}
|
|
|
|
from_integers! {
|
|
// integer type => maximum decimal length
|
|
|
|
// u8 purposely left off... HeaderValue::from(b'3') could be confusing
|
|
from_u16: u16 => 5,
|
|
from_i16: i16 => 6,
|
|
from_u32: u32 => 10,
|
|
from_i32: i32 => 11,
|
|
from_u64: u64 => 20,
|
|
from_i64: i64 => 20
|
|
}
|
|
|
|
#[cfg(target_pointer_width = "16")]
|
|
from_integers! {
|
|
from_usize: usize => 5,
|
|
from_isize: isize => 6
|
|
}
|
|
|
|
#[cfg(target_pointer_width = "32")]
|
|
from_integers! {
|
|
from_usize: usize => 10,
|
|
from_isize: isize => 11
|
|
}
|
|
|
|
#[cfg(target_pointer_width = "64")]
|
|
from_integers! {
|
|
from_usize: usize => 20,
|
|
from_isize: isize => 20
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod from_header_name_tests {
|
|
use super::*;
|
|
use crate::header::map::HeaderMap;
|
|
use crate::header::name;
|
|
|
|
#[test]
|
|
fn it_can_insert_header_name_as_header_value() {
|
|
let mut map = HeaderMap::new();
|
|
map.insert(name::UPGRADE, name::SEC_WEBSOCKET_PROTOCOL.into());
|
|
map.insert(
|
|
name::ACCEPT,
|
|
name::HeaderName::from_bytes(b"hello-world").unwrap().into(),
|
|
);
|
|
|
|
assert_eq!(
|
|
map.get(name::UPGRADE).unwrap(),
|
|
HeaderValue::from_bytes(b"sec-websocket-protocol").unwrap()
|
|
);
|
|
|
|
assert_eq!(
|
|
map.get(name::ACCEPT).unwrap(),
|
|
HeaderValue::from_bytes(b"hello-world").unwrap()
|
|
);
|
|
}
|
|
}
|
|
|
|
impl FromStr for HeaderValue {
|
|
type Err = InvalidHeaderValue;
|
|
|
|
#[inline]
|
|
fn from_str(s: &str) -> Result<HeaderValue, Self::Err> {
|
|
HeaderValue::from_str(s)
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a HeaderValue> for HeaderValue {
|
|
#[inline]
|
|
fn from(t: &'a HeaderValue) -> Self {
|
|
t.clone()
|
|
}
|
|
}
|
|
|
|
impl<'a> TryFrom<&'a str> for HeaderValue {
|
|
type Error = InvalidHeaderValue;
|
|
|
|
#[inline]
|
|
fn try_from(t: &'a str) -> Result<Self, Self::Error> {
|
|
t.parse()
|
|
}
|
|
}
|
|
|
|
impl<'a> TryFrom<&'a String> for HeaderValue {
|
|
type Error = InvalidHeaderValue;
|
|
#[inline]
|
|
fn try_from(s: &'a String) -> Result<Self, Self::Error> {
|
|
Self::from_bytes(s.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl<'a> TryFrom<&'a [u8]> for HeaderValue {
|
|
type Error = InvalidHeaderValue;
|
|
|
|
#[inline]
|
|
fn try_from(t: &'a [u8]) -> Result<Self, Self::Error> {
|
|
HeaderValue::from_bytes(t)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<String> for HeaderValue {
|
|
type Error = InvalidHeaderValue;
|
|
|
|
#[inline]
|
|
fn try_from(t: String) -> Result<Self, Self::Error> {
|
|
HeaderValue::from_shared(t.into())
|
|
}
|
|
}
|
|
|
|
impl TryFrom<Vec<u8>> for HeaderValue {
|
|
type Error = InvalidHeaderValue;
|
|
|
|
#[inline]
|
|
fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
|
|
HeaderValue::from_shared(vec.into())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod try_from_header_name_tests {
|
|
use super::*;
|
|
use crate::header::name;
|
|
|
|
#[test]
|
|
fn it_converts_using_try_from() {
|
|
assert_eq!(
|
|
HeaderValue::try_from(name::UPGRADE).unwrap(),
|
|
HeaderValue::from_bytes(b"upgrade").unwrap()
|
|
);
|
|
}
|
|
}
|
|
|
|
const fn is_visible_ascii(b: u8) -> bool {
|
|
b >= 32 && b < 127 || b == b'\t'
|
|
}
|
|
|
|
#[inline]
|
|
fn is_valid(b: u8) -> bool {
|
|
b >= 32 && b != 127 || b == b'\t'
|
|
}
|
|
|
|
impl fmt::Debug for InvalidHeaderValue {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
f.debug_struct("InvalidHeaderValue")
|
|
// skip _priv noise
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for InvalidHeaderValue {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.write_str("failed to parse header value")
|
|
}
|
|
}
|
|
|
|
impl Error for InvalidHeaderValue {}
|
|
|
|
impl fmt::Display for ToStrError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.write_str("failed to convert header to a str")
|
|
}
|
|
}
|
|
|
|
impl Error for ToStrError {}
|
|
|
|
// ===== PartialEq / PartialOrd =====
|
|
|
|
impl PartialEq for HeaderValue {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
self.inner == other.inner
|
|
}
|
|
}
|
|
|
|
impl Eq for HeaderValue {}
|
|
|
|
impl PartialOrd for HeaderValue {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
self.inner.partial_cmp(&other.inner)
|
|
}
|
|
}
|
|
|
|
impl Ord for HeaderValue {
|
|
#[inline]
|
|
fn cmp(&self, other: &Self) -> cmp::Ordering {
|
|
self.inner.cmp(&other.inner)
|
|
}
|
|
}
|
|
|
|
impl PartialEq<str> for HeaderValue {
|
|
#[inline]
|
|
fn eq(&self, other: &str) -> bool {
|
|
self.inner == other.as_bytes()
|
|
}
|
|
}
|
|
|
|
impl PartialEq<[u8]> for HeaderValue {
|
|
#[inline]
|
|
fn eq(&self, other: &[u8]) -> bool {
|
|
self.inner == other
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<str> for HeaderValue {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
|
|
(*self.inner).partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<[u8]> for HeaderValue {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
|
|
(*self.inner).partial_cmp(other)
|
|
}
|
|
}
|
|
|
|
impl PartialEq<HeaderValue> for str {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
*other == *self
|
|
}
|
|
}
|
|
|
|
impl PartialEq<HeaderValue> for [u8] {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
*other == *self
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<HeaderValue> for str {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
self.as_bytes().partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<HeaderValue> for [u8] {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
self.partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl PartialEq<String> for HeaderValue {
|
|
#[inline]
|
|
fn eq(&self, other: &String) -> bool {
|
|
*self == &other[..]
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<String> for HeaderValue {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
|
|
self.inner.partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl PartialEq<HeaderValue> for String {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
*other == *self
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<HeaderValue> for String {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
self.as_bytes().partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl<'a> PartialEq<HeaderValue> for &'a HeaderValue {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
**self == *other
|
|
}
|
|
}
|
|
|
|
impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
(**self).partial_cmp(other)
|
|
}
|
|
}
|
|
|
|
impl<'a, T: ?Sized> PartialEq<&'a T> for HeaderValue
|
|
where
|
|
HeaderValue: PartialEq<T>,
|
|
{
|
|
#[inline]
|
|
fn eq(&self, other: &&'a T) -> bool {
|
|
*self == **other
|
|
}
|
|
}
|
|
|
|
impl<'a, T: ?Sized> PartialOrd<&'a T> for HeaderValue
|
|
where
|
|
HeaderValue: PartialOrd<T>,
|
|
{
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
|
|
self.partial_cmp(*other)
|
|
}
|
|
}
|
|
|
|
impl<'a> PartialEq<HeaderValue> for &'a str {
|
|
#[inline]
|
|
fn eq(&self, other: &HeaderValue) -> bool {
|
|
*other == *self
|
|
}
|
|
}
|
|
|
|
impl<'a> PartialOrd<HeaderValue> for &'a str {
|
|
#[inline]
|
|
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
|
|
self.as_bytes().partial_cmp(other.as_bytes())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_try_from() {
|
|
HeaderValue::try_from(vec![127]).unwrap_err();
|
|
}
|
|
|
|
#[test]
|
|
fn test_debug() {
|
|
let cases = &[
|
|
("hello", "\"hello\""),
|
|
("hello \"world\"", "\"hello \\\"world\\\"\""),
|
|
("\u{7FFF}hello", "\"\\xe7\\xbf\\xbfhello\""),
|
|
];
|
|
|
|
for &(value, expected) in cases {
|
|
let val = HeaderValue::from_bytes(value.as_bytes()).unwrap();
|
|
let actual = format!("{:?}", val);
|
|
assert_eq!(expected, actual);
|
|
}
|
|
|
|
let mut sensitive = HeaderValue::from_static("password");
|
|
sensitive.set_sensitive(true);
|
|
assert_eq!("Sensitive", format!("{:?}", sensitive));
|
|
}
|