Migrate std::map to use core::hash::Hash trait. Disable many hokey hashes.

2 files changed, 218 insertions, 192 deletions

diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs
index 48fc9f205b9..ef792ef690e 100644
--- a/src/libcore/hash.rs
+++ b/src/libcore/hash.rs
@@ -64,7 +64,7 @@ impl <A: IterBytes> A: Hash {
     pure fn hash_keyed(k0: u64, k1: u64) -> u64 {
         unchecked {
             let s = &State(k0, k1);
-            for self.iter_le_bytes |bytes| {
+            for self.iter_bytes(true) |bytes| {
                 s.input(bytes);
             }
             s.result_u64()
@@ -79,8 +79,8 @@ pure fn hash_keyed_2<A: IterBytes,
                                    k0: u64, k1: u64) -> u64 {
     unchecked {
         let s = &State(k0, k1);
-        for a.iter_le_bytes |bytes| { s.input(bytes); }
-        for b.iter_le_bytes |bytes| { s.input(bytes); }
+        for a.iter_bytes(true) |bytes| { s.input(bytes); }
+        for b.iter_bytes(true) |bytes| { s.input(bytes); }
         s.result_u64()
     }
 }
@@ -91,9 +91,9 @@ pure fn hash_keyed_3<A: IterBytes,
                                    k0: u64, k1: u64) -> u64 {
     unchecked {
         let s = &State(k0, k1);
-        for a.iter_le_bytes |bytes| { s.input(bytes); }
-        for b.iter_le_bytes |bytes| { s.input(bytes); }
-        for c.iter_le_bytes |bytes| { s.input(bytes); }
+        for a.iter_bytes(true) |bytes| { s.input(bytes); }
+        for b.iter_bytes(true) |bytes| { s.input(bytes); }
+        for c.iter_bytes(true) |bytes| { s.input(bytes); }
         s.result_u64()
     }
 }
@@ -105,10 +105,10 @@ pure fn hash_keyed_4<A: IterBytes,
                                    k0: u64, k1: u64) -> u64 {
     unchecked {
         let s = &State(k0, k1);
-        for a.iter_le_bytes |bytes| { s.input(bytes); }
-        for b.iter_le_bytes |bytes| { s.input(bytes); }
-        for c.iter_le_bytes |bytes| { s.input(bytes); }
-        for d.iter_le_bytes |bytes| { s.input(bytes); }
+        for a.iter_bytes(true) |bytes| { s.input(bytes); }
+        for b.iter_bytes(true) |bytes| { s.input(bytes); }
+        for c.iter_bytes(true) |bytes| { s.input(bytes); }
+        for d.iter_bytes(true) |bytes| { s.input(bytes); }
         s.result_u64()
     }
 }
@@ -121,11 +121,11 @@ pure fn hash_keyed_5<A: IterBytes,
                                    k0: u64, k1: u64) -> u64 {
     unchecked {
         let s = &State(k0, k1);
-        for a.iter_le_bytes |bytes| { s.input(bytes); }
-        for b.iter_le_bytes |bytes| { s.input(bytes); }
-        for c.iter_le_bytes |bytes| { s.input(bytes); }
-        for d.iter_le_bytes |bytes| { s.input(bytes); }
-        for e.iter_le_bytes |bytes| { s.input(bytes); }
+        for a.iter_bytes(true) |bytes| { s.input(bytes); }
+        for b.iter_bytes(true) |bytes| { s.input(bytes); }
+        for c.iter_bytes(true) |bytes| { s.input(bytes); }
+        for d.iter_bytes(true) |bytes| { s.input(bytes); }
+        for e.iter_bytes(true) |bytes| { s.input(bytes); }
         s.result_u64()
     }
 }
diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs
index 077f56cab45..f619085bd4b 100644
--- a/src/libcore/to_bytes.rs
+++ b/src/libcore/to_bytes.rs
@@ -7,221 +7,273 @@ use io::Writer;
 type Cb = fn(buf: &[const u8]) -> bool;
 
 trait IterBytes {
-    fn iter_le_bytes(f: Cb);
-    fn iter_be_bytes(f: Cb);
+    fn iter_bytes(lsb0: bool, f: Cb);
 }
 
 impl u8: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
