Bump to 0.2.15

Author: alexcrichton

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "rustc-serialize"
-version = "0.2.14"
+version = "0.2.15"
 authors = ["The Rust Project Developers"]
 license = "MIT/Apache-2.0"
 readme = "README.md"

src/collection_impls.rs

@@ -11,15 +11,15 @@
 //! Implementations of serialization for structures found in libcollections
 
 use std::default::Default;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 
 use {Decodable, Encodable, Decoder, Encoder};
-use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
+use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
 use std::collections::hash_state::HashState;
 
 impl<
     T: Encodable
-> Encodable for DList<T> {
+> Encodable for LinkedList<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_seq(self.len(), |s| {
             for (i, e) in self.iter().enumerate() {
@@ -30,10 +30,10 @@ impl<
     }
 }
 
-impl<T:Decodable> Decodable for DList<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<DList<T>, D::Error> {
+impl<T:Decodable> Decodable for LinkedList<T> {
+    fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
         d.read_seq(|d, len| {
-            let mut list = DList::new();
+            let mut list = LinkedList::new();
             for i in 0..len {
                 list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
@@ -42,7 +42,7 @@ impl<T:Decodable> Decodable for DList<T> {
     }
 }
 
-impl<T: Encodable> Encodable for RingBuf<T> {
+impl<T: Encodable> Encodable for VecDeque<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_seq(self.len(), |s| {
             for (i, e) in self.iter().enumerate() {
@@ -53,10 +53,10 @@ impl<T: Encodable> Encodable for RingBuf<T> {
     }
 }
 
-impl<T:Decodable> Decodable for RingBuf<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<RingBuf<T>, D::Error> {
+impl<T:Decodable> Decodable for VecDeque<T> {
+    fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
         d.read_seq(|d, len| {
-            let mut deque: RingBuf<T> = RingBuf::new();
+            let mut deque: VecDeque<T> = VecDeque::new();
             for i in 0..len {
                 deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
@@ -129,10 +129,9 @@ impl<
 }
 
 impl<K, V, S> Encodable for HashMap<K, V, S>
-    where K: Encodable + Hash< <S as HashState>::Hasher> + Eq,
+    where K: Encodable + Hash + Eq,
           V: Encodable,
           S: HashState,
-          <S as HashState>::Hasher: Hasher<Output=u64>
 {
     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
         e.emit_map(self.len(), |e| {
@@ -148,10 +147,9 @@ impl<K, V, S> Encodable for HashMap<K, V, S>
 }
 
 impl<K, V, S> Decodable for HashMap<K, V, S>
-    where K: Decodable + Hash< <S as HashState>::Hasher> + Eq,
+    where K: Decodable + Hash + Eq,
           V: Decodable,
           S: HashState + Default,
-          <S as HashState>::Hasher: Hasher<Output=u64>
 {
     fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
         d.read_map(|d, len| {
@@ -168,9 +166,8 @@ impl<K, V, S> Decodable for HashMap<K, V, S>
 }
 
 impl<T, S> Encodable for HashSet<T, S>
-    where T: Encodable + Hash< <S as HashState>::Hasher> + Eq,
+    where T: Encodable + Hash + Eq,
           S: HashState,
-          <S as HashState>::Hasher: Hasher<Output=u64>
 {
     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
         s.emit_seq(self.len(), |s| {
@@ -185,9 +182,8 @@ impl<T, S> Encodable for HashSet<T, S>
 }
 
 impl<T, S> Decodable for HashSet<T, S>
-    where T: Decodable + Hash< <S as HashState>::Hasher> + Eq,
+    where T: Decodable + Hash + Eq,
           S: HashState + Default,
-          <S as HashState>::Hasher: Hasher<Output=u64>
 {
     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
         d.read_seq(|d, len| {

src/json.rs

@@ -1045,7 +1045,7 @@ impl Json {
     /// Returns None otherwise.
     pub fn as_string<'a>(&'a self) -> Option<&'a str> {
         match *self {
-            Json::String(ref s) => Some(&s[]),
+            Json::String(ref s) => Some(&s),
             _ => None
         }
     }
@@ -2140,7 +2140,7 @@ impl ::Decoder for Decoder {
                 return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
             }
         };
-        let idx = match names.iter().position(|n| *n == &name[]) {
+        let idx = match names.iter().position(|n| *n == name) {
             Some(idx) => idx,
             None => return Err(UnknownVariantError(name))
         };
@@ -3366,7 +3366,7 @@ mod tests {
         hm.insert(1, true);
         let mut mem_buf = Vec::new();
         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
-        let json_str = from_utf8(&mem_buf[]).unwrap();
+        let json_str = from_utf8(&mem_buf).unwrap();
         match Json::from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3382,7 +3382,7 @@ mod tests {
         hm.insert(1, true);
         let mut mem_buf = Vec::new();
         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
-        let json_str = from_utf8(&mem_buf[]).unwrap();
+        let json_str = from_utf8(&mem_buf).unwrap();
         match Json::from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3422,7 +3422,7 @@ mod tests {
             write!(&mut writer, "{}",
                    super::as_pretty_json(&json).indent(i as u32)).unwrap();
 
-            let printed = from_utf8(&writer[]).unwrap();
+            let printed = from_utf8(&writer).unwrap();
 
             // Check for indents at each line
             let lines: Vec<&str> = printed.lines().collect();

src/lib.rs

@@ -10,7 +10,7 @@
 
 //! Support code for encoding and decoding types.
 
-#![feature(core, collections, unicode, io, std_misc, path, hash, os)]
+#![feature(core, collections, unicode, old_io, std_misc, old_path, path, os)]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/rustc-serialize/")]

src/serialize.rs

@@ -328,7 +328,7 @@ impl Encodable for str {
 
 impl Encodable for String {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(&self[])
+        s.emit_str(self)
     }
 }