Implement HttpTryFrom<HashMap<String,String>> for HeaderMap

src/header/map.rs

@@ -1,5 +1,8 @@
 use super::HeaderValue;
 use super::name::{HeaderName, HdrName, InvalidHeaderName};
+use convert::{HttpTryFrom, HttpTryInto};
+use Error;
+use sealed::Sealed;
 
 use std::{fmt, mem, ops, ptr, vec};
 use std::collections::hash_map::RandomState;
@@ -23,10 +26,11 @@ pub use self::into_header_name::IntoHeaderName;
 /// ```
 /// # use http::HeaderMap;
 /// # use http::header::{CONTENT_LENGTH, HOST, LOCATION};
-/// let mut headers = HeaderMap::new();
-///
-/// headers.insert(HOST, "example.com".parse().unwrap());
-/// headers.insert(CONTENT_LENGTH, "123".parse().unwrap());
+/// # use http::HttpTryFrom;
+/// let mut headers = HeaderMap::try_from(vec![
+///     (HOST, "example.com"),
+///     (CONTENT_LENGTH, "123")
+/// ]).unwrap();
 ///
 /// assert!(headers.contains_key(HOST));
 /// assert!(!headers.contains_key(LOCATION));
@@ -1720,6 +1724,45 @@ impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>
     }
 }
 
+impl<T> Sealed for HeaderMap<T> {}
+
+/// Convert a collection of tuples into a HeaderMap
+///
+/// # Examples
+///
+/// ```
+/// # use http::{HttpTryFrom, Result, header::HeaderMap};
+/// # use std::collections::HashMap;
+/// let mut headers_hashmap: HashMap<String, String> = vec![
+///     ("X-Custom-Header".to_string(), "my value".to_string()),
+/// ].iter().cloned().collect();
+///
+/// let good_headers: Result<HeaderMap> = HeaderMap::try_from(&headers_hashmap);
+/// assert!(good_headers.is_ok());
+///
+/// headers_hashmap.insert("\r".into(), "\0".into());
+/// let bad_headers: Result<HeaderMap> = HeaderMap::try_from(&headers_hashmap);
+/// assert!(bad_headers.is_err());
+/// ```
+impl<COLLECTION, K, V> HttpTryFrom<COLLECTION> for HeaderMap<HeaderValue>
+    where
+        COLLECTION: IntoIterator<Item=(K, V)>,
+        HeaderName: HttpTryFrom<K>,
+        HeaderValue: HttpTryFrom<V>
+{
+    type Error = Error;
+
+    fn try_from(c: COLLECTION) -> Result<Self, Self::Error> {
+        c.into_iter()
+            .map(|(k, v)| -> ::Result<(HeaderName, HeaderValue)> {
+                let name : HeaderName = k.http_try_into()?;
+                let value : HeaderValue = v.http_try_into()?;
+                Ok((name, value))
+            })
+            .collect()
+    }
+}
+
 impl<T> Extend<(Option<HeaderName>, T)> for HeaderMap<T> {
     /// Extend a `HeaderMap` with the contents of another `HeaderMap`.
     ///

src/header/name.rs

@@ -1772,6 +1772,14 @@ impl<'a> HttpTryFrom<&'a str> for HeaderName {
     }
 }
 
+impl<'a> HttpTryFrom<&'a String> for HeaderName {
+    type Error = InvalidHeaderName;
+    #[inline]
+    fn try_from(s: &'a String) -> Result<Self, Self::Error> {
+        Self::from_bytes(s.as_bytes())
+    }
+}
+
 impl<'a> HttpTryFrom<&'a [u8]> for HeaderName {
     type Error = InvalidHeaderName;
     #[inline]

src/header/value.rs

@@ -521,6 +521,14 @@ impl<'a> HttpTryFrom<&'a str> for HeaderValue {
     }
 }
 
+impl<'a> HttpTryFrom<&'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> HttpTryFrom<&'a [u8]> for HeaderValue {
     type Error = InvalidHeaderValue;