+    fn iter_bytes(_lsb0: bool, f: Cb) {
         f([
-            self,
-        ]);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        f([
-            self as u8
+            self
         ]);
     }
 }
 
 impl u16: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        f([
-            self as u8,
-            (self >> 8) as u8
-        ]);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        f([
-            (self >> 8) as u8,
-            self as u8
-        ]);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        if lsb0 {
+            f([
+                self as u8,
+                (self >> 8) as u8
+            ]);
+        } else {
+            f([
+                (self >> 8) as u8,
+                self as u8
+            ]);
+        }
     }
 }
 
 impl u32: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        f([
-            self as u8,
-            (self >> 8) as u8,
-            (self >> 16) as u8,
-            (self >> 24) as u8,
-        ]);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        f([
-            (self >> 24) as u8,
-            (self >> 16) as u8,
-            (self >> 8) as u8,
-            self as u8
-        ]);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        if lsb0 {
+            f([
+                self as u8,
+                (self >> 8) as u8,
+                (self >> 16) as u8,
+                (self >> 24) as u8,
+            ]);
+        } else {
+            f([
+                (self >> 24) as u8,
+                (self >> 16) as u8,
+                (self >> 8) as u8,
+                self as u8
+            ]);
+        }
     }
 }
 
 impl u64: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        f([
-            self as u8,
-            (self >> 8) as u8,
-            (self >> 16) as u8,
-            (self >> 24) as u8,
-            (self >> 32) as u8,
-            (self >> 40) as u8,
-            (self >> 48) as u8,
-            (self >> 56) as u8
-        ]);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        f([
-            (self >> 56) as u8,
-            (self >> 48) as u8,
-            (self >> 40) as u8,
-            (self >> 32) as u8,
-            (self >> 24) as u8,
-            (self >> 16) as u8,
-            (self >> 8) as u8,
-            self as u8
-        ]);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        if lsb0 {
+            f([
+                self as u8,
+                (self >> 8) as u8,
+                (self >> 16) as u8,
+                (self >> 24) as u8,
+                (self >> 32) as u8,
+                (self >> 40) as u8,
+                (self >> 48) as u8,
+                (self >> 56) as u8
+            ]);
+        } else {
+            f([
+                (self >> 56) as u8,
+                (self >> 48) as u8,
+                (self >> 40) as u8,
+                (self >> 32) as u8,
+                (self >> 24) as u8,
+                (self >> 16) as u8,
+                (self >> 8) as u8,
+                self as u8
+            ]);
+        }
     }
 }
 
 impl i8: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u8).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u8).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u8).iter_bytes(lsb0, f)
+    }
 }
 
 impl i16: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u16).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u16).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u16).iter_bytes(lsb0, f)
+    }
 }
 
 impl i32: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u32).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u32).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u32).iter_bytes(lsb0, f)
+    }
 }
 
 impl i64: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u64).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u64).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u64).iter_bytes(lsb0, f)
+    }
 }
 
 #[cfg(target_word_size = "32")]
 impl uint: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u32).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u32).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u32).iter_bytes(lsb0, f)
+    }
 }
 
 #[cfg(target_word_size = "64")]
 impl uint: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as u64).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as u64).iter_be_bytes(f) }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as u64).iter_bytes(lsb0, f)
+    }
 }
 
 impl int: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) { (self as uint).iter_le_bytes(f) }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { (self as uint).iter_be_bytes(f) }
-}
-
-impl ~[const u8]: IterBytes {
-    #[inline(always)]
-    fn iter_le_bytes(f: Cb) { f(self); }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { f(self); }
-}
-
-impl @[const u8]: IterBytes {
-    #[inline(always)]
-    fn iter_le_bytes(f: Cb) { f(self); }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) { f(self); }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as uint).iter_bytes(lsb0, f)
+    }
 }
 
 impl<A: IterBytes> &[const A]: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
+    fn iter_bytes(lsb0: bool, f: Cb) {
         for self.each |elt| {
-            do elt.iter_le_bytes |bytes| {
+            do elt.iter_bytes(lsb0) |bytes| {
                 f(bytes)
             }
         }
     }
+}
+
+// Move this to vec, probably.
+fn borrow<A>(a: &x/[const A]) -> &x/[const A] {
+    a
+}
+
+impl<A: IterBytes> ~[const A]: IterBytes {
     #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        for self.each |elt| {
-            do elt.iter_be_bytes |bytes| {
-                f(bytes)
-            }
-        }
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        borrow(self).iter_bytes(lsb0, f)
     }
 }
 
