---

yaml
---
r: 44368
b: refs/heads/master
c: 48b2141
h: refs/heads/master
v: v3

Author: brendanzab

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4fb4a4b66d5c988d79f77b081dabd8f62b880dfe
+refs/heads/master: 48b2141b83bd3afe6aee3adf170ef6e985ab1353
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/core.rc

@@ -199,7 +199,7 @@ pub use vec::{OwnedVector, OwnedCopyableVector};
 pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
 pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 
-pub use num::Num;
+pub use num::{Num, NumCast};
 pub use ptr::Ptr;
 pub use to_str::ToStr;
 pub use clone::Clone;

trunk/src/libcore/hashmap.rs

@@ -108,17 +108,19 @@ pub mod linear {
         }
 
         #[inline(always)]
-        pure fn bucket_for_key(&self, k: &K) -> SearchResult {
+        pure fn bucket_for_key(&self, buckets: &[Option<Bucket<K, V>>],
+                               k: &K) -> SearchResult {
             let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            self.bucket_for_key_with_hash(hash, k)
+            self.bucket_for_key_with_hash(buckets, hash, k)
         }
 
         #[inline(always)]
         pure fn bucket_for_key_with_hash(&self,
+                                         buckets: &[Option<Bucket<K, V>>],
                                          hash: uint,
                                          k: &K) -> SearchResult {
             let _ = for self.bucket_sequence(hash) |i| {
-                match self.buckets[i] {
+                match buckets[i] {
                     Some(ref bkt) => if bkt.hash == hash && *k == bkt.key {
                         return FoundEntry(i);
                     },
@@ -155,19 +157,11 @@ pub mod linear {
             }
         }
 
-        #[inline(always)]
-        pure fn value_for_bucket(&self, idx: uint) -> &self/V {
-            match self.buckets[idx] {
-                Some(ref bkt) => &bkt.value,
-                None => die!(~"LinearMap::find: internal logic error"),
-            }
-        }
-
         /// Inserts the key value pair into the buckets.
         /// Assumes that there will be a bucket.
         /// True if there was no previous entry with that key
         fn insert_internal(&mut self, hash: uint, k: K, v: V) -> bool {
-            match self.bucket_for_key_with_hash(hash, &k) {
+            match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
                 TableFull => { die!(~"Internal logic error"); }
                 FoundHole(idx) => {
                     debug!("insert fresh (%?->%?) at idx %?, hash %?",
@@ -202,7 +196,8 @@ pub mod linear {
             //
             // I found this explanation elucidating:
             // http://www.maths.lse.ac.uk/Courses/MA407/del-hash.pdf
-            let mut idx = match self.bucket_for_key_with_hash(hash, k) {
+            let mut idx = match self.bucket_for_key_with_hash(self.buckets,
+                                                              hash, k) {
                 TableFull | FoundHole(_) => return None,
                 FoundEntry(idx) => idx
             };
@@ -278,7 +273,7 @@ pub mod linear {
     impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Map<K, V> {
         /// Return true if the map contains a value for the specified key
         pure fn contains_key(&self, k: &K) -> bool {
-            match self.bucket_for_key(k) {
+            match self.bucket_for_key(self.buckets, k) {
                 FoundEntry(_) => {true}
                 TableFull | FoundHole(_) => {false}
             }
@@ -296,9 +291,20 @@ pub mod linear {
 
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
-            match self.bucket_for_key(k) {
-                FoundEntry(idx) => Some(self.value_for_bucket(idx)),
-                TableFull | FoundHole(_) => None,
+            match self.bucket_for_key(self.buckets, k) {
+                FoundEntry(idx) => {
+                    match self.buckets[idx] {
+                        Some(ref bkt) => {
+                            Some(&bkt.value)
+                        }
+                        None => {
+                            die!(~"LinearMap::find: internal logic error")
+                        }
+                    }
+                }
+                TableFull | FoundHole(_) => {
+                    None
+                }
             }
         }
 
@@ -358,63 +364,6 @@ pub mod linear {
             old_value
         }
 
-        /// Return the value corresponding to the key in the map, or insert
-        /// and return the value if it doesn't exist.
-        fn find_or_insert(&mut self, k: K, v: V) -> &self/V {
-            if self.size >= self.resize_at {
-                // n.b.: We could also do this after searching, so
-                // that we do not resize if this call to insert is
-                // simply going to update a key in place.  My sense
-                // though is that it's worse to have to search through
-                // buckets to find the right spot twice than to just
-                // resize in this corner case.
-                self.expand();
-            }
-
-            let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            let idx = match self.bucket_for_key_with_hash(hash, &k) {
-                TableFull => die!(~"Internal logic error"),
-                FoundEntry(idx) => idx,
-                FoundHole(idx) => {
-                    self.buckets[idx] = Some(Bucket{hash: hash, key: k,
-                                         value: v});
-                    self.size += 1;
-                    idx
-                },
-            };
-
-            self.value_for_bucket(idx)
-        }
-
-        /// Return the value corresponding to the key in the map, or create,
-        /// insert, and return a new value if it doesn't exist.
-        fn find_or_insert_with(&mut self, k: K, f: fn(&K) -> V) -> &self/V {
-            if self.size >= self.resize_at {
-                // n.b.: We could also do this after searching, so
-                // that we do not resize if this call to insert is
-                // simply going to update a key in place.  My sense
-                // though is that it's worse to have to search through
-                // buckets to find the right spot twice than to just
-                // resize in this corner case.
-                self.expand();
-            }
-
-            let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            let idx = match self.bucket_for_key_with_hash(hash, &k) {
-                TableFull => die!(~"Internal logic error"),
-                FoundEntry(idx) => idx,
-                FoundHole(idx) => {
-                    let v = f(&k);
-                    self.buckets[idx] = Some(Bucket{hash: hash, key: k,
-                                         value: v});
-                    self.size += 1;
-                    idx
-                },
-            };
-
-            self.value_for_bucket(idx)
-        }
-
         fn consume(&mut self, f: fn(K, V)) {
             let mut buckets = ~[];
             self.buckets <-> buckets;
@@ -572,7 +521,7 @@ mod test_map {
     use uint;
 
     #[test]
-    pub fn test_insert() {
+    pub fn inserts() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert m.insert(2, 4);
@@ -581,7 +530,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_insert_overwrite() {
+    pub fn overwrite() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert *m.get(&1) == 2;
@@ -590,7 +539,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_insert_conflicts() {
+    pub fn conflicts() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert m.insert(5, 3);
@@ -601,7 +550,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_conflict_remove() {
+    pub fn conflict_remove() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert m.insert(5, 3);
@@ -612,7 +561,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_is_empty() {
+    pub fn empty() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert !m.is_empty();
@@ -621,37 +570,23 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_pop() {
+    pub fn pops() {
         let mut m = LinearMap::new();
         m.insert(1, 2);
         assert m.pop(&1) == Some(2);
         assert m.pop(&1) == None;
     }
 
     #[test]
-    pub fn test_swap() {
+    pub fn swaps() {
         let mut m = LinearMap::new();
         assert m.swap(1, 2) == None;
         assert m.swap(1, 3) == Some(2);
         assert m.swap(1, 4) == Some(3);
     }
 
     #[test]
-    pub fn test_find_or_insert() {
-        let mut m = LinearMap::new::<int, int>();
-        assert m.find_or_insert(1, 2) == &2;
-        assert m.find_or_insert(1, 3) == &2;
-    }
-
-    #[test]
-    pub fn test_find_or_insert_with() {
-        let mut m = LinearMap::new::<int, int>();
-        assert m.find_or_insert_with(1, |_| 2) == &2;
-        assert m.find_or_insert_with(1, |_| 3) == &2;
-    }
-
-    #[test]
-    pub fn test_consume() {
+    pub fn consumes() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert m.insert(2, 3);
@@ -666,7 +601,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_iterate() {
+    pub fn iterate() {
         let mut m = linear::linear_map_with_capacity(4);
         for uint::range(0, 32) |i| {
             assert m.insert(i, i*2);
@@ -680,7 +615,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_find() {
+    pub fn find() {
         let mut m = LinearMap::new();
         assert m.find(&1).is_none();
         m.insert(1, 2);

trunk/src/libcore/num/f32.rs

@@ -14,6 +14,7 @@ use cmath;
 use cmp;
 use libc::{c_float, c_int};
 use num;
+use num::NumCast;
 use option::Option;
 use from_str;
 use to_str;
@@ -283,11 +284,6 @@ impl f32: num::Num {
     pure fn modulo(&self, other: &f32) -> f32 { return *self % *other; }
     #[inline(always)]
     pure fn neg(&self)                -> f32 { return -*self;        }
-
-    #[inline(always)]
-    pure fn to_int(&self)         -> int { return *self as int; }
-    #[inline(always)]
-    static pure fn from_int(n: int) -> f32 { return n as f32;    }
 }
 
 impl f32: num::Zero {
@@ -300,6 +296,30 @@ impl f32: num::One {
     static pure fn one() -> f32 { 1.0 }
 }
 
+pub impl f32: NumCast {
+    /**
+     * Cast `n` to an `f32`
+     */
+    #[inline(always)]
+    static pure fn from<N:NumCast>(n: N) -> f32 { n.to_f32() }
+
+    #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
+    #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
+    #[inline(always)] pure fn to_u32(&self)   -> u32   { *self as u32   }
+    #[inline(always)] pure fn to_u64(&self)   -> u64   { *self as u64   }
+    #[inline(always)] pure fn to_uint(&self)  -> uint  { *self as uint  }
+
+    #[inline(always)] pure fn to_i8(&self)    -> i8    { *self as i8    }
+    #[inline(always)] pure fn to_i16(&self)   -> i16   { *self as i16   }
+    #[inline(always)] pure fn to_i32(&self)   -> i32   { *self as i32   }
+    #[inline(always)] pure fn to_i64(&self)   -> i64   { *self as i64   }
+    #[inline(always)] pure fn to_int(&self)   -> int   { *self as int   }
+
+    #[inline(always)] pure fn to_f32(&self)   -> f32   { *self          }
+    #[inline(always)] pure fn to_f64(&self)   -> f64   { *self as f64   }
+    #[inline(always)] pure fn to_float(&self) -> float { *self as float }
+}
+
 #[abi="rust-intrinsic"]
 pub extern {
     fn floorf32(val: f32) -> f32;
@@ -545,6 +565,63 @@ impl f32: num::FromStrRadix {
     }
 }
 
+#[test]
+pub fn test_num() {
+    let ten: f32 = num::cast(10);
+    let two: f32 = num::cast(2);
+
+    assert (ten.add(&two)    == num::cast(12));
+    assert (ten.sub(&two)    == num::cast(8));
+    assert (ten.mul(&two)    == num::cast(20));
+    assert (ten.div(&two)    == num::cast(5));
+    assert (ten.modulo(&two) == num::cast(0));
+}
+
+#[test]
+fn test_numcast() {
+    assert (20u     == 20f32.to_uint());
+    assert (20u8    == 20f32.to_u8());
+    assert (20u16   == 20f32.to_u16());
+    assert (20u32   == 20f32.to_u32());
+    assert (20u64   == 20f32.to_u64());
+    assert (20i     == 20f32.to_int());
+    assert (20i8    == 20f32.to_i8());
+    assert (20i16   == 20f32.to_i16());
+    assert (20i32   == 20f32.to_i32());
+    assert (20i64   == 20f32.to_i64());
+    assert (20f     == 20f32.to_float());
+    assert (20f32   == 20f32.to_f32());
+    assert (20f64   == 20f32.to_f64());
+
+    assert (20f32 == NumCast::from(20u));
+    assert (20f32 == NumCast::from(20u8));
+    assert (20f32 == NumCast::from(20u16));
+    assert (20f32 == NumCast::from(20u32));
+    assert (20f32 == NumCast::from(20u64));
+    assert (20f32 == NumCast::from(20i));
+    assert (20f32 == NumCast::from(20i8));
+    assert (20f32 == NumCast::from(20i16));
+    assert (20f32 == NumCast::from(20i32));
+    assert (20f32 == NumCast::from(20i64));
+    assert (20f32 == NumCast::from(20f));
+    assert (20f32 == NumCast::from(20f32));
+    assert (20f32 == NumCast::from(20f64));
+
+    assert (20f32 == num::cast(20u));
+    assert (20f32 == num::cast(20u8));
+    assert (20f32 == num::cast(20u16));
+    assert (20f32 == num::cast(20u32));
+    assert (20f32 == num::cast(20u64));
+    assert (20f32 == num::cast(20i));
+    assert (20f32 == num::cast(20i8));
+    assert (20f32 == num::cast(20i16));
+    assert (20f32 == num::cast(20i32));
+    assert (20f32 == num::cast(20i64));
+    assert (20f32 == num::cast(20f));
+    assert (20f32 == num::cast(20f32));
+    assert (20f32 == num::cast(20f64));
+}
+
 //
 // Local Variables:
 // mode: rust