Update to master

Author: vhbit

src/base64.rs

@@ -82,12 +82,13 @@ impl ToBase64 for [u8] {
     /// # Example
     ///
     /// ```rust
-    /// extern crate serialize;
-    /// use serialize::base64::{ToBase64, STANDARD};
+    /// # #![allow(staged_unstable)]
+    /// extern crate "rustc-serialize" as rustc_serialize;
+    /// use rustc_serialize::base64::{ToBase64, STANDARD};
     ///
     /// fn main () {
     ///     let str = [52,32].to_base64(STANDARD);
-    ///     println!("base 64 output: {}", str);
+    ///     println!("base 64 output: {:?}", str);
     /// }
     /// ```
     fn to_base64(&self, config: Config) -> String {
@@ -204,7 +205,7 @@ impl error::Error for FromBase64Error {
     }
 
     fn detail(&self) -> Option<String> {
-        Some(self.to_string())
+        Some(format!("{:?}", self))
     }
 }
 
@@ -220,8 +221,10 @@ impl FromBase64 for str {
     /// This converts a string literal to base64 and back.
     ///
     /// ```rust
-    /// extern crate serialize;
-    /// use serialize::base64::{ToBase64, FromBase64, STANDARD};
+    /// # #![allow(staged_unstable)]
+    /// # #![allow(staged_experimental)]
+    /// extern crate "rustc-serialize" as rustc_serialize;
+    /// use rustc_serialize::base64::{ToBase64, FromBase64, STANDARD};
     ///
     /// fn main () {
     ///     let hello_str = b"Hello, World".to_base64(STANDARD);
@@ -230,7 +233,7 @@ impl FromBase64 for str {
     ///     if res.is_ok() {
     ///       let opt_bytes = String::from_utf8(res.unwrap());
     ///       if opt_bytes.is_ok() {
-    ///         println!("decoded from base64: {}", opt_bytes.unwrap());
+    ///         println!("decoded from base64: {:?}", opt_bytes.unwrap());
     ///       }
     ///     }
     /// }

src/collection_impls.rs

@@ -15,6 +15,7 @@ use std::hash::{Hash, Hasher};
 
 use {Decodable, Encodable, Decoder, Encoder};
 use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
+use std::collections::hash_state::HashState;
 
 impl<
     T: Encodable
@@ -127,13 +128,13 @@ impl<
     }
 }
 
-impl<
-    K: Encodable + Hash<X> + Eq,
-    V: Encodable,
-    X,
-    H: Hasher<X>
-> Encodable for HashMap<K, V, H> {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
+impl<K, V, S> Encodable for HashMap<K, V, S>
+    where K: Encodable + Hash< <S as HashState>::Hasher> + 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| {
             let mut i = 0;
             for (key, val) in self.iter() {
@@ -146,16 +147,16 @@ impl<
     }
 }
 
-impl<
-    K: Decodable + Hash<S> + Eq,
-    V: Decodable,
-    S,
-    H: Hasher<S> + Default
-> Decodable for HashMap<K, V, H> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, H>, D::Error> {
+impl<K, V, S> Decodable for HashMap<K, V, S>
+    where K: Decodable + Hash< <S as HashState>::Hasher> + 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| {
-            let hasher = Default::default();
-            let mut map = HashMap::with_capacity_and_hasher(len, hasher);
+            let state = Default::default();
+            let mut map = HashMap::with_capacity_and_hash_state(len, state);
             for i in range(0u, 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)));
@@ -166,12 +167,12 @@ impl<
     }
 }
 
-impl<
-    T: Encodable + Hash<X> + Eq,
-    X,
-    H: Hasher<X>
-> Encodable for HashSet<T, H> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+impl<T, S> Encodable for HashSet<T, S>
+    where T: Encodable + Hash< <S as HashState>::Hasher> + 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| {
             let mut i = 0;
             for e in self.iter() {
@@ -183,22 +184,22 @@ impl<
     }
 }
 
-impl<
-    T: Decodable + Hash<S> + Eq,
-    S,
-    H: Hasher<S> + Default
-> Decodable for HashSet<T, H> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, H>, D::Error> {
+impl<T, S> Decodable for HashSet<T, S>
+    where T: Decodable + Hash< <S as HashState>::Hasher> + 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| {
-            let mut set = HashSet::with_capacity_and_hasher(len, Default::default());
+            let state = Default::default();
+            let mut set = HashSet::with_capacity_and_hash_state(len, state);
             for i in range(0u, len) {
                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(set)
         })
     }
 }
-
 impl<V: Encodable> Encodable for VecMap<V> {
     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
         e.emit_map(self.len(), |e| {

src/hex.rs

@@ -32,8 +32,9 @@ impl ToHex for [u8] {
     /// # Example
     ///
     /// ```rust
-    /// extern crate serialize;
-    /// use serialize::hex::ToHex;
+    /// # #![allow(staged_unstable)]
+    /// extern crate "rustc-serialize" as rustc_serialize;
+    /// use rustc_serialize::hex::ToHex;
     ///
     /// fn main () {
     ///     let str = [52,32].to_hex();
@@ -88,7 +89,7 @@ impl error::Error for FromHexError {
     }
 
     fn detail(&self) -> Option<String> {
-        Some(self.to_string())
+        Some(format!("{:?}", self))
     }
 }
 
@@ -105,14 +106,15 @@ impl FromHex for str {
     /// This converts a string literal to hexadecimal and back.
     ///
     /// ```rust
-    /// extern crate serialize;
-    /// use serialize::hex::{FromHex, ToHex};
+    /// # #![allow(staged_unstable)]
+    /// extern crate "rustc-serialize" as rustc_serialize;
+    /// use rustc_serialize::hex::{FromHex, ToHex};
     ///
     /// fn main () {
     ///     let hello_str = "Hello, World".as_bytes().to_hex();
     ///     println!("{}", hello_str);
     ///     let bytes = hello_str.as_slice().from_hex().unwrap();
-    ///     println!("{}", bytes);
+    ///     println!("{:?}", bytes);
     ///     let result_str = String::from_utf8(bytes).unwrap();
     ///     println!("{}", result_str);
     /// }