From 11655ad98be649dfe523db1a4ded2627fcc73c0d Mon Sep 17 00:00:00 2001 From: Sean McArthur Date: Thu, 27 Jul 2017 11:29:21 -0700 Subject: [PATCH] uri: inline methods, add Debug/Display for Scheme, Authority, OriginForm --- src/uri.rs | 61 +++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 56 insertions(+), 5 deletions(-) diff --git a/src/uri.rs b/src/uri.rs index cb083a9..75732e3 100644 --- a/src/uri.rs +++ b/src/uri.rs @@ -47,32 +47,32 @@ pub struct Uri { } /// Represents the scheme component of a URI -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct Scheme { inner: Scheme2, } -#[derive(Debug, Clone)] +#[derive(Clone, Debug)] enum Scheme2> { None, Standard(Protocol), Other(T), } -#[derive(Debug, Clone, Eq, PartialEq)] +#[derive(Copy, Clone, Debug)] enum Protocol { Http, Https, } /// Represents the authority component of a URI. -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct Authority { data: ByteStr, } /// Represents the path component of a URI -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct OriginForm { data: ByteStr, query: u16, @@ -260,6 +260,7 @@ impl Uri { /// Returns the origin form component of the Uri /// /// This is the path and query string components or *. + #[inline] pub fn origin_form(&self) -> Option<&OriginForm> { if !self.scheme.inner.is_none() || self.authority.data.is_empty() { Some(&self.origin_form) @@ -302,6 +303,7 @@ impl Uri { /// /// assert_eq!(uri.path(), "/hello/world"); /// ``` + #[inline] pub fn path(&self) -> &str { if self.has_path() { self.origin_form.path() @@ -344,6 +346,7 @@ impl Uri { /// /// assert!(uri.scheme().is_none()); /// ``` + #[inline] pub fn scheme(&self) -> Option<&str> { if self.scheme.inner.is_none() { None @@ -389,6 +392,7 @@ impl Uri { /// /// assert!(uri.authority().is_none()); /// ``` + #[inline] pub fn authority(&self) -> Option<&str> { if self.authority.data.is_empty() { None @@ -430,6 +434,7 @@ impl Uri { /// /// assert!(uri.host().is_none()); /// ``` + #[inline] pub fn host(&self) -> Option<&str> { self.authority().map(host) } @@ -528,6 +533,7 @@ impl Uri { /// /// assert!(uri.query().is_none()); /// ``` + #[inline] pub fn query(&self) -> Option<&str> { self.origin_form.query() } @@ -540,6 +546,7 @@ impl Uri { impl<'a> HttpTryFrom<&'a str> for Uri { type Error = InvalidUri; + #[inline] fn try_from(t: &'a str) -> Result { t.parse() } @@ -548,6 +555,7 @@ impl<'a> HttpTryFrom<&'a str> for Uri { impl HttpTryFrom for Uri { type Error = InvalidUri; + #[inline] fn try_from(t: Bytes) -> Result { Uri::try_from_shared(t) } @@ -699,6 +707,7 @@ impl Scheme { /// let scheme: Scheme = "http".parse().unwrap(); /// assert_eq!(scheme.as_str(), "http"); /// ``` + #[inline] pub fn as_str(&self) -> &str { use self::Scheme2::*; use self::Protocol::*; @@ -712,6 +721,7 @@ impl Scheme { } /// Converts this `Scheme` back to a sequence of bytes + #[inline] pub fn into_bytes(self) -> Bytes { self.into() } @@ -734,6 +744,7 @@ impl FromStr for Scheme { } impl From for Bytes { + #[inline] fn from(src: Scheme) -> Self { use self::Scheme2::*; use self::Protocol::*; @@ -747,6 +758,18 @@ impl From for Bytes { } } +impl fmt::Debug for Scheme { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(self.as_str()) + } +} + +impl fmt::Display for Scheme { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(self.as_str()) + } +} + impl Scheme2 { fn is_none(&self) -> bool { match *self { @@ -933,16 +956,19 @@ impl Authority { /// /// assert_eq!(authority.host(), "example.org"); /// ``` + #[inline] pub fn host(&self) -> &str { host(self.as_str()) } /// Return a str representation of the authority + #[inline] pub fn as_str(&self) -> &str { &self.data[..] } /// Converts this `Authority` back to a sequence of bytes + #[inline] pub fn into_bytes(self) -> Bytes { self.into() } @@ -963,11 +989,25 @@ impl FromStr for Authority { } impl From for Bytes { + #[inline] fn from(src: Authority) -> Bytes { src.data.into() } } + +impl fmt::Debug for Authority { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(self.as_str()) + } +} + +impl fmt::Display for Authority { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(self.as_str()) + } +} + impl OriginForm { /// Attempt to convert a `OriginForm` from `Bytes`. /// @@ -1064,6 +1104,7 @@ impl OriginForm { /// /// assert_eq!(origin_form.path(), "/hello/world"); /// ``` + #[inline] pub fn path(&self) -> &str { let ret = if self.query == NONE { &self.data[..] @@ -1112,6 +1153,7 @@ impl OriginForm { /// /// assert!(origin_form.query().is_none()); /// ``` + #[inline] pub fn query(&self) -> Option<&str> { if self.query == NONE { None @@ -1122,6 +1164,7 @@ impl OriginForm { } /// Converts this `OriginForm` back to a sequence of bytes + #[inline] pub fn into_bytes(self) -> Bytes { self.into() } @@ -1141,6 +1184,12 @@ impl From for Bytes { } } +impl fmt::Debug for OriginForm { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(self, f) + } +} + impl fmt::Display for OriginForm { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { if !self.data.is_empty() { @@ -1233,6 +1282,7 @@ fn host(auth: &str) -> &str { impl FromStr for Uri { type Err = InvalidUri; + #[inline] fn from_str(s: &str) -> Result { Uri::try_from_shared(s.into()) } @@ -1349,6 +1399,7 @@ impl Eq for Uri {} /// Returns a `Uri` representing `/` impl Default for Uri { + #[inline] fn default() -> Uri { Uri { scheme: Scheme::empty(),