diff --git a/src/context/maybe_utf8.rs b/src/context/maybe_utf8.rs index 5311147..229f167 100644 --- a/src/context/maybe_utf8.rs +++ b/src/context/maybe_utf8.rs @@ -47,7 +47,7 @@ impl MaybeUtf8 { ///let string = MaybeUtf8Owned::from("abc"); ///assert_eq!(Some("abc"), string.as_utf8()); ///``` - pub fn as_utf8<'a>(&'a self) -> Option<&'a str> where S: AsRef { + pub fn as_utf8(&self) -> Option<&str> where S: AsRef { match *self { MaybeUtf8::Utf8(ref s) => Some(s.as_ref()), MaybeUtf8::NotUtf8(_) => None diff --git a/src/context/parameters.rs b/src/context/parameters.rs index e934ef7..74625ec 100644 --- a/src/context/parameters.rs +++ b/src/context/parameters.rs @@ -91,7 +91,7 @@ impl Parameters { T: FromStr { if let Some(val) = self.0.get(key.as_ref()) { - val.as_utf8_lossy().parse().map_err(|e| Some(e)) + val.as_utf8_lossy().parse().map_err(Some) } else { Err(None) } @@ -230,4 +230,4 @@ impl, V: Into> Extend<(K, V)> for Parame fn extend>(&mut self, iter: T) { self.0.extend(iter.into_iter().map(|(k, v)| (k.into(), v.into()))) } -} \ No newline at end of file +} diff --git a/src/response.rs b/src/response.rs index d79407f..2a1ec7c 100644 --- a/src/response.rs +++ b/src/response.rs @@ -197,9 +197,9 @@ pub enum Data<'a> { impl<'a> Data<'a> { ///Borrow the content as a byte slice. pub fn as_bytes(&self) -> &[u8] { - match self { - &Data::Bytes(ref bytes) => bytes, - &Data::String(ref string) => string.as_bytes(), + match *self { + Data::Bytes(ref bytes) => bytes, + Data::String(ref string) => string.as_bytes(), } } @@ -213,9 +213,9 @@ impl<'a> Data<'a> { ///Borrow the content as a UTF-8 string slice, if possible. pub fn as_string(&self) -> Result<&str, Utf8Error> { - match self { - &Data::Bytes(ref bytes) => from_utf8(bytes), - &Data::String(ref string) => Ok(string), + match *self { + Data::Bytes(ref bytes) => from_utf8(bytes), + Data::String(ref string) => Ok(string), } } @@ -260,7 +260,7 @@ impl<'a> Into> for &'a str { ///its size is known. pub struct Response<'a, 'b> { writer: Option>, - filters: &'b Vec>, + filters: &'b [Box], global: &'b Global, filter_storage: Option, force_close: bool @@ -271,7 +271,7 @@ impl<'a, 'b> Response<'a, 'b> { ///Internal and may change without warning. pub fn new( response: hyper::server::response::Response<'a>, - filters: &'b Vec>, + filters: &'b [Box], global: &'b Global, force_close: bool ) -> Response<'a, 'b> { @@ -537,14 +537,14 @@ impl<'a, 'b> Response<'a, 'b> { let mut writer = unsafe { self.into_raw(metadata.len()) }; - io::copy(&mut file, &mut writer).map_err(|e| FileError::Send(e)).map(|_| ()) + io::copy(&mut file, &mut writer).map_err(FileError::Send).map(|_| ()) } ///Write the status code and headers to the client and turn the `Response` ///into a `Chunked` response. pub fn into_chunked(mut self) -> Chunked<'a, 'b> { let mut writer = self.writer.take().expect("response used after drop"); - + //Make sure it's chunked writer.headers_mut().remove::<::header::ContentLength>(); writer.headers_mut().remove_raw("content-length"); @@ -621,7 +621,7 @@ impl<'a, 'b> Drop for Response<'a, 'b> { ///an overhead for each time `send` or `try_send` is called (simply put). pub struct Chunked<'a, 'b> { writer: Option, Error>>, - filters: &'b Vec>, + filters: &'b [Box], global: &'b Global, filter_storage: AnyMap } @@ -738,7 +738,7 @@ impl<'a, 'b> Chunked<'a, 'b> { } } - writer.end().map_err(|e| Error::Io(e)) + writer.end().map_err(Error::Io) } fn borrow_writer(&mut self) -> Result<&mut hyper::server::response::Response<'a, hyper::net::Streaming>, Error> { @@ -982,8 +982,8 @@ fn filter_end<'a>(filters: &'a [Box], global: &Global, filter_st filter.end(filter_context) }) - .take_while(|a| if let &Action::Next(_) = a { true } else { false }) - .map(|a| Some(a)) + .take_while(|a| if let Action::Next(_) = *a { true } else { false }) + .map(Some) .collect(); let mut write_queue = vec![]; diff --git a/src/router/mod.rs b/src/router/mod.rs index f47482e..54a9559 100644 --- a/src/router/mod.rs +++ b/src/router/mod.rs @@ -230,16 +230,16 @@ impl Iterator for RouteIter { type Item = ::Item; fn next(&mut self) -> Option<::Item> { - match self { - &mut RouteIter::Path(ref mut i) => i.next(), - &mut RouteIter::Root => None + match *self { + RouteIter::Path(ref mut i) => i.next(), + RouteIter::Root => None } } fn size_hint(&self) -> (usize, Option) { - match self { - &RouteIter::Path(ref i) => i.size_hint(), - &RouteIter::Root => (0, Some(0)) + match *self { + RouteIter::Path(ref i) => i.size_hint(), + RouteIter::Root => (0, Some(0)) } } } diff --git a/src/router/tree_router.rs b/src/router/tree_router.rs index f99f1e0..6e24b4f 100644 --- a/src/router/tree_router.rs +++ b/src/router/tree_router.rs @@ -39,7 +39,7 @@ impl<'a, I: Iterator> Iterator for VariableIter<'a, I> { type Item=(MaybeUtf8Owned, MaybeUtf8Owned); fn next(&mut self) -> Option { - while let Some((next_index, next_segment)) = self.iter.next() { + for (next_index, next_segment) in &mut self.iter { //validate next_index and check if the variable has a name debug_assert!(next_index < self.names.len(), format!("invalid variable name index! variable_names.len(): {}, index: {}", self.names.len(), next_index)); let next_name = match self.names.get(next_index) { @@ -226,14 +226,14 @@ impl Router for TreeRouter { let path = route.segments().collect::>(); let mut variables = vec![None; path.len()]; let mut stack = vec![(self, Wildcard, 0, 0), (self, Variable, 0, 0), (self, Static, 0, 0)]; - + let mut result: Endpoint = None.into(); while let Some((current, branch, index, var_index)) = stack.pop() { if index == path.len() && result.handler.is_none() { if let Some(&(ref item, ref variable_names)) = current.items.get(&method) { let values = path.iter().zip(variables.iter()).filter_map(|(v, keep)| { - if let &Some(index) = keep { + if let Some(index) = *keep { Some((index, v.clone())) } else { None @@ -438,7 +438,7 @@ mod test { use context::MaybeUtf8Slice; let handler: Option<&str> = $handler; - let handler = handler.map(|h| TestHandler::from(h)); + let handler = handler.map(TestHandler::from); let mut endpoint = $res; assert_eq!(endpoint.handler, handler.as_ref()); let expected_vars: HashMap = map!($($key => $val),*); @@ -882,4 +882,4 @@ mod test { counter = (counter + 1) % paths.len() }); } -} \ No newline at end of file +} diff --git a/src/server/config.rs b/src/server/config.rs index b2e30a6..06ecade 100644 --- a/src/server/config.rs +++ b/src/server/config.rs @@ -96,7 +96,7 @@ impl FromStr for Host { type Err = ::Err; fn from_str(s: &str) -> Result { - s.parse().map(|s| Host(s)) + s.parse().map(Host) } } diff --git a/src/server/instance.rs b/src/server/instance.rs index a6257d7..e6a40d1 100644 --- a/src/server/instance.rs +++ b/src/server/instance.rs @@ -220,13 +220,13 @@ impl HyperHandler for ServerInstance { ContextAction::Next => { *response.filter_storage_mut() = filter_storage; - let endpoint = context.uri.as_path().map(|path| self.handlers.find(&context.method, &path)).unwrap_or_else(|| { + let endpoint = context.uri.as_path().map_or_else(|| { Endpoint { handler: None, variables: HashMap::new(), hyperlinks: vec![] } - }); + }, |path| self.handlers.find(&context.method, &path)); let Endpoint { handler, @@ -298,7 +298,7 @@ fn parse_path(path: &str) -> ParsedUri { } } -fn parse_fragment<'a>(path: &'a str) -> (&'a str, Option<&'a str>) { +fn parse_fragment(path: &str) -> (&str, Option<&str>) { match path.find('#') { Some(index) => (&path[..index], Some(&path[index+1..])), None => (path, None) @@ -316,7 +316,7 @@ fn parse_url(url: Url) -> ParsedUri { } let query = url.query_pairs() - .unwrap_or_else(|| Vec::new()) + .unwrap_or_default() .into_iter() .collect();