Remove serialization support for old_path and HashState

The `std::old_path` module is on its way out and the `HashState` portions of
hash maps is likely not going to be stable for 1.0. Once the functionality is
stabilized it can return to this crate.

Author: alexcrichton

src/collection_impls.rs

@@ -10,12 +10,10 @@
 
 //! Implementations of serialization for structures found in libcollections
 
-use std::default::Default;
 use std::hash::Hash;
 
 use {Decodable, Encodable, Decoder, Encoder};
 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
-use std::collections::hash_state::HashState;
 
 impl<
     T: Encodable
@@ -128,10 +126,9 @@ impl<
     }
 }
 
-impl<K, V, S> Encodable for HashMap<K, V, S>
+impl<K, V> Encodable for HashMap<K, V>
     where K: Encodable + Hash + Eq,
           V: Encodable,
-          S: HashState,
 {
     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
         e.emit_map(self.len(), |e| {
@@ -146,15 +143,13 @@ impl<K, V, S> Encodable for HashMap<K, V, S>
     }
 }
 
-impl<K, V, S> Decodable for HashMap<K, V, S>
+impl<K, V> Decodable for HashMap<K, V>
     where K: Decodable + Hash + Eq,
           V: Decodable,
-          S: HashState + Default,
 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
+    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V>, D::Error> {
         d.read_map(|d, len| {
-            let state = Default::default();
-            let mut map = HashMap::with_capacity_and_hash_state(len, state);
+            let mut map = HashMap::with_capacity(len);
             for i in 0..len {
                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
@@ -165,10 +160,7 @@ impl<K, V, S> Decodable for HashMap<K, V, S>
     }
 }
 
-impl<T, S> Encodable for HashSet<T, S>
-    where T: Encodable + Hash + Eq,
-          S: HashState,
-{
+impl<T> Encodable for HashSet<T> where T: Encodable + Hash + Eq {
     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
         s.emit_seq(self.len(), |s| {
             let mut i = 0;
@@ -181,14 +173,10 @@ impl<T, S> Encodable for HashSet<T, S>
     }
 }
 
-impl<T, S> Decodable for HashSet<T, S>
-    where T: Decodable + Hash + Eq,
-          S: HashState + Default,
-{
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
+impl<T> Decodable for HashSet<T> where T: Decodable + Hash + Eq, {
+    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T>, D::Error> {
         d.read_seq(|d, len| {
-            let state = Default::default();
-            let mut set = HashSet::with_capacity_and_hash_state(len, state);
+            let mut set = HashSet::with_capacity(len);
             for i in 0..len {
                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }

src/lib.rs

@@ -10,7 +10,7 @@
 
 //! Support code for encoding and decoding types.
 
-#![feature(core, collections, unicode, io, std_misc, old_path, path, os)]
+#![feature(core, collections, unicode, io, std_misc, 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

@@ -16,7 +16,6 @@ Core encoding and decoding interfaces.
 
 use std::cell::{Cell, RefCell};
 use std::ffi::{AsOsStr, OsString};
-use std::old_path::{PosixPath, WindowsPath};
 use std::path;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -540,32 +539,6 @@ macro_rules! tuple {
 
 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
-impl Encodable for PosixPath {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        self.as_vec().encode(e)
-    }
-}
-
-impl Decodable for PosixPath {
-    fn decode<D: Decoder>(d: &mut D) -> Result<PosixPath, D::Error> {
-        let bytes: Vec<u8> = try!(Decodable::decode(d));
-        Ok(PosixPath::new(bytes))
-    }
-}
-
-impl Encodable for WindowsPath {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        self.as_vec().encode(e)
-    }
-}
-
-impl Decodable for WindowsPath {
-    fn decode<D: Decoder>(d: &mut D) -> Result<WindowsPath, D::Error> {
-        let bytes: Vec<u8> = try!(Decodable::decode(d));
-        Ok(WindowsPath::new(bytes))
-    }
-}
-
 impl Encodable for path::Path {
     #[cfg(unix)]
     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {