Merge pull request #109 from http-rs/header-values

Replace Vec<HeaderValue> with HeaderValues

Author: yoshuawuyts

src/headers/header_value.rs

@@ -1,6 +1,7 @@
 use std::fmt::{self, Display};
 use std::str::FromStr;
 
+use crate::headers::HeaderValues;
 use crate::Error;
 use crate::{Cookie, Mime};
 
@@ -119,3 +120,13 @@ impl<'a> PartialEq<&String> for HeaderValue {
         &&self.inner == other
     }
 }
+
+impl From<HeaderValues> for HeaderValue {
+    fn from(mut other: HeaderValues) -> Self {
+        other.inner.reverse();
+        other
+            .inner
+            .pop()
+            .expect("HeaderValues should contain at least one value")
+    }
+}

src/headers/header_values.rs

@@ -0,0 +1,149 @@
+use crate::headers::{HeaderValue, Values};
+
+use std::fmt::{self, Display};
+use std::iter::FromIterator;
+use std::ops::{Deref, DerefMut, Index};
+use std::slice::SliceIndex;
+
+/// A list of `HeaderValue`s.
+///
+/// This always contains at least one header value.
+#[derive(Debug, Clone)]
+pub struct HeaderValues {
+    pub(crate) inner: Vec<HeaderValue>,
+}
+
+impl HeaderValues {
+    /// Move all values from `other` into `self`, leaving `other` empty.
+    pub fn append(&mut self, other: &mut Self) {
+        self.inner.append(&mut other.inner)
+    }
+
+    /// Returns a reference or a value depending on the type of index.
+    pub fn get(&self, index: usize) -> Option<&HeaderValue> {
+        self.inner.get(index)
+    }
+
+    /// Returns a mutable reference or a value depending on the type of index.
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut HeaderValue> {
+        self.inner.get_mut(index)
+    }
+
+    /// Returns the last `HeaderValue`.
+    pub fn last(&self) -> &HeaderValue {
+        self.inner
+            .last()
+            .expect("HeaderValues must always contain at least one value")
+    }
+
+    /// An iterator visiting all header values in arbitrary order.
+    pub fn iter(&self) -> Values<'_> {
+        Values::new_values(&self)
+    }
+
+    // /// An iterator visiting all header values in arbitrary order, with mutable
+    // /// references to the values.
+    // pub fn iter_mut(&mut self) -> ValuesMut<'_> {
+    //     ValuesMut {
+    //         inner: self.headers.iter_mut(),
+    //     }
+    // }
+}
+
+impl<I: SliceIndex<[HeaderValue]>> Index<I> for HeaderValues {
+    type Output = I::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        Index::index(&self.inner, index)
+    }
+}
+
+impl FromIterator<HeaderValue> for HeaderValues {
+    fn from_iter<I>(iter: I) -> HeaderValues
+    where
+        I: IntoIterator<Item = HeaderValue>,
+    {
+        let iter = iter.into_iter();
+        let mut output = Vec::with_capacity(iter.size_hint().0);
+        for v in iter {
+            output.push(v);
+        }
+        HeaderValues { inner: output }
+    }
+}
+
+impl Display for HeaderValues {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut list = f.debug_list();
+        for v in &self.inner {
+            list.entry(&v);
+        }
+        list.finish()
+    }
+}
+
+impl PartialEq<str> for HeaderValues {
+    fn eq(&self, other: &str) -> bool {
+        self.inner[0] == other
+    }
+}
+
+impl<'a> PartialEq<&'a str> for HeaderValues {
+    fn eq(&self, other: &&'a str) -> bool {
+        &self.inner[0] == other
+    }
+}
+
+impl PartialEq<String> for HeaderValues {
+    fn eq(&self, other: &String) -> bool {
+        &self.inner[0] == other
+    }
+}
+
+impl<'a> PartialEq<&String> for HeaderValues {
+    fn eq(&self, other: &&String) -> bool {
+        &&self.inner[0] == other
+    }
+}
+
+impl From<HeaderValue> for HeaderValues {
+    fn from(other: HeaderValue) -> Self {
+        Self { inner: vec![other] }
+    }
+}
+
+impl AsRef<HeaderValue> for HeaderValues {
+    fn as_ref(&self) -> &HeaderValue {
+        &self.inner[0]
+    }
+}
+
+impl AsMut<HeaderValue> for HeaderValues {
+    fn as_mut(&mut self) -> &mut HeaderValue {
+        &mut self.inner[0]
+    }
+}
+impl Deref for HeaderValues {
+    type Target = HeaderValue;
+
+    fn deref(&self) -> &HeaderValue {
+        &self.inner[0]
+    }
+}
+
+impl DerefMut for HeaderValues {
+    fn deref_mut(&mut self) -> &mut HeaderValue {
+        &mut self.inner[0]
+    }
+}
+
+impl<'a> IntoIterator for &'a HeaderValues {
+    type Item = &'a HeaderValue;
+    type IntoIter = Values<'a>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}

src/headers/into_iter.rs

@@ -1,16 +1,16 @@
 use std::collections::hash_map;
 use std::iter::Iterator;
 
-use crate::headers::{HeaderName, HeaderValue};
+use crate::headers::{HeaderName, HeaderValues};
 
 /// An owning iterator over the entries of `Headers`.
 #[derive(Debug)]
 pub struct IntoIter {
-    pub(super) inner: hash_map::IntoIter<HeaderName, Vec<HeaderValue>>,
+    pub(super) inner: hash_map::IntoIter<HeaderName, HeaderValues>,
 }
 
 impl Iterator for IntoIter {
-    type Item = (HeaderName, Vec<HeaderValue>);
+    type Item = (HeaderName, HeaderValues);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()

src/headers/iter.rs

@@ -1,16 +1,16 @@
 use std::collections::hash_map;
 use std::iter::Iterator;
 
-use crate::headers::{HeaderName, HeaderValue};
+use crate::headers::{HeaderName, HeaderValues};
 
 /// Iterator over the headers.
 #[derive(Debug)]
 pub struct Iter<'a> {
-    pub(super) inner: hash_map::Iter<'a, HeaderName, Vec<HeaderValue>>,
+    pub(super) inner: hash_map::Iter<'a, HeaderName, HeaderValues>,
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a HeaderName, &'a Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a HeaderValues);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()

src/headers/iter_mut.rs

@@ -1,16 +1,16 @@
 use std::collections::hash_map;
 use std::iter::Iterator;
 
-use crate::headers::{HeaderName, HeaderValue};
+use crate::headers::{HeaderName, HeaderValues};
 
 /// Iterator over the headers.
 #[derive(Debug)]
 pub struct IterMut<'a> {
-    pub(super) inner: hash_map::IterMut<'a, HeaderName, Vec<HeaderValue>>,
+    pub(super) inner: hash_map::IterMut<'a, HeaderName, HeaderValues>,
 }
 
 impl<'a> Iterator for IterMut<'a> {
-    type Item = (&'a HeaderName, &'a mut Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a mut HeaderValues);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()

src/headers/mod.rs

@@ -7,6 +7,7 @@ use std::iter::IntoIterator;
 mod constants;
 mod header_name;
 mod header_value;
+mod header_values;
 mod into_iter;
 mod iter;
 mod iter_mut;
@@ -17,6 +18,7 @@ mod values;
 pub use constants::*;
 pub use header_name::HeaderName;
 pub use header_value::HeaderValue;
+pub use header_values::HeaderValues;
 pub use into_iter::IntoIter;
 pub use iter::Iter;
 pub use iter_mut::IterMut;
@@ -27,7 +29,7 @@ pub use values::Values;
 /// A collection of HTTP Headers.
 #[derive(Debug, Clone)]
 pub struct Headers {
-    pub(crate) headers: HashMap<HeaderName, Vec<HeaderValue>>,
+    pub(crate) headers: HashMap<HeaderName, HeaderValues>,
 }
 
 impl Headers {
@@ -47,11 +49,11 @@ impl Headers {
         &mut self,
         name: impl TryInto<HeaderName>,
         values: impl ToHeaderValues,
-    ) -> crate::Result<Option<Vec<HeaderValue>>> {
+    ) -> crate::Result<Option<HeaderValues>> {
         let name = name
             .try_into()
             .map_err(|_| crate::format_err!("Could not convert into header name"))?;
-        let values: Vec<HeaderValue> = values.to_header_values()?.collect();
+        let values: HeaderValues = values.to_header_values()?.collect();
         Ok(self.headers.insert(name, values))
     }
 
@@ -69,7 +71,7 @@ impl Headers {
             .map_err(|_| crate::format_err!("Could not convert into header name"))?;
         match self.get_mut(&name) {
             Some(headers) => {
-                let mut values: Vec<HeaderValue> = values.to_header_values()?.collect();
+                let mut values: HeaderValues = values.to_header_values()?.collect();
                 headers.append(&mut values);
             }
             None => {
@@ -80,17 +82,17 @@ impl Headers {
     }
 
     /// Get a reference to a header.
-    pub fn get(&self, name: &HeaderName) -> Option<&Vec<HeaderValue>> {
+    pub fn get(&self, name: &HeaderName) -> Option<&HeaderValues> {
         self.headers.get(name)
     }
 
     /// Get a mutable reference to a header.
-    pub fn get_mut(&mut self, name: &HeaderName) -> Option<&mut Vec<HeaderValue>> {
+    pub fn get_mut(&mut self, name: &HeaderName) -> Option<&mut HeaderValues> {
         self.headers.get_mut(name)
     }
 
     /// Remove a header.
-    pub fn remove(&mut self, name: &HeaderName) -> Option<Vec<HeaderValue>> {
+    pub fn remove(&mut self, name: &HeaderName) -> Option<HeaderValues> {
         self.headers.remove(name)
     }
 
@@ -123,7 +125,7 @@ impl Headers {
 }
 
 impl IntoIterator for Headers {
-    type Item = (HeaderName, Vec<HeaderValue>);
+    type Item = (HeaderName, HeaderValues);
     type IntoIter = IntoIter;
 
     /// Returns a iterator of references over the remaining items.
@@ -136,7 +138,7 @@ impl IntoIterator for Headers {
 }
 
 impl<'a> IntoIterator for &'a Headers {
-    type Item = (&'a HeaderName, &'a Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a HeaderValues);
     type IntoIter = Iter<'a>;
 
     #[inline]
@@ -146,7 +148,7 @@ impl<'a> IntoIterator for &'a Headers {
 }
 
 impl<'a> IntoIterator for &'a mut Headers {
-    type Item = (&'a HeaderName, &'a mut Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a mut HeaderValues);
     type IntoIter = IterMut<'a>;
 
     #[inline]

src/headers/names.rs

@@ -1,12 +1,12 @@
 use std::collections::hash_map;
 use std::iter::Iterator;
 
-use crate::headers::{HeaderName, HeaderValue};
+use crate::headers::{HeaderName, HeaderValues};
 
 /// Iterator over the headers.
 #[derive(Debug)]
 pub struct Names<'a> {
-    pub(super) inner: hash_map::Keys<'a, HeaderName, Vec<HeaderValue>>,
+    pub(super) inner: hash_map::Keys<'a, HeaderName, HeaderValues>,
 }
 
 impl<'a> Iterator for Names<'a> {