Initial impl of Values iter for HeaderValues

Author: yoshuawuyts

src/headers/header_values.rs

@@ -1,4 +1,5 @@
-use crate::headers::HeaderValue;
+use crate::headers::{HeaderValue, Values};
+
 use std::fmt::{self, Display};
 use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut, Index};
@@ -23,12 +24,30 @@ impl HeaderValues {
         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(&mut 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 {
@@ -118,3 +137,23 @@ impl DerefMut for HeaderValues {
         &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()
+    }
+}
+
+// impl<'a> IntoIterator for &'a mut HeaderValues {
+//     type Item = &'a HeaderValue;
+//     type IntoIter = ValuesMut<'a>;
+
+//     #[inline]
+//     fn into_iter(self) -> Self::IntoIter {
+//         self.iter_mut()
+//     }
+// }

src/headers/values.rs

@@ -6,19 +6,29 @@ use crate::headers::{HeaderName, HeaderValue, HeaderValues};
 /// Iterator over the header values.
 #[derive(Debug)]
 pub struct Values<'a> {
-    pub(super) inner: hash_map::Values<'a, HeaderName, HeaderValues>,
+    pub(super) inner: Option<hash_map::Values<'a, HeaderName, HeaderValues>>,
     slot: Option<&'a HeaderValues>,
     cursor: usize,
 }
 
 impl<'a> Values<'a> {
+    /// Constructor for `Headers`.
     pub(crate) fn new(inner: hash_map::Values<'a, HeaderName, HeaderValues>) -> Self {
         Self {
-            inner,
+            inner: Some(inner),
             slot: None,
             cursor: 0,
         }
     }
+
+    /// Constructor for `HeaderValues`.
+    pub(crate) fn new_values(values: &'a HeaderValues) -> Self {
+        Self {
+            inner: None,
+            slot: Some(values),
+            cursor: 0,
+        }
+    }
 }
 
 impl<'a> Iterator for Values<'a> {
@@ -28,7 +38,10 @@ impl<'a> Iterator for Values<'a> {
         loop {
             // Check if we have a vec in the current slot, and if not set one.
             if self.slot.is_none() {
-                let next = self.inner.next()?;
+                let next = match self.inner.as_mut() {
+                    Some(inner) => inner.next()?,
+                    None => return None,
+                };
                 self.cursor = 0;
                 self.slot = Some(next);
             }
@@ -51,6 +64,8 @@ impl<'a> Iterator for Values<'a> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
+        self.inner
+            .map(|inner| inner.size_hint())
+            .unwrap_or((0, None))
     }
 }