Start moving core::hash to support a Hash trait. Add to_bytes::IterBytes trait.

src/libcore/to_bytes.rs

@@ -2,22 +2,314 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+import io::Writer;
+
+type Cb = fn(buf: &[const u8]) -> bool;
+
+trait IterBytes {
+    fn iter_le_bytes(f: Cb);
+    fn iter_be_bytes(f: Cb);
+}
+
+impl u8: IterBytes {
+    #[inline(always)]
+    fn iter_le_bytes(f: Cb) {
+        f([
+            self,
+        ]);
+    }
+    #[inline(always)]
+    fn iter_be_bytes(f: Cb) {
+        f([
+            self as u8
+        ]);
+    }
+}
+
+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
+        ]);
+    }
+}
+
+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
+        ]);
+    }
+}
+
+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
+        ]);
+    }
+}
+
+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) }
+}
+
+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) }
+}
+
+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) }
+}
+
+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) }
+}
+
+#[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) }
+}
+
+#[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) }
+}
+
+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); }
+}
+
+impl<A: IterBytes> &[const A]: IterBytes {
+    #[inline(always)]
+    fn iter_le_bytes(f: Cb) {
+        for self.each |elt| {
+            do elt.iter_le_bytes |bytes| {
+                f(bytes)
+            }
+        }
+    }
+    #[inline(always)]
+    fn iter_be_bytes(f: Cb) {
+        for self.each |elt| {
+            do elt.iter_be_bytes |bytes| {
+                f(bytes)
+            }
+        }
+    }
+}
+
+fn iter_le_bytes_2<A: IterBytes, B: IterBytes>(a: &A, b: &B, f: Cb) {
+    let mut flag = true;
+    a.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    if !flag { return; }
+    b.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+}
+
+fn iter_be_bytes_2<A: IterBytes, B: IterBytes>(a: &A, b: &B, f: Cb) {
+    let mut flag = true;
+    a.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    if !flag { return; }
+    b.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+}
+
+fn iter_le_bytes_3<A: IterBytes,
+                   B: IterBytes,
+                   C: IterBytes>(a: &A, b: &B, c: &C, f: Cb) {
+    let mut flag = true;
+    a.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+    if !flag { return; }
+    b.iter_le_bytes(|bytes| { flag = f(bytes); flag});
+    if !flag { return; }
+    c.iter_le_bytes(|bytes| {flag = f(bytes); flag});
+}
+
+fn iter_be_bytes_3<A: IterBytes,
+                   B: IterBytes,
+                   C: IterBytes>(a: &A, b: &B, c: &C, f: Cb) {
+    let mut flag = true;
+                       a.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    if !flag { return; }
+                       b.iter_be_bytes(|bytes| {flag = f(bytes); flag});
+    if !flag { return; }
+                       c.iter_be_bytes(|bytes| {flag = f(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) {
+        do str::byte_slice(self) |bytes| {
+            f(bytes);
+        }
+    }
+}
+
+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) {
+        do str::byte_slice(self) |bytes| {
+            f(bytes);
+        }
+    }
+}
+
+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) {
+        do str::byte_slice(self) |bytes| {
+            f(bytes);
+        }
+    }
+}
+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);
+    }
+}
+
+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);
+    }
+}
+
+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);
+    }
+}
+
+
 trait ToBytes {
-    fn to_bytes() -> ~[u8];
+    fn to_le_bytes() -> ~[u8];
+    fn to_be_bytes() -> ~[u8];
 }
 
-impl ~[u8]: ToBytes {
-    fn to_bytes() -> ~[u8] { copy self }
-}
+impl<A: IterBytes> A: ToBytes {
+    fn to_le_bytes() -> ~[u8] {
+        let buf = io::mem_buffer();
+        for self.iter_le_bytes |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)
+    }
 
-impl @~[u8]: ToBytes {
-    fn to_bytes() -> ~[u8] { copy *self }
-}
-
-impl ~str: ToBytes {
-    fn to_bytes() -> ~[u8] { str::to_bytes(self) }
-}
-
-impl @(~str): ToBytes {
-    fn to_bytes() -> ~[u8] { str::to_bytes(*self) }
 }