-fn iter_le_bytes_2<A: IterBytes, B: IterBytes>(a: &A, b: &B, f: Cb) {
+
+impl<A: IterBytes> @[const A]: IterBytes {
+    #[inline(always)]
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        borrow(self).iter_bytes(lsb0, f)
+    }
+}
+
+fn iter_bytes_2<A: IterBytes, B: IterBytes>(a: &A, b: &B,
+                                            lsb0: bool, z: Cb) {
+    let mut flag = true;
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+}
+
+fn iter_bytes_3<A: IterBytes,
+                B: IterBytes,
+                C: IterBytes>(a: &A, b: &B, c: &C,
+                              lsb0: bool, z: Cb) {
+    let mut flag = true;
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+}
+
+fn iter_bytes_4<A: IterBytes,
+                B: IterBytes,
+                C: IterBytes,
+                D: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D,
+                              lsb0: bool, z: Cb) {
     let mut flag = true;
-    a.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-    b.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 
-fn iter_be_bytes_2<A: IterBytes, B: IterBytes>(a: &A, b: &B, f: Cb) {
+fn iter_bytes_5<A: IterBytes,
+                B: IterBytes,
+                C: IterBytes,
+                D: IterBytes,
+                E: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D, e: &E,
+                              lsb0: bool, z: Cb) {
     let mut flag = true;
-    a.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-    b.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 
-fn iter_le_bytes_3<A: IterBytes,
-                   B: IterBytes,
-                   C: IterBytes>(a: &A, b: &B, c: &C, f: Cb) {
+fn iter_bytes_6<A: IterBytes,
+                B: IterBytes,
+                C: IterBytes,
+                D: IterBytes,
+                E: IterBytes,
+                F: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D, e: &E, f: &F,
+                              lsb0: bool, z: Cb) {
     let mut flag = true;
-    a.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-    b.iter_le_bytes(|bytes| { flag = f(bytes); flag});
+    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-    c.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 
-fn iter_be_bytes_3<A: IterBytes,
-                   B: IterBytes,
-                   C: IterBytes>(a: &A, b: &B, c: &C, f: Cb) {
+fn iter_bytes_7<A: IterBytes,
+                B: IterBytes,
+                C: IterBytes,
+                D: IterBytes,
+                E: IterBytes,
+                F: IterBytes,
+                G: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D, e: &E, f: &F,
+                              g: &G,
+                              lsb0: bool, z: Cb) {
     let mut flag = true;
-                       a.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-                       b.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
-                       c.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+    if !flag { return; }
+    g.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 
 impl &str: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        do str::byte_slice(self) |bytes| {
-            f(bytes);
-        }
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
+    fn iter_bytes(_lsb0: bool, f: Cb) {
         do str::byte_slice(self) |bytes| {
             f(bytes);
         }
@@ -230,13 +282,7 @@ impl &str: IterBytes {
 
 impl ~str: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        do str::byte_slice(self) |bytes| {
-            f(bytes);
-        }
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
+    fn iter_bytes(_lsb0: bool, f: Cb) {
         do str::byte_slice(self) |bytes| {
             f(bytes);
         }
@@ -245,48 +291,41 @@ impl ~str: IterBytes {
 
 impl @str: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
+    fn iter_bytes(_lsb0: bool, f: Cb) {
         do str::byte_slice(self) |bytes| {
             f(bytes);
         }
     }
+}
+
+impl<A: IterBytes> Option<A>: IterBytes {
     #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        do str::byte_slice(self) |bytes| {
-            f(bytes);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        match self {
+          Some(a) => iter_bytes_2(&0u8, &a, lsb0, f),
+          None => 1u8.iter_bytes(lsb0, f)
         }
     }
 }
+
 impl<A: IterBytes> &A: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        (*self).iter_le_bytes(f);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        (*self).iter_be_bytes(f);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (*self).iter_bytes(lsb0, f);
     }
 }
 
 impl<A: IterBytes> @A: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        (*self).iter_le_bytes(f);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        (*self).iter_be_bytes(f);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (*self).iter_bytes(lsb0, f);
     }
 }
 
 impl<A: IterBytes> ~A: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        (*self).iter_le_bytes(f);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        (*self).iter_be_bytes(f);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (*self).iter_bytes(lsb0, f);
     }
 }
 
@@ -294,35 +333,22 @@ impl<A: IterBytes> ~A: IterBytes {
 // to the target; it just gives you the pointer-bytes.
 impl<A> *A: IterBytes {
     #[inline(always)]
-    fn iter_le_bytes(f: Cb) {
-        (self as uint).iter_le_bytes(f);
-    }
-    #[inline(always)]
-    fn iter_be_bytes(f: Cb) {
-        (self as uint).iter_be_bytes(f);
+    fn iter_bytes(lsb0: bool, f: Cb) {
+        (self as uint).iter_bytes(lsb0, f);
     }
 }
 
 
 trait ToBytes {
-    fn to_le_bytes() -> ~[u8];
-    fn to_be_bytes() -> ~[u8];
+    fn to_bytes(lsb0: bool) -> ~[u8];
 }
 
 impl<A: IterBytes> A: ToBytes {
-    fn to_le_bytes() -> ~[u8] {
+    fn to_bytes(lsb0: bool) -> ~[u8] {
         let buf = io::mem_buffer();
-        for self.iter_le_bytes |bytes| {
+        for self.iter_bytes(lsb0) |bytes| {
             buf.write(bytes)
         }
         io::mem_buffer_buf(buf)
     }
-    fn to_be_bytes() -> ~[u8] {
-        let buf = io::mem_buffer();
-        for self.iter_be_bytes |bytes| {
-            buf.write(bytes)
-        }
-        io::mem_buffer_buf(buf)
-    }
-
 }