Allow header access by indexing

This allows using the `[name]` syntax to get a header from a struct. This is implemented for Request, Response, Headers, and Trailers.

IndexMut for assignment wasn't added because it can only be used to override existing values, which might be tricky.

Author: yoshuawuyts

src/headers/headers.rs

@@ -3,12 +3,29 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 use std::iter::IntoIterator;
+use std::ops::Index;
+use std::str::FromStr;
 
 use crate::headers::{
     HeaderName, HeaderValues, IntoIter, Iter, IterMut, Names, ToHeaderValues, Values,
 };
 
 /// A collection of HTTP Headers.
+///
+/// Headers are never manually constructed, but are part of `Request`,
+/// `Response`, and `Trailers`. Each of these types implements `AsRef<Headers>`
+/// and `AsMut<Headers>` so functions that want to modify headers can be generic
+/// over either of these traits.
+///
+/// # Examples
+///
+/// ```
+/// use http_types::{Response, StatusCode};
+///
+/// let mut res = Response::new(StatusCode::Ok);
+/// res.insert_header("hello", "foo0").unwrap();
+/// assert_eq!(res["hello"], "foo0");
+/// ```
 #[derive(Debug, Clone)]
 pub struct Headers {
     pub(crate) headers: HashMap<HeaderName, HeaderValues>,
@@ -106,6 +123,35 @@ impl Headers {
     }
 }
 
+impl Index<&HeaderName> for Headers {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Headers`.
+    #[inline]
+    fn index(&self, name: &HeaderName) -> &HeaderValues {
+        self.get(name).expect("no entry found for name")
+    }
+}
+
+impl Index<&str> for Headers {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Headers`.
+    #[inline]
+    fn index(&self, name: &str) -> &HeaderValues {
+        let name = HeaderName::from_str(name).expect("string slice needs to be valid ASCII");
+        self.get(&name).expect("no entry found for name")
+    }
+}
+
 impl IntoIterator for Headers {
     type Item = (HeaderName, HeaderValues);
     type IntoIter = IntoIter;
@@ -173,4 +219,11 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn index_into_headers() {
+        let mut headers = Headers::new();
+        headers.insert("hello", "foo0").unwrap();
+        assert_eq!(headers["hello"], "foo0");
+    }
 }

src/request.rs

@@ -3,6 +3,7 @@ use async_std::sync;
 
 use std::convert::TryInto;
 use std::mem;
+use std::ops::Index;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -484,6 +485,34 @@ impl From<Request> for Body {
     }
 }
 
+impl Index<&HeaderName> for Request {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Request`.
+    #[inline]
+    fn index(&self, name: &HeaderName) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
+
+impl Index<&str> for Request {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Request`.
+    #[inline]
+    fn index(&self, name: &str) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
+
 impl IntoIterator for Request {
     type Item = (HeaderName, HeaderValues);
     type IntoIter = headers::IntoIter;

src/response.rs

@@ -3,6 +3,7 @@ use async_std::sync;
 
 use std::convert::TryInto;
 use std::mem;
+use std::ops::Index;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -448,6 +449,33 @@ impl From<()> for Response {
         Response::new(StatusCode::NoContent)
     }
 }
+impl Index<&HeaderName> for Response {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Response`.
+    #[inline]
+    fn index(&self, name: &HeaderName) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
+
+impl Index<&str> for Response {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Response`.
+    #[inline]
+    fn index(&self, name: &str) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
 
 impl From<StatusCode> for Response {
     fn from(s: StatusCode) -> Self {

src/trailers.rs

@@ -55,7 +55,7 @@ use async_std::sync;
 
 use std::convert::TryInto;
 use std::future::Future;
-use std::ops::{Deref, DerefMut};
+use std::ops::{Deref, DerefMut, Index};
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -181,6 +181,34 @@ impl DerefMut for Trailers {
     }
 }
 
+impl Index<&HeaderName> for Trailers {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Trailers`.
+    #[inline]
+    fn index(&self, name: &HeaderName) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
+
+impl Index<&str> for Trailers {
+    type Output = HeaderValues;
+
+    /// Returns a reference to the value corresponding to the supplied name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not present in `Trailers`.
+    #[inline]
+    fn index(&self, name: &str) -> &HeaderValues {
+        self.headers.index(name)
+    }
+}
+
 /// The sending half of a channel to send trailers.
 ///
 /// Unlike `async_std::sync::channel` the `send` method on this type can only be