---

yaml
---
r: 138740
b: refs/heads/try2
c: ce23c8c
h: refs/heads/master
v: v3

Author: yjh0502

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 165cc9e2c424b674a9e6fc88cc7c86ebc7d55b98
+refs/heads/try2: ce23c8c0cfc6aee3eae7d0287651ef7bcd9c6b9f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/io.rs

@@ -144,6 +144,12 @@ pub trait ReaderUtil {
     /// Read a big-endian i16 (2 bytes).
     fn read_be_i16(&self) -> i16;
 
+    /// Read a big-endian IEEE754 double-precision floating-point (8 bytes).
+    fn read_be_f64(&self) -> f64;
+
+    /// Read a big-endian IEEE754 single-precision floating-point (4 bytes).
+    fn read_be_f32(&self) -> f32;
+
     /// Read a little-endian u64 (8 bytes).
     fn read_le_u64(&self) -> u64;
 
@@ -162,6 +168,14 @@ pub trait ReaderUtil {
     /// Read a litle-endian i16 (2 bytes).
     fn read_le_i16(&self) -> i16;
 
+    /// Read a litten-endian IEEE754 double-precision floating-point
+    /// (8 bytes).
+    fn read_le_f64(&self) -> f64;
+
+    /// Read a litten-endian IEEE754 single-precision floating-point
+    /// (4 bytes).
+    fn read_le_f32(&self) -> f32;
+
     /// Read a u8 (1 byte).
     fn read_u8(&self) -> u8;
 
@@ -368,6 +382,18 @@ impl<T:Reader> ReaderUtil for T {
         self.read_be_int_n(2) as i16
     }
 
+    fn read_be_f64(&self) -> f64 {
+        unsafe {
+            cast::transmute::<u64, f64>(self.read_be_u64())
+        }
+    }
+
+    fn read_be_f32(&self) -> f32 {
+        unsafe {
+            cast::transmute::<u32, f32>(self.read_be_u32())
+        }
+    }
+
     fn read_le_u64(&self) -> u64 {
         self.read_le_uint_n(8) as u64
     }
@@ -392,6 +418,18 @@ impl<T:Reader> ReaderUtil for T {
         self.read_le_int_n(2) as i16
     }
 
+    fn read_le_f64(&self) -> f64 {
+        unsafe {
+            cast::transmute::<u64, f64>(self.read_le_u64())
+        }
+    }
+
+    fn read_le_f32(&self) -> f32 {
+        unsafe {
+            cast::transmute::<u32, f32>(self.read_le_u32())
+        }
+    }
+
     fn read_u8(&self) -> u8 {
         self.read_byte() as u8
     }
@@ -874,6 +912,12 @@ pub trait WriterUtil {
     /// Write a big-endian i16 (2 bytes).
     fn write_be_i16(&self, n: i16);
 
+    /// Write a big-endian IEEE754 double-precision floating-point (8 bytes).
+    fn write_be_f64(&self, f: f64);
+
+    /// Write a big-endian IEEE754 single-precision floating-point (4 bytes).
+    fn write_be_f32(&self, f: f32);
+
     /// Write a little-endian u64 (8 bytes).
     fn write_le_u64(&self, n: u64);
 
@@ -892,6 +936,14 @@ pub trait WriterUtil {
     /// Write a little-endian i16 (2 bytes).
     fn write_le_i16(&self, n: i16);
 
+    /// Write a little-endian IEEE754 double-precision floating-point
+    /// (8 bytes).
+    fn write_le_f64(&self, f: f64);
+
+    /// Write a litten-endian IEEE754 single-precision floating-point
+    /// (4 bytes).
+    fn write_le_f32(&self, f: f32);
+
     /// Write a u8 (1 byte).
     fn write_u8(&self, n: u8);
 
@@ -948,6 +1000,16 @@ impl<T:Writer> WriterUtil for T {
     fn write_be_i16(&self, n: i16) {
         u64_to_be_bytes(n as u64, 2u, |v| self.write(v))
     }
+    fn write_be_f64(&self, f:f64) {
+        unsafe {
+            self.write_be_u64(cast::transmute(f))
+        }
+    }
+    fn write_be_f32(&self, f:f32) {
+        unsafe {
+            self.write_be_u32(cast::transmute(f))
+        }
+    }
     fn write_le_u64(&self, n: u64) {
         u64_to_le_bytes(n, 8u, |v| self.write(v))
     }
@@ -966,9 +1028,20 @@ impl<T:Writer> WriterUtil for T {
     fn write_le_i16(&self, n: i16) {
         u64_to_le_bytes(n as u64, 2u, |v| self.write(v))
     }
+    fn write_le_f64(&self, f:f64) {
+        unsafe {
+            self.write_le_u64(cast::transmute(f))
+        }
+    }
+    fn write_le_f32(&self, f:f32) {
+        unsafe {
+            self.write_le_u32(cast::transmute(f))
+        }
+    }
 
     fn write_u8(&self, n: u8) { self.write([n]) }
     fn write_i8(&self, n: i8) { self.write([n as u8]) }
+
 }
 
 #[allow(non_implicitly_copyable_typarams)]
@@ -1421,6 +1494,41 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_read_f32() {
+        let path = Path("tmp/lib-io-test-read-f32.tmp");
+        //big-endian floating-point 8.1250
+        let buf = ~[0x41, 0x02, 0x00, 0x00];
+
+        {
+            let file = io::file_writer(&path, [io::Create]).get();
+            file.write(buf);
+        }
+
+        {
+            let file = io::file_reader(&path).get();
+            let f = file.read_be_f32();
+            assert f == 8.1250;
+        }
+    }
+
+#[test]
+    fn test_read_write_f32() {
+        let path = Path("tmp/lib-io-test-read-write-f32.tmp");
+        let f:f32 = 8.1250;
+
+        {
+            let file = io::file_writer(&path, [io::Create]).get();
+            file.write_be_f32(f);
+            file.write_le_f32(f);
+        }
+
+        {
+            let file = io::file_reader(&path).get();
+            assert file.read_be_f32() == 8.1250;
+            assert file.read_le_f32() == 8.1250;
+        }
+    }
 }
 
 //

branches/try2/src/libcore/trie.rs

@@ -13,7 +13,6 @@
 use prelude::*;
 
 // FIXME: #3469: need to manually update TrieNode when SHIFT changes
-// FIXME: #5244: need to manually update the TrieNode constructor
 const SHIFT: uint = 4;
 const SIZE: uint = 1 << SHIFT;
 const MASK: uint = SIZE - 1;
@@ -57,7 +56,7 @@ impl<T> Container for TrieMap<T> {
     pure fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
-impl<T> Mutable for TrieMap<T> {
+impl<T: Copy> Mutable for TrieMap<T> {
     /// Clear the map, removing all values.
     #[inline(always)]
     fn clear(&mut self) {
@@ -66,7 +65,7 @@ impl<T> Mutable for TrieMap<T> {
     }
 }
 
-impl<T> Map<uint, T> for TrieMap<T> {
+impl<T: Copy> Map<uint, T> for TrieMap<T> {
     /// Return true if the map contains a value for the specified key
     #[inline(always)]
     pure fn contains_key(&self, key: &uint) -> bool {
@@ -128,7 +127,7 @@ impl<T> Map<uint, T> for TrieMap<T> {
     }
 }
 
-impl<T> TrieMap<T> {
+impl<T: Copy> TrieMap<T> {
     #[inline(always)]
     static pure fn new() -> TrieMap<T> {
         TrieMap{root: TrieNode::new(), length: 0}
@@ -210,15 +209,10 @@ struct TrieNode<T> {
     children: [Child<T> * 16] // FIXME: #3469: can't use the SIZE constant yet
 }
 
-impl<T> TrieNode<T> {
+impl<T: Copy> TrieNode<T> {
     #[inline(always)]
     static pure fn new() -> TrieNode<T> {
-        // FIXME: #5244: [Nothing, ..SIZE] should be possible without Copy
-        TrieNode{count: 0,
-                 children: [Nothing, Nothing, Nothing, Nothing,
-                            Nothing, Nothing, Nothing, Nothing,
-                            Nothing, Nothing, Nothing, Nothing,
-                            Nothing, Nothing, Nothing, Nothing]}
+        TrieNode{count: 0, children: [Nothing, ..SIZE]}
     }
 }
 
@@ -266,16 +260,12 @@ pure fn chunk(n: uint, idx: uint) -> uint {
     (n >> (SHIFT * real_idx)) & MASK
 }
 
-fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
+fn insert<T: Copy>(count: &mut uint, child: &mut Child<T>, key: uint,
                    value: T, idx: uint) -> bool {
-    let mut tmp = Nothing;
-    tmp <-> *child;
-    let mut added = false;
-
-    *child = match tmp {
+    match *child {
       External(stored_key, stored_value) => {
           if stored_key == key {
-              External(stored_key, value)
+              false // already in the trie
           } else {
               // conflict - split the node
               let mut new = ~TrieNode::new();
@@ -284,24 +274,20 @@ fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
                      stored_key, stored_value, idx + 1);
               insert(&mut new.count, &mut new.children[chunk(key, idx)], key,
                      value, idx + 1);
-              added = true;
-              Internal(new)
+              *child = Internal(new);
+              true
           }
       }
-      Internal(x) => {
-        let mut x = x;
-        added = insert(&mut x.count, &mut x.children[chunk(key, idx)], key,
-                       value, idx + 1);
-        Internal(x)
-
+      Internal(ref mut x) => {
+        insert(&mut x.count, &mut x.children[chunk(key, idx)], key, value,
+               idx + 1)
       }
       Nothing => {
         *count += 1;
-        added = true;
-        External(key, value)
+        *child = External(key, value);
+        true
       }
-    };
-    added
+    }
 }
 
 fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,