From 1c27e2d54e78649297ea9f212bfcc9d78e5076d4 Mon Sep 17 00:00:00 2001 From: Nathaniel McCallum Date: Thu, 5 May 2022 22:11:03 -0400 Subject: [PATCH] refactor: split the `Header` trait into three traits The `Header` trait is now `Named`, `Decodable` and `Encodable`. The goal of this change is to make it possible to implement `Encodable` for borrowed types. Under the existing code, `Header::decode()` requires that `Self` own its data. But it is a legitimate use to do `Header::encode()` on borrowed data. By separating the traits, we can implement `Encodable` on borrowed types and `Encodable` and `Decodable` on owned types. Signed-off-by: Nathaniel McCallum --- headers-core/src/lib.rs | 51 +++++++++++++++++++ .../access_control_allow_credentials.rs | 9 +++- src/common/access_control_request_method.rs | 10 +++- src/common/authorization.rs | 11 +++- src/common/cache_control.rs | 8 ++- src/common/content_disposition.rs | 8 ++- src/common/content_length.rs | 9 +++- src/common/content_range.rs | 42 ++++++++------- src/common/content_type.rs | 8 ++- src/common/expect.rs | 8 ++- src/common/host.rs | 10 +++- src/common/mod.rs | 4 +- src/common/proxy_authorization.rs | 7 ++- src/common/range.rs | 8 ++- src/common/sec_websocket_version.rs | 8 ++- src/common/set_cookie.rs | 8 ++- src/common/strict_transport_security.rs | 8 ++- src/lib.rs | 15 ++++-- src/map_ext.rs | 31 ++++------- src/util/mod.rs | 6 ++- 20 files changed, 203 insertions(+), 66 deletions(-) diff --git a/headers-core/src/lib.rs b/headers-core/src/lib.rs index 92e3d15e..4d919193 100644 --- a/headers-core/src/lib.rs +++ b/headers-core/src/lib.rs @@ -15,10 +15,36 @@ pub use http::header::{self, HeaderName, HeaderValue}; use std::error; use std::fmt::{self, Display, Formatter}; +/// Associates a header name with a Rust type. +pub trait Named { + /// The name of this header. + fn name() -> &'static HeaderName; +} + +/// Decodes a header into a Rust type. +pub trait Decodable: Named { + /// Decode this type from an iterator of `HeaderValue`s. + fn decode<'i, I>(values: &mut I) -> Result + where + Self: Sized, + I: Iterator; +} + +/// Encodes a header into a Rust type. +pub trait Encodable: Named { + /// Encode this type to a `HeaderMap`. + /// + /// This function should be infallible. Any errors converting to a + /// `HeaderValue` should have been caught when parsing or constructing + /// this value. + fn encode>(&self, values: &mut E); +} + /// A trait for any object that will represent a header field and value. /// /// This trait represents the construction and identification of headers, /// and contains trait-object unsafe methods. +#[deprecated] pub trait Header { /// The name of this header. fn name() -> &'static HeaderName; @@ -37,6 +63,31 @@ pub trait Header { fn encode>(&self, values: &mut E); } +#[allow(deprecated)] +impl Named for T { + fn name() -> &'static HeaderName { + T::name() + } +} + +#[allow(deprecated)] +impl Decodable for T { + fn decode<'i, I>(values: &mut I) -> Result + where + Self: Sized, + I: Iterator, + { + T::decode(values) + } +} + +#[allow(deprecated)] +impl Encodable for T { + fn encode>(&self, values: &mut E) { + self.encode(values) + } +} + /// Errors trying to decode a header. #[derive(Debug)] pub struct Error { diff --git a/src/common/access_control_allow_credentials.rs b/src/common/access_control_allow_credentials.rs index 583f310a..1e737aa9 100644 --- a/src/common/access_control_allow_credentials.rs +++ b/src/common/access_control_allow_credentials.rs @@ -1,4 +1,5 @@ -use {Header, HeaderName, HeaderValue}; +use crate::core::{Decodable, Encodable, Named}; +use crate::{HeaderName, HeaderValue}; /// `Access-Control-Allow-Credentials` header, part of /// [CORS](http://www.w3.org/TR/cors/#access-control-allow-headers-response-header) @@ -33,11 +34,13 @@ use {Header, HeaderName, HeaderValue}; #[derive(Clone, PartialEq, Eq, Debug)] pub struct AccessControlAllowCredentials; -impl Header for AccessControlAllowCredentials { +impl Named for AccessControlAllowCredentials { fn name() -> &'static HeaderName { &::http::header::ACCESS_CONTROL_ALLOW_CREDENTIALS } +} +impl Decodable for AccessControlAllowCredentials { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -50,7 +53,9 @@ impl Header for AccessControlAllowCredentials { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for AccessControlAllowCredentials { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(HeaderValue::from_static("true"))); } diff --git a/src/common/access_control_request_method.rs b/src/common/access_control_request_method.rs index f922f0b5..15c59bd1 100644 --- a/src/common/access_control_request_method.rs +++ b/src/common/access_control_request_method.rs @@ -1,5 +1,7 @@ +use crate::core::{Decodable, Encodable, Named}; +use crate::{HeaderName, HeaderValue}; + use http::Method; -use {Header, HeaderName, HeaderValue}; /// `Access-Control-Request-Method` header, part of /// [CORS](http://www.w3.org/TR/cors/#access-control-request-method-request-header) @@ -28,11 +30,13 @@ use {Header, HeaderName, HeaderValue}; #[derive(Clone, Debug, PartialEq, Eq, Hash)] pub struct AccessControlRequestMethod(Method); -impl Header for AccessControlRequestMethod { +impl Named for AccessControlRequestMethod { fn name() -> &'static HeaderName { &::http::header::ACCESS_CONTROL_REQUEST_METHOD } +} +impl Decodable for AccessControlRequestMethod { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -40,7 +44,9 @@ impl Header for AccessControlRequestMethod { .map(AccessControlRequestMethod) .ok_or_else(::Error::invalid) } +} +impl Encodable for AccessControlRequestMethod { fn encode>(&self, values: &mut E) { // For the more common methods, try to use a static string. let s = match self.0 { diff --git a/src/common/authorization.rs b/src/common/authorization.rs index dbef1530..95b13ffb 100644 --- a/src/common/authorization.rs +++ b/src/common/authorization.rs @@ -1,5 +1,7 @@ //! Authorization header and types. +use crate::core::{Decodable, Encodable, Named}; + use base64; use bytes::Bytes; @@ -71,11 +73,13 @@ impl Authorization { } } -impl ::Header for Authorization { +impl Named for Authorization { fn name() -> &'static ::HeaderName { &::http::header::AUTHORIZATION } +} +impl Decodable for Authorization { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -92,7 +96,9 @@ impl ::Header for Authorization { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for Authorization { fn encode>(&self, values: &mut E) { let value = self.0.encode(); debug_assert!( @@ -171,7 +177,8 @@ impl Credentials for Basic { base64::encode_config_buf(&self.decoded, base64::STANDARD, &mut encoded); let bytes = Bytes::from(encoded); - HeaderValue::from_maybe_shared(bytes).expect("base64 encoding is always a valid HeaderValue") + HeaderValue::from_maybe_shared(bytes) + .expect("base64 encoding is always a valid HeaderValue") } } diff --git a/src/common/cache_control.rs b/src/common/cache_control.rs index 305361d3..67ba8379 100644 --- a/src/common/cache_control.rs +++ b/src/common/cache_control.rs @@ -3,6 +3,8 @@ use std::iter::FromIterator; use std::str::FromStr; use std::time::Duration; +use crate::core::{Decodable, Encodable, Named}; + use util::{self, csv, Seconds}; use HeaderValue; @@ -183,15 +185,19 @@ impl CacheControl { } } -impl ::Header for CacheControl { +impl Named for CacheControl { fn name() -> &'static ::HeaderName { &::http::header::CACHE_CONTROL } +} +impl Decodable for CacheControl { fn decode<'i, I: Iterator>(values: &mut I) -> Result { csv::from_comma_delimited(values).map(|FromIter(cc)| cc) } +} +impl Encodable for CacheControl { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(util::fmt(Fmt(self)))); } diff --git a/src/common/content_disposition.rs b/src/common/content_disposition.rs index 5c1ea0f7..6ee09dde 100644 --- a/src/common/content_disposition.rs +++ b/src/common/content_disposition.rs @@ -6,6 +6,8 @@ // Browser conformance tests at: http://greenbytes.de/tech/tc2231/ // IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml +use crate::core::{Decodable, Encodable, Named}; + /// A `Content-Disposition` header, (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266). /// /// The Content-Disposition response header field is used to convey @@ -89,11 +91,13 @@ impl ContentDisposition { } } -impl ::Header for ContentDisposition { +impl Named for ContentDisposition { fn name() -> &'static ::HeaderName { &::http::header::CONTENT_DISPOSITION } +} +impl Decodable for ContentDisposition { fn decode<'i, I: Iterator>(values: &mut I) -> Result { //TODO: parse harder values @@ -102,7 +106,9 @@ impl ::Header for ContentDisposition { .map(ContentDisposition) .ok_or_else(::Error::invalid) } +} +impl Encodable for ContentDisposition { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(self.0.clone())); } diff --git a/src/common/content_length.rs b/src/common/content_length.rs index ff8c5423..2b3be016 100644 --- a/src/common/content_length.rs +++ b/src/common/content_length.rs @@ -1,4 +1,5 @@ -use {Header, HeaderValue}; +use crate::core::{Decodable, Encodable, Named}; +use crate::HeaderValue; /// `Content-Length` header, defined in /// [RFC7230](http://tools.ietf.org/html/rfc7230#section-3.3.2) @@ -40,11 +41,13 @@ use {Header, HeaderValue}; #[derive(Clone, Copy, Debug, PartialEq)] pub struct ContentLength(pub u64); -impl Header for ContentLength { +impl Named for ContentLength { fn name() -> &'static ::http::header::HeaderName { &::http::header::CONTENT_LENGTH } +} +impl Decodable for ContentLength { fn decode<'i, I: Iterator>(values: &mut I) -> Result { // If multiple Content-Length headers were sent, everything can still // be alright if they all contain the same value, and all parse @@ -68,7 +71,9 @@ impl Header for ContentLength { len.map(ContentLength).ok_or_else(::Error::invalid) } +} +impl Encodable for ContentLength { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(self.0.into())); } diff --git a/src/common/content_range.rs b/src/common/content_range.rs index 7ed2b200..e29dcfc2 100644 --- a/src/common/content_range.rs +++ b/src/common/content_range.rs @@ -1,7 +1,8 @@ use std::fmt; use std::ops::{Bound, RangeBounds}; -use {util, HeaderValue}; +use crate::core::{Decodable, Encodable, Named}; +use crate::{util, HeaderValue}; /// Content-Range, described in [RFC7233](https://tools.ietf.org/html/rfc7233#section-4.2) /// @@ -98,11 +99,13 @@ impl ContentRange { } } -impl ::Header for ContentRange { +impl Named for ContentRange { fn name() -> &'static ::HeaderName { &::http::header::CONTENT_RANGE } +} +impl Decodable for ContentRange { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -141,7 +144,9 @@ impl ::Header for ContentRange { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for ContentRange { fn encode>(&self, values: &mut E) { struct Adapter<'a>(&'a ContentRange); @@ -178,22 +183,23 @@ fn split_in_two(s: &str, separator: char) -> Option<(&str, &str)> { } /* - test_header!(test_bytes, - vec![b"bytes 0-499/500"], - Some(ContentRange(ContentRangeSpec::Bytes { - range: Some((0, 499)), - complete_length: Some(500) - }))); - - test_header!(test_bytes_unknown_len, - vec![b"bytes 0-499/*"], - Some(ContentRange(ContentRangeSpec::Bytes { - range: Some((0, 499)), - complete_length: None - }))); - - test_header!(test_bytes_unknown_range, - vec![b"bytes */500"], +test_header!(test_bytes, + vec![b"bytes 0-499/500"], + Some(ContentRange(ContentRangeSpec::Bytes { + range: Some((0, 499)), + complete_length: Some(500) + }))); + +test_header!(test_bytes_unknown_len, + vec![b"bytes 0-499/*"], + Some(ContentRange(ContentRangeSpec::Bytes { + range: Some((0, 499)), + complete_length: None + }))); + +test_header!(test_bytes_unknown_range, + vec![b"bytes */ +500"], Some(ContentRange(ContentRangeSpec::Bytes { range: None, complete_length: Some(500) diff --git a/src/common/content_type.rs b/src/common/content_type.rs index bfe56527..3fb6c82f 100644 --- a/src/common/content_type.rs +++ b/src/common/content_type.rs @@ -1,5 +1,7 @@ use std::fmt; +use crate::core::{Decodable, Encodable, Named}; + use mime::{self, Mime}; /// `Content-Type` header, defined in @@ -94,11 +96,13 @@ impl ContentType { } } -impl ::Header for ContentType { +impl Named for ContentType { fn name() -> &'static ::HeaderName { &::http::header::CONTENT_TYPE } +} +impl Decodable for ContentType { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -106,7 +110,9 @@ impl ::Header for ContentType { .map(ContentType) .ok_or_else(::Error::invalid) } +} +impl Encodable for ContentType { fn encode>(&self, values: &mut E) { let value = self .0 diff --git a/src/common/expect.rs b/src/common/expect.rs index a1caf253..c3715343 100644 --- a/src/common/expect.rs +++ b/src/common/expect.rs @@ -1,5 +1,7 @@ use std::fmt; +use crate::core::{Decodable, Encodable, Named}; + use util::IterExt; /// The `Expect` header. @@ -27,11 +29,13 @@ impl Expect { pub const CONTINUE: Expect = Expect(()); } -impl ::Header for Expect { +impl Named for Expect { fn name() -> &'static ::HeaderName { &::http::header::EXPECT } +} +impl Decodable for Expect { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .just_one() @@ -44,7 +48,9 @@ impl ::Header for Expect { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for Expect { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(::HeaderValue::from_static( "100-continue", diff --git a/src/common/host.rs b/src/common/host.rs index a5c41b1d..a11b0ccb 100644 --- a/src/common/host.rs +++ b/src/common/host.rs @@ -1,5 +1,7 @@ -use std::fmt; use std::convert::TryFrom; +use std::fmt; + +use crate::core::{Decodable, Encodable, Named}; use http::uri::Authority; @@ -19,11 +21,13 @@ impl Host { } } -impl ::Header for Host { +impl Named for Host { fn name() -> &'static ::HeaderName { &::http::header::HOST } +} +impl Decodable for Host { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -32,7 +36,9 @@ impl ::Header for Host { .map(Host) .ok_or_else(::Error::invalid) } +} +impl Encodable for Host { fn encode>(&self, values: &mut E) { let bytes = self.0.as_str().as_bytes(); let val = ::HeaderValue::from_bytes(bytes).expect("Authority is a valid HeaderValue"); diff --git a/src/common/mod.rs b/src/common/mod.rs index 2237ae8e..aa04ca97 100644 --- a/src/common/mod.rs +++ b/src/common/mod.rs @@ -70,7 +70,7 @@ pub use self::vary::Vary; //pub use self::warning::Warning; #[cfg(test)] -fn test_decode(values: &[&str]) -> Option { +fn test_decode(values: &[&str]) -> Option { use HeaderMapExt; let mut map = ::http::HeaderMap::new(); for val in values { @@ -80,7 +80,7 @@ fn test_decode(values: &[&str]) -> Option { } #[cfg(test)] -fn test_encode(header: T) -> ::http::HeaderMap { +fn test_encode(header: T) -> ::http::HeaderMap { use HeaderMapExt; let mut map = ::http::HeaderMap::new(); map.typed_insert(header); diff --git a/src/common/proxy_authorization.rs b/src/common/proxy_authorization.rs index 50a6b0a4..57ddb4e7 100644 --- a/src/common/proxy_authorization.rs +++ b/src/common/proxy_authorization.rs @@ -1,4 +1,5 @@ use super::authorization::{Authorization, Credentials}; +use crate::core::{Decodable, Encodable, Named}; /// `Proxy-Authorization` header, defined in [RFC7235](https://tools.ietf.org/html/rfc7235#section-4.4) /// @@ -24,15 +25,19 @@ use super::authorization::{Authorization, Credentials}; #[derive(Clone, PartialEq, Debug)] pub struct ProxyAuthorization(pub C); -impl ::Header for ProxyAuthorization { +impl Named for ProxyAuthorization { fn name() -> &'static ::HeaderName { &::http::header::PROXY_AUTHORIZATION } +} +impl Decodable for ProxyAuthorization { fn decode<'i, I: Iterator>(values: &mut I) -> Result { Authorization::decode(values).map(|auth| ProxyAuthorization(auth.0)) } +} +impl Encodable for ProxyAuthorization { fn encode>(&self, values: &mut E) { let value = self.0.encode(); debug_assert!( diff --git a/src/common/range.rs b/src/common/range.rs index 29cc79d3..2a631f04 100644 --- a/src/common/range.rs +++ b/src/common/range.rs @@ -1,5 +1,7 @@ use std::ops::{Bound, RangeBounds}; +use crate::core::{Decodable, Encodable, Named}; + /// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1) /// /// The "Range" header field on a GET request modifies the method @@ -83,11 +85,13 @@ fn parse_bound(s: &str) -> Option> { s.parse().ok().map(Bound::Included) } -impl ::Header for Range { +impl Named for Range { fn name() -> &'static ::HeaderName { &::http::header::RANGE } +} +impl Decodable for Range { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -100,7 +104,9 @@ impl ::Header for Range { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for Range { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once(self.0.clone())); } diff --git a/src/common/sec_websocket_version.rs b/src/common/sec_websocket_version.rs index d20c49c7..7e38dd6d 100644 --- a/src/common/sec_websocket_version.rs +++ b/src/common/sec_websocket_version.rs @@ -1,3 +1,5 @@ +use crate::core::{Decodable, Encodable, Named}; + /// The `Sec-Websocket-Version` header. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SecWebsocketVersion(u8); @@ -7,11 +9,13 @@ impl SecWebsocketVersion { pub const V13: SecWebsocketVersion = SecWebsocketVersion(13); } -impl ::Header for SecWebsocketVersion { +impl Named for SecWebsocketVersion { fn name() -> &'static ::HeaderName { &::http::header::SEC_WEBSOCKET_VERSION } +} +impl Decodable for SecWebsocketVersion { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .next() @@ -24,7 +28,9 @@ impl ::Header for SecWebsocketVersion { }) .ok_or_else(::Error::invalid) } +} +impl Encodable for SecWebsocketVersion { fn encode>(&self, values: &mut E) { debug_assert_eq!(self.0, 13); diff --git a/src/common/set_cookie.rs b/src/common/set_cookie.rs index 32876ac7..1b243c30 100644 --- a/src/common/set_cookie.rs +++ b/src/common/set_cookie.rs @@ -1,3 +1,5 @@ +use crate::core::{Decodable, Encodable, Named}; + /// `Set-Cookie` header, defined [RFC6265](http://tools.ietf.org/html/rfc6265#section-4.1) /// /// The Set-Cookie HTTP response header is used to send cookies from the @@ -54,11 +56,13 @@ #[derive(Clone, Debug)] pub struct SetCookie(Vec<::HeaderValue>); -impl ::Header for SetCookie { +impl Named for SetCookie { fn name() -> &'static ::HeaderName { &::http::header::SET_COOKIE } +} +impl Decodable for SetCookie { fn decode<'i, I: Iterator>(values: &mut I) -> Result { let vec = values.cloned().collect::>(); @@ -68,7 +72,9 @@ impl ::Header for SetCookie { Err(::Error::invalid()) } } +} +impl Encodable for SetCookie { fn encode>(&self, values: &mut E) { values.extend(self.0.iter().cloned()); } diff --git a/src/common/strict_transport_security.rs b/src/common/strict_transport_security.rs index 628b8004..ad5da368 100644 --- a/src/common/strict_transport_security.rs +++ b/src/common/strict_transport_security.rs @@ -1,6 +1,8 @@ use std::fmt; use std::time::Duration; +use crate::core::{Decodable, Encodable, Named}; + use util::{self, IterExt, Seconds}; /// `StrictTransportSecurity` header, defined in [RFC6797](https://tools.ietf.org/html/rfc6797) @@ -129,11 +131,13 @@ fn from_str(s: &str) -> Result { .ok_or_else(::Error::invalid) } -impl ::Header for StrictTransportSecurity { +impl Named for StrictTransportSecurity { fn name() -> &'static ::HeaderName { &::http::header::STRICT_TRANSPORT_SECURITY } +} +impl Decodable for StrictTransportSecurity { fn decode<'i, I: Iterator>(values: &mut I) -> Result { values .just_one() @@ -141,7 +145,9 @@ impl ::Header for StrictTransportSecurity { .map(from_str) .unwrap_or_else(|| Err(::Error::invalid())) } +} +impl Encodable for StrictTransportSecurity { fn encode>(&self, values: &mut E) { struct Adapter<'a>(&'a StrictTransportSecurity); diff --git a/src/lib.rs b/src/lib.rs index 18dd8c19..8a74214e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,7 +20,7 @@ //! //! # Defining Custom Headers //! -//! ## Implementing the `Header` trait +//! ## Implementing the header traits //! //! Consider a Do Not Track header. It can be true or false, but it represents //! that via the numerals `1` and `0`. @@ -29,15 +29,18 @@ //! extern crate http; //! extern crate headers; //! -//! use headers::{Header, HeaderName, HeaderValue}; +//! use headers::{HeaderName, HeaderValue}; +//! use headers::core::{Decodable, Encodable, Named}; //! //! struct Dnt(bool); //! -//! impl Header for Dnt { +//! impl Named for Dnt { //! fn name() -> &'static HeaderName { //! &http::header::DNT //! } +//! } //! +//! impl Decodable for Dnt { //! fn decode<'i, I>(values: &mut I) -> Result //! where //! I: Iterator, @@ -54,7 +57,9 @@ //! Err(headers::Error::invalid()) //! } //! } +//! } //! +//! impl Encodable for Dnt { //! fn encode(&self, values: &mut E) //! where //! E: Extend, @@ -76,7 +81,7 @@ extern crate base64; #[macro_use] extern crate bitflags; extern crate bytes; -extern crate headers_core; +pub extern crate headers_core; extern crate http; extern crate httpdate; extern crate mime; @@ -84,6 +89,8 @@ extern crate sha1; #[cfg(all(test, feature = "nightly"))] extern crate test; +pub use headers_core as core; +#[allow(deprecated)] pub use headers_core::{Error, Header}; #[doc(hidden)] diff --git a/src/map_ext.rs b/src/map_ext.rs index e80ccda9..420bf958 100644 --- a/src/map_ext.rs +++ b/src/map_ext.rs @@ -1,29 +1,22 @@ -use super::{Error, Header, HeaderValue}; +use super::{Error, HeaderValue}; +use crate::core::{Decodable, Encodable}; + use http; /// An extension trait adding "typed" methods to `http::HeaderMap`. pub trait HeaderMapExt: self::sealed::Sealed { /// Inserts the typed `Header` into this `HeaderMap`. - fn typed_insert(&mut self, header: H) - where - H: Header; + fn typed_insert(&mut self, header: H); /// Tries to find the header by name, and then decode it into `H`. - fn typed_get(&self) -> Option - where - H: Header; + fn typed_get(&self) -> Option; /// Tries to find the header by name, and then decode it into `H`. - fn typed_try_get(&self) -> Result, Error> - where - H: Header; + fn typed_try_get(&self) -> Result, Error>; } impl HeaderMapExt for http::HeaderMap { - fn typed_insert(&mut self, header: H) - where - H: Header, - { + fn typed_insert(&mut self, header: H) { let entry = self.entry(H::name()); let mut values = ToValues { state: State::First(entry), @@ -31,17 +24,11 @@ impl HeaderMapExt for http::HeaderMap { header.encode(&mut values); } - fn typed_get(&self) -> Option - where - H: Header, - { + fn typed_get(&self) -> Option { HeaderMapExt::typed_try_get(self).unwrap_or(None) } - fn typed_try_get(&self) -> Result, Error> - where - H: Header, - { + fn typed_try_get(&self) -> Result, Error> { let mut values = self.get_all(H::name()).iter(); if values.size_hint() == (0, Some(0)) { Ok(None) diff --git a/src/util/mod.rs b/src/util/mod.rs index 07fddbfb..a8f4fe1f 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -49,18 +49,22 @@ macro_rules! error_type { macro_rules! derive_header { ($type:ident(_), name: $name:ident) => { - impl crate::Header for $type { + impl ::headers_core::Named for $type { fn name() -> &'static ::http::header::HeaderName { &::http::header::$name } + } + impl ::headers_core::Decodable for $type { fn decode<'i, I>(values: &mut I) -> Result where I: Iterator, { ::util::TryFromValues::try_from_values(values).map($type) } + } + impl ::headers_core::Encodable for $type { fn encode>(&self, values: &mut E) { values.extend(::std::iter::once((&self.0).into())); }