forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(rustup): Remove uses of the obsolete &a[] syntax

Browse Source
This commit is contained in:
Renato Zannon
2015-02-21 03:31:32 -02:00
committed by Sean McArthur
parent 234fcdc3a2
commit 039e984f68
21 changed files with 47 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
examples/server.rs
View File

@@ -21,7 +21,7 @@ macro_rules! try_return(
fn echo(mut req: Request, mut res: Response) { fn echo(mut req: Request, mut res: Response) {
match req.uri { match req.uri {
AbsolutePath(ref path) => match (&req.method, &path[]) { AbsolutePath(ref path) => match (&req.method, &path[..]) {
(&Get, "/") | (&Get, "/echo") => { (&Get, "/") | (&Get, "/echo") => {
let out = b"Try POST /echo"; let out = b"Try POST /echo";

4
src/client/mod.rs
View File

@@ -197,7 +197,7 @@ impl<'a, U: IntoUrl, C: NetworkConnector> RequestBuilder<'a, U, C> {
// punching borrowck here // punching borrowck here
let loc = match res.headers.get::<Location>() { let loc = match res.headers.get::<Location>() {
Some(&Location(ref loc)) => { Some(&Location(ref loc)) => {
Some(UrlParser::new().base_url(&url).parse(&loc[])) Some(UrlParser::new().base_url(&url).parse(&loc[..]))
} }
None => { None => {
debug!("no Location header"); debug!("no Location header");
@@ -394,7 +394,7 @@ mod tests {
#[test] #[test]
fn test_redirect_followif() { fn test_redirect_followif() {
fn follow_if(url: &Url) -> bool { fn follow_if(url: &Url) -> bool {
!url.serialize()[].contains("127.0.0.3") !url.serialize().contains("127.0.0.3")
} }
let mut client = Client::with_connector(MockRedirectPolicy); let mut client = Client::with_connector(MockRedirectPolicy);
client.set_redirect_policy(RedirectPolicy::FollowIf(follow_if)); client.set_redirect_policy(RedirectPolicy::FollowIf(follow_if));

6
src/client/request.rs
View File

@@ -77,7 +77,7 @@ impl Request<Fresh> {
//TODO: this needs a test //TODO: this needs a test
if let Some(ref q) = self.url.query { if let Some(ref q) = self.url.query {
uri.push('?'); uri.push('?');
uri.push_str(&q[]); uri.push_str(&q[..]);
} }
debug!("writing head: {:?} {:?} {:?}", self.method, uri, self.version); debug!("writing head: {:?} {:?} {:?}", self.method, uri, self.version);
@@ -185,7 +185,7 @@ mod tests {
let stream = *req.body.end().unwrap() let stream = *req.body.end().unwrap()
.into_inner().downcast::<MockStream>().ok().unwrap(); .into_inner().downcast::<MockStream>().ok().unwrap();
let bytes = stream.write.into_inner(); let bytes = stream.write.into_inner();
let s = from_utf8(&bytes[]).unwrap(); let s = from_utf8(&bytes[..]).unwrap();
assert!(!s.contains("Content-Length:")); assert!(!s.contains("Content-Length:"));
assert!(!s.contains("Transfer-Encoding:")); assert!(!s.contains("Transfer-Encoding:"));
} }
@@ -199,7 +199,7 @@ mod tests {
let stream = *req.body.end().unwrap() let stream = *req.body.end().unwrap()
.into_inner().downcast::<MockStream>().ok().unwrap(); .into_inner().downcast::<MockStream>().ok().unwrap();
let bytes = stream.write.into_inner(); let bytes = stream.write.into_inner();
let s = from_utf8(&bytes[]).unwrap(); let s = from_utf8(&bytes[..]).unwrap();
assert!(!s.contains("Content-Length:")); assert!(!s.contains("Content-Length:"));
assert!(!s.contains("Transfer-Encoding:")); assert!(!s.contains("Transfer-Encoding:"));
} }

2
src/header/common/access_control/allow_origin.rs
View File

@@ -29,7 +29,7 @@ impl header::Header for AccessControlAllowOrigin {
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowOrigin> { fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowOrigin> {
if raw.len() == 1 { if raw.len() == 1 {
match str::from_utf8(unsafe { &raw[].get_unchecked(0)[] }) { match str::from_utf8(unsafe { &raw.get_unchecked(0)[..] }) {
Ok(s) => { Ok(s) => {
if s == "*" { if s == "*" {
Some(AccessControlAllowOrigin::AllowStar) Some(AccessControlAllowOrigin::AllowStar)

10
src/header/common/authorization.rs
View File

@@ -29,7 +29,7 @@ impl<S: Scheme + 'static> Header for Authorization<S> {
fn parse_header(raw: &[Vec<u8>]) -> Option<Authorization<S>> { fn parse_header(raw: &[Vec<u8>]) -> Option<Authorization<S>> {
if raw.len() == 1 { if raw.len() == 1 {
match (from_utf8(unsafe { &raw[].get_unchecked(0)[] }), Scheme::scheme(None::<S>)) { match (from_utf8(unsafe { &raw.get_unchecked(0)[..] }), Scheme::scheme(None::<S>)) {
(Ok(header), Some(scheme)) (Ok(header), Some(scheme))
if header.starts_with(scheme) && header.len() > scheme.len() + 1 => { if header.starts_with(scheme) && header.len() > scheme.len() + 1 => {
header[scheme.len() + 1..].parse::<S>().map(|s| Authorization(s)).ok() header[scheme.len() + 1..].parse::<S>().map(|s| Authorization(s)).ok()
@@ -96,7 +96,7 @@ impl Scheme for Basic {
let mut text = self.username.clone(); let mut text = self.username.clone();
text.push(':'); text.push(':');
if let Some(ref pass) = self.password { if let Some(ref pass) = self.password {
text.push_str(&pass[]); text.push_str(&pass[..]);
} }
write!(f, "{}", text.as_bytes().to_base64(Config { write!(f, "{}", text.as_bytes().to_base64(Config {
char_set: Standard, char_set: Standard,
@@ -113,7 +113,7 @@ impl FromStr for Basic {
match s.from_base64() { match s.from_base64() {
Ok(decoded) => match String::from_utf8(decoded) { Ok(decoded) => match String::from_utf8(decoded) {
Ok(text) => { Ok(text) => {
let mut parts = &mut text[].split(':'); let mut parts = &mut text.split(':');
let user = match parts.next() { let user = match parts.next() {
Some(part) => part.to_string(), Some(part) => part.to_string(),
None => return Err(()) None => return Err(())
@@ -160,7 +160,7 @@ mod tests {
#[test] #[test]
fn test_raw_auth_parse() { fn test_raw_auth_parse() {
let headers = Headers::from_raw(&mut mem("Authorization: foo bar baz\r\n\r\n")).unwrap(); let headers = Headers::from_raw(&mut mem("Authorization: foo bar baz\r\n\r\n")).unwrap();
assert_eq!(&headers.get::<Authorization<String>>().unwrap().0[], "foo bar baz"); assert_eq!(&headers.get::<Authorization<String>>().unwrap().0[..], "foo bar baz");
} }
#[test] #[test]
@@ -181,7 +181,7 @@ mod tests {
fn test_basic_auth_parse() { fn test_basic_auth_parse() {
let headers = Headers::from_raw(&mut mem("Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==\r\n\r\n")).unwrap(); let headers = Headers::from_raw(&mut mem("Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==\r\n\r\n")).unwrap();
let auth = headers.get::<Authorization<Basic>>().unwrap(); let auth = headers.get::<Authorization<Basic>>().unwrap();
assert_eq!(&auth.0.username[], "Aladdin"); assert_eq!(&auth.0.username[..], "Aladdin");
assert_eq!(auth.0.password, Some("open sesame".to_string())); assert_eq!(auth.0.password, Some("open sesame".to_string()));
} }

6
src/header/common/cache_control.rs
View File

@@ -16,7 +16,7 @@ impl Header for CacheControl {
fn parse_header(raw: &[Vec<u8>]) -> Option<CacheControl> { fn parse_header(raw: &[Vec<u8>]) -> Option<CacheControl> {
let directives = raw.iter() let directives = raw.iter()
.filter_map(|line| from_one_comma_delimited(&line[])) .filter_map(|line| from_one_comma_delimited(&line[..]))
.collect::<Vec<Vec<CacheDirective>>>() .collect::<Vec<Vec<CacheDirective>>>()
.concat(); .concat();
if directives.len() > 0 { if directives.len() > 0 {
@@ -29,7 +29,7 @@ impl Header for CacheControl {
impl HeaderFormat for CacheControl { impl HeaderFormat for CacheControl {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt_comma_delimited(fmt, &self[]) fmt_comma_delimited(fmt, &self[..])
} }
} }
@@ -88,7 +88,7 @@ impl fmt::Display for CacheDirective {
ProxyRevalidate => "proxy-revalidate", ProxyRevalidate => "proxy-revalidate",
SMaxAge(secs) => return write!(f, "s-maxage={}", secs), SMaxAge(secs) => return write!(f, "s-maxage={}", secs),
Extension(ref name, None) => &name[], Extension(ref name, None) => &name[..],
Extension(ref name, Some(ref arg)) => return write!(f, "{}={}", name, arg), Extension(ref name, Some(ref arg)) => return write!(f, "{}={}", name, arg),
}, f) }, f)

2
src/header/common/connection.rs
View File

@@ -64,7 +64,7 @@ impl Header for Connection {
impl HeaderFormat for Connection { impl HeaderFormat for Connection {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Connection(ref parts) = *self; let Connection(ref parts) = *self;
fmt_comma_delimited(fmt, &parts[]) fmt_comma_delimited(fmt, &parts[..])
} }
} }

6
src/header/common/cookie.rs
View File

@@ -26,7 +26,7 @@ impl Header for Cookie {
fn parse_header(raw: &[Vec<u8>]) -> Option<Cookie> { fn parse_header(raw: &[Vec<u8>]) -> Option<Cookie> {
let mut cookies = Vec::with_capacity(raw.len()); let mut cookies = Vec::with_capacity(raw.len());
for cookies_raw in raw.iter() { for cookies_raw in raw.iter() {
match from_utf8(&cookies_raw[]) { match from_utf8(&cookies_raw[..]) {
Ok(cookies_str) => { Ok(cookies_str) => {
for cookie_str in cookies_str.split(';') { for cookie_str in cookies_str.split(';') {
match cookie_str.trim().parse() { match cookie_str.trim().parse() {
@@ -82,7 +82,7 @@ impl Cookie {
#[test] #[test]
fn test_parse() { fn test_parse() {
let h = Header::parse_header(&[b"foo=bar; baz=quux".to_vec()][]); let h = Header::parse_header(&[b"foo=bar; baz=quux".to_vec()][..]);
let c1 = CookiePair::new("foo".to_string(), "bar".to_string()); let c1 = CookiePair::new("foo".to_string(), "bar".to_string());
let c2 = CookiePair::new("baz".to_string(), "quux".to_string()); let c2 = CookiePair::new("baz".to_string(), "quux".to_string());
assert_eq!(h, Some(Cookie(vec![c1, c2]))); assert_eq!(h, Some(Cookie(vec![c1, c2])));
@@ -99,7 +99,7 @@ fn test_fmt() {
let mut headers = Headers::new(); let mut headers = Headers::new();
headers.set(cookie_header); headers.set(cookie_header);
assert_eq!(&headers.to_string()[], "Cookie: foo=bar; baz=quux\r\n"); assert_eq!(&headers.to_string()[..], "Cookie: foo=bar; baz=quux\r\n");
} }
#[test] #[test]

2
src/header/common/host.rs
View File

@@ -28,7 +28,7 @@ impl Header for Host {
// FIXME: use rust-url to parse this // FIXME: use rust-url to parse this
// https://github.com/servo/rust-url/issues/42 // https://github.com/servo/rust-url/issues/42
let idx = { let idx = {
let slice = &s[]; let slice = &s[..];
if slice.char_at(1) == '[' { if slice.char_at(1) == '[' {
match slice.rfind(']') { match slice.rfind(']') {
Some(idx) => { Some(idx) => {

4
src/header/common/if_match.rs
View File

@@ -25,7 +25,7 @@ impl Header for IfMatch {
fn parse_header(raw: &[Vec<u8>]) -> Option<IfMatch> { fn parse_header(raw: &[Vec<u8>]) -> Option<IfMatch> {
from_one_raw_str(raw).and_then(|s: String| { from_one_raw_str(raw).and_then(|s: String| {
let slice = &s[]; let slice = &s[..];
match slice { match slice {
"" => None, "" => None,
"*" => Some(IfMatch::Any), "*" => Some(IfMatch::Any),
@@ -39,7 +39,7 @@ impl HeaderFormat for IfMatch {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
IfMatch::Any => write!(fmt, "*"), IfMatch::Any => write!(fmt, "*"),
IfMatch::EntityTags(ref fields) => fmt_comma_delimited(fmt, &fields[]) IfMatch::EntityTags(ref fields) => fmt_comma_delimited(fmt, &fields[..])
} }
} }
} }

4
src/header/common/if_none_match.rs
View File

@@ -33,7 +33,7 @@ impl Header for IfNoneMatch {
fn parse_header(raw: &[Vec<u8>]) -> Option<IfNoneMatch> { fn parse_header(raw: &[Vec<u8>]) -> Option<IfNoneMatch> {
from_one_raw_str(raw).and_then(|s: String| { from_one_raw_str(raw).and_then(|s: String| {
let slice = &s[]; let slice = &s[..];
match slice { match slice {
"" => None, "" => None,
"*" => Some(IfNoneMatch::Any), "*" => Some(IfNoneMatch::Any),
@@ -47,7 +47,7 @@ impl HeaderFormat for IfNoneMatch {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
IfNoneMatch::Any => { write!(fmt, "*") } IfNoneMatch::Any => { write!(fmt, "*") }
IfNoneMatch::EntityTags(ref fields) => { fmt_comma_delimited(fmt, &fields[]) } IfNoneMatch::EntityTags(ref fields) => { fmt_comma_delimited(fmt, &fields[..]) }
} }
} }
} }

6
src/header/common/mod.rs
View File

@@ -50,13 +50,13 @@ macro_rules! bench_header(
fn bench_parse(b: &mut Bencher) { fn bench_parse(b: &mut Bencher) {
let val = $value; let val = $value;
b.iter(|| { b.iter(|| {
let _: $ty = Header::parse_header(&val[]).unwrap(); let _: $ty = Header::parse_header(&val[..]).unwrap();
}); });
} }
#[bench] #[bench]
fn bench_format(b: &mut Bencher) { fn bench_format(b: &mut Bencher) {
let val: $ty = Header::parse_header(&$value[]).unwrap(); let val: $ty = Header::parse_header(&$value[..]).unwrap();
let fmt = HeaderFormatter(&val); let fmt = HeaderFormatter(&val);
b.iter(|| { b.iter(|| {
format!("{}", fmt); format!("{}", fmt);
@@ -102,7 +102,7 @@ macro_rules! impl_list_header(
impl $crate::header::HeaderFormat for $from { impl $crate::header::HeaderFormat for $from {
fn fmt_header(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt_header(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
$crate::header::parsing::fmt_comma_delimited(fmt, &self[]) $crate::header::parsing::fmt_comma_delimited(fmt, &self[..])
} }
} }

2
src/header/common/pragma.rs
View File

@@ -31,7 +31,7 @@ impl Header for Pragma {
fn parse_header(raw: &[Vec<u8>]) -> Option<Pragma> { fn parse_header(raw: &[Vec<u8>]) -> Option<Pragma> {
parsing::from_one_raw_str(raw).and_then(|s: String| { parsing::from_one_raw_str(raw).and_then(|s: String| {
let slice = &s.to_ascii_lowercase()[]; let slice = &s.to_ascii_lowercase()[..];
match slice { match slice {
"" => None, "" => None,
"no-cache" => Some(Pragma::NoCache), "no-cache" => Some(Pragma::NoCache),

6
src/header/common/set_cookie.rs
View File

@@ -23,7 +23,7 @@ impl Header for SetCookie {
fn parse_header(raw: &[Vec<u8>]) -> Option<SetCookie> { fn parse_header(raw: &[Vec<u8>]) -> Option<SetCookie> {
let mut set_cookies = Vec::with_capacity(raw.len()); let mut set_cookies = Vec::with_capacity(raw.len());
for set_cookies_raw in raw.iter() { for set_cookies_raw in raw.iter() {
match from_utf8(&set_cookies_raw[]) { match from_utf8(&set_cookies_raw[..]) {
Ok(s) if !s.is_empty() => { Ok(s) if !s.is_empty() => {
match s.parse() { match s.parse() {
Ok(cookie) => set_cookies.push(cookie), Ok(cookie) => set_cookies.push(cookie),
@@ -76,7 +76,7 @@ impl SetCookie {
#[test] #[test]
fn test_parse() { fn test_parse() {
let h = Header::parse_header(&[b"foo=bar; HttpOnly".to_vec()][]); let h = Header::parse_header(&[b"foo=bar; HttpOnly".to_vec()][..]);
let mut c1 = Cookie::new("foo".to_string(), "bar".to_string()); let mut c1 = Cookie::new("foo".to_string(), "bar".to_string());
c1.httponly = true; c1.httponly = true;
@@ -94,7 +94,7 @@ fn test_fmt() {
let mut headers = Headers::new(); let mut headers = Headers::new();
headers.set(cookies); headers.set(cookies);
assert_eq!(&headers.to_string()[], "Set-Cookie: foo=bar; HttpOnly; Path=/p\r\nSet-Cookie: baz=quux; Path=/\r\n"); assert_eq!(&headers.to_string()[..], "Set-Cookie: foo=bar; HttpOnly; Path=/p\r\nSet-Cookie: baz=quux; Path=/\r\n");
} }
#[test] #[test]

2
src/header/common/upgrade.rs
View File

@@ -55,7 +55,7 @@ impl Header for Upgrade {
impl HeaderFormat for Upgrade { impl HeaderFormat for Upgrade {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Upgrade(ref parts) = *self; let Upgrade(ref parts) = *self;
fmt_comma_delimited(fmt, &parts[]) fmt_comma_delimited(fmt, &parts[..])
} }
} }

4
src/header/common/vary.rs
View File

@@ -21,7 +21,7 @@ impl Header for Vary {
fn parse_header(raw: &[Vec<u8>]) -> Option<Vary> { fn parse_header(raw: &[Vec<u8>]) -> Option<Vary> {
from_one_raw_str(raw).and_then(|s: String| { from_one_raw_str(raw).and_then(|s: String| {
let slice = &s[]; let slice = &s[..];
match slice { match slice {
"" => None, "" => None,
"*" => Some(Vary::Any), "*" => Some(Vary::Any),
@@ -35,7 +35,7 @@ impl HeaderFormat for Vary {
fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
Vary::Any => { write!(fmt, "*") } Vary::Any => { write!(fmt, "*") }
Vary::Headers(ref fields) => { fmt_comma_delimited(fmt, &fields[]) } Vary::Headers(ref fields) => { fmt_comma_delimited(fmt, &fields[..]) }
} }
} }
} }

14
src/header/mod.rs
View File

@@ -139,7 +139,7 @@ impl Headers {
loop { loop {
match try!(http::read_header(rdr)) { match try!(http::read_header(rdr)) {
Some((name, value)) => { Some((name, value)) => {
debug!("raw header: {:?}={:?}", name, &value[]); debug!("raw header: {:?}={:?}", name, &value[..]);
count += (name.len() + value.len()) as u32; count += (name.len() + value.len()) as u32;
if count > MAX_HEADERS_LENGTH { if count > MAX_HEADERS_LENGTH {
debug!("Max header size reached, aborting"); debug!("Max header size reached, aborting");
@@ -183,14 +183,14 @@ impl Headers {
.get(&UniCase(Borrowed(unsafe { mem::transmute::<&str, &str>(name) }))) .get(&UniCase(Borrowed(unsafe { mem::transmute::<&str, &str>(name) })))
.and_then(|item| { .and_then(|item| {
if let Some(ref raw) = *item.raw { if let Some(ref raw) = *item.raw {
return Some(&raw[]); return Some(&raw[..]);
} }
let raw = vec![item.typed.as_ref().unwrap().to_string().into_bytes()]; let raw = vec![item.typed.as_ref().unwrap().to_string().into_bytes()];
item.raw.set(raw); item.raw.set(raw);
let raw = item.raw.as_ref().unwrap(); let raw = item.raw.as_ref().unwrap();
Some(&raw[]) Some(&raw[..])
}) })
} }
@@ -451,7 +451,7 @@ fn get_or_parse_mut<H: Header + HeaderFormat>(item: &mut Item) -> Option<&mut It
fn parse<H: Header + HeaderFormat>(item: &Item) { fn parse<H: Header + HeaderFormat>(item: &Item) {
match *item.raw { match *item.raw {
Some(ref raw) => match Header::parse_header(&raw[]) { Some(ref raw) => match Header::parse_header(&raw[..]) {
Some::<H>(h) => item.typed.set(box h as Box<HeaderFormat + Send + Sync>), Some::<H>(h) => item.typed.set(box h as Box<HeaderFormat + Send + Sync>),
None => () None => ()
}, },
@@ -476,7 +476,7 @@ impl fmt::Display for Item {
None => match *self.raw { None => match *self.raw {
Some(ref raw) => { Some(ref raw) => {
for part in raw.iter() { for part in raw.iter() {
match from_utf8(&part[]) { match from_utf8(&part[..]) {
Ok(s) => try!(fmt.write_str(s)), Ok(s) => try!(fmt.write_str(s)),
Err(e) => { Err(e) => {
error!("raw header value is not utf8. header={:?}, error={:?}", part, e); error!("raw header value is not utf8. header={:?}, error={:?}", part, e);
@@ -595,7 +595,7 @@ mod tests {
return None; return None;
} }
// we JUST checked that raw.len() == 1, so raw[0] WILL exist. // we JUST checked that raw.len() == 1, so raw[0] WILL exist.
match from_utf8(unsafe { &raw[].get_unchecked(0)[] }) { match from_utf8(unsafe { &raw.get_unchecked(0)[..] }) {
Ok(s) => FromStr::from_str(s).ok(), Ok(s) => FromStr::from_str(s).ok(),
Err(_) => None Err(_) => None
}.map(|u| CrazyLength(Some(false), u)) }.map(|u| CrazyLength(Some(false), u))
@@ -671,7 +671,7 @@ mod tests {
let mut headers = Headers::new(); let mut headers = Headers::new();
headers.set(ContentLength(10)); headers.set(ContentLength(10));
headers.set_raw("content-LENGTH", vec![b"20".to_vec()]); headers.set_raw("content-LENGTH", vec![b"20".to_vec()]);
assert_eq!(headers.get_raw("Content-length").unwrap(), &[b"20".to_vec()][]); assert_eq!(headers.get_raw("Content-length").unwrap(), &[b"20".to_vec()][..]);
assert_eq!(headers.get(), Some(&ContentLength(20))); assert_eq!(headers.get(), Some(&ContentLength(20)));
} }

4
src/header/parsing.rs
View File

@@ -11,7 +11,7 @@ pub fn from_one_raw_str<T: str::FromStr>(raw: &[Vec<u8>]) -> Option<T> {
return None; return None;
} }
// we JUST checked that raw.len() == 1, so raw[0] WILL exist. // we JUST checked that raw.len() == 1, so raw[0] WILL exist.
match str::from_utf8(&raw[0][]) { match str::from_utf8(&raw[0][..]) {
Ok(s) => str::FromStr::from_str(s).ok(), Ok(s) => str::FromStr::from_str(s).ok(),
Err(_) => None Err(_) => None
} }
@@ -24,7 +24,7 @@ pub fn from_comma_delimited<T: str::FromStr>(raw: &[Vec<u8>]) -> Option<Vec<T>>
return None; return None;
} }
// we JUST checked that raw.len() == 1, so raw[0] WILL exist. // we JUST checked that raw.len() == 1, so raw[0] WILL exist.
from_one_comma_delimited(&raw[0][]) from_one_comma_delimited(&raw[0][..])
} }
/// Reads a comma-delimited raw string into a Vec. /// Reads a comma-delimited raw string into a Vec.

2
src/header/shared/entity.rs
View File

@@ -42,7 +42,7 @@ impl FromStr for EntityTag {
type Err = (); type Err = ();
fn from_str(s: &str) -> Result<EntityTag, ()> { fn from_str(s: &str) -> Result<EntityTag, ()> {
let length: usize = s.len(); let length: usize = s.len();
let slice = &s[]; let slice = &s[..];
// Early exits: // Early exits:
// 1. The string is empty, or, // 1. The string is empty, or,

2
src/header/shared/quality_item.rs
View File

@@ -39,7 +39,7 @@ impl<T: fmt::Display> fmt::Display for QualityItem<T> {
write!(f, "{}", self.item) write!(f, "{}", self.item)
} else { } else {
write!(f, "{}; q={}", self.item, write!(f, "{}; q={}", self.item,
format!("{:.3}", self.quality).trim_right_matches(&['0', '.'][])) format!("{:.3}", self.quality).trim_right_matches(&['0', '.'][..]))
} }
} }
} }

4
src/http.rs
View File

@@ -395,7 +395,7 @@ pub fn read_method<R: Reader>(stream: &mut R) -> HttpResult<method::Method> {
debug!("maybe_method = {:?}", maybe_method); debug!("maybe_method = {:?}", maybe_method);
match (maybe_method, &buf[]) { match (maybe_method, &buf[..]) {
(Some(method), _) => Ok(method), (Some(method), _) => Ok(method),
(None, ext) => { (None, ext) => {
// We already checked that the buffer is ASCII // We already checked that the buffer is ASCII
@@ -664,7 +664,7 @@ pub fn read_status<R: Reader>(stream: &mut R) -> HttpResult<RawStatus> {
} }
} }
let reason = match str::from_utf8(&buf[]) { let reason = match str::from_utf8(&buf[..]) {
Ok(s) => s.trim(), Ok(s) => s.trim(),
Err(_) => return Err(HttpStatusError) Err(_) => return Err(HttpStatusError)
}; };