---

yaml
---
r: 64776
b: refs/heads/snap-stage3
c: d6bc438
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5157e05049d76f1206c9f879961194d4ac26ce58
+refs/heads/snap-stage3: d6bc438bbcb9240d0303ffec81bf1a617f0903a5
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/bitv.rs

@@ -703,8 +703,8 @@ impl cmp::Eq for BitvSet {
 }
 
 impl Container for BitvSet {
-    #[inline]
     fn len(&self) -> uint { self.size }
+    fn is_empty(&self) -> bool { self.size == 0 }
 }
 
 impl Mutable for BitvSet {

branches/snap-stage3/src/libextra/priority_queue.rs

@@ -27,6 +27,9 @@ pub struct PriorityQueue<T> {
 impl<T:Ord> Container for PriorityQueue<T> {
     /// Returns the length of the queue
     fn len(&self) -> uint { self.data.len() }
+
+    /// Returns true if a queue contains no elements
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<T:Ord> Mutable for PriorityQueue<T> {

branches/snap-stage3/src/libextra/ringbuf.rs

@@ -34,6 +34,9 @@ pub struct RingBuf<T> {
 impl<T> Container for RingBuf<T> {
     /// Return the number of elements in the RingBuf
     fn len(&self) -> uint { self.nelts }
+
+    /// Return true if the RingBufcontains no elements
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<T> Mutable for RingBuf<T> {

branches/snap-stage3/src/libextra/smallintmap.rs

@@ -37,6 +37,9 @@ impl<V> Container for SmallIntMap<V> {
         }
         sz
     }
+
+    /// Return true if the map contains no elements
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<V> Mutable for SmallIntMap<V> {

branches/snap-stage3/src/libextra/treemap.rs

@@ -135,6 +135,19 @@ impl<K: TotalOrd, V> MutableMap<K, V> for TreeMap<K, V> {
         find_mut(&mut self.root, key)
     }
 
+    /// Insert a key-value pair into the map. An existing value for a
+    /// key is replaced by the new value. Return true if the key did
+    /// not already exist in the map.
+    fn insert(&mut self, key: K, value: V) -> bool {
+        self.swap(key, value).is_none()
+    }
+
+    /// Remove a key-value pair from the map. Return true if the key
+    /// was present in the map, otherwise false.
+    fn remove(&mut self, key: &K) -> bool {
+        self.pop(key).is_some()
+    }
+
     /// Insert a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise None is returned.
     fn swap(&mut self, key: K, value: V) -> Option<V> {

branches/snap-stage3/src/libstd/container.rs

@@ -19,10 +19,7 @@ pub trait Container {
     fn len(&self) -> uint;
 
     /// Return true if the container contains no elements
-    #[inline]
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
+    fn is_empty(&self) -> bool;
 }
 
 /// A trait to represent mutable containers
@@ -46,17 +43,11 @@ pub trait MutableMap<K, V>: Map<K, V> + Mutable {
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
-    #[inline]
-    fn insert(&mut self, key: K, value: V) -> bool {
-        self.swap(key, value).is_none()
-    }
+    fn insert(&mut self, key: K, value: V) -> bool;
 
     /// Remove a key-value pair from the map. Return true if the key
     /// was present in the map, otherwise false.
-    #[inline]
-    fn remove(&mut self, key: &K) -> bool {
-        self.pop(key).is_some()
-    }
+    fn remove(&mut self, key: &K) -> bool;
 
     /// Insert a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise None is returned.

branches/snap-stage3/src/libstd/hashmap.rs

@@ -282,6 +282,9 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
 impl<K:Hash + Eq,V> Container for HashMap<K, V> {
     /// Return the number of elements in the map
     fn len(&self) -> uint { self.size }
+
+    /// Return true if the map contains no elements
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<K:Hash + Eq,V> Mutable for HashMap<K, V> {
@@ -322,6 +325,19 @@ impl<K:Hash + Eq,V> MutableMap<K, V> for HashMap<K, V> {
         Some(self.mut_value_for_bucket(idx))
     }
 
+    /// Insert a key-value pair into the map. An existing value for a
+    /// key is replaced by the new value. Return true if the key did
+    /// not already exist in the map.
+    fn insert(&mut self, k: K, v: V) -> bool {
+        self.swap(k, v).is_none()
+    }
+
+    /// Remove a key-value pair from the map. Return true if the key
+    /// was present in the map, otherwise false.
+    fn remove(&mut self, k: &K) -> bool {
+        self.pop(k).is_some()
+    }
+
     /// Insert a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise None is returned.
     fn swap(&mut self, k: K, v: V) -> Option<V> {
@@ -645,6 +661,9 @@ impl<T:Hash + Eq> Eq for HashSet<T> {
 impl<T:Hash + Eq> Container for HashSet<T> {
     /// Return the number of elements in the set
     fn len(&self) -> uint { self.map.len() }
+
+    /// Return true if the set contains no elements
+    fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl<T:Hash + Eq> Mutable for HashSet<T> {

branches/snap-stage3/src/libstd/iterator.rs

@@ -29,7 +29,7 @@ use uint;
 /// Conversion from an `Iterator`
 pub trait FromIterator<A, T: Iterator<A>> {
     /// Build a container with elements from an external iterator.
-    pub fn from_iterator(iterator: &mut T) -> Self;
+    fn from_iterator(iterator: &mut T) -> Self;
 }
 
 /// An interface for dealing with "external iterators". These types of iterators
@@ -52,7 +52,9 @@ pub trait DoubleEndedIterator<A>: Iterator<A> {
 }
 
 /// An object implementing random access indexing by `uint`
-pub trait RandomAccessIterator<A> {
+///
+/// A `RandomAccessIterator` should be either infinite or a `DoubleEndedIterator`.
+pub trait RandomAccessIterator<A>: Iterator<A> {
     /// Return the number of indexable elements. At most `std::uint::max_value`
     /// elements are indexable, even if the iterator represents a longer range.
     fn indexable(&self) -> uint;

branches/snap-stage3/src/libstd/str.rs

@@ -1099,16 +1099,24 @@ impl<'self> Container for &'self str {
     fn len(&self) -> uint {
         do self.as_imm_buf |_p, n| { n - 1u }
     }
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }
 
 impl Container for ~str {
     #[inline]
     fn len(&self) -> uint { self.as_slice().len() }
+    #[inline]
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl Container for @str {
     #[inline]
     fn len(&self) -> uint { self.as_slice().len() }
+    #[inline]
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl Mutable for ~str {

branches/snap-stage3/src/libstd/trie.rs

@@ -36,6 +36,10 @@ impl<T> Container for TrieMap<T> {
     /// Return the number of elements in the map
     #[inline]
     fn len(&self) -> uint { self.length }
+
+    /// Return true if the map contains no elements
+    #[inline]
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<T> Mutable for TrieMap<T> {
@@ -83,6 +87,21 @@ impl<T> MutableMap<uint, T> for TrieMap<T> {
         find_mut(&mut self.root.children[chunk(*key, 0)], *key, 1)
     }
 
+    /// Insert a key-value pair into the map. An existing value for a
+    /// key is replaced by the new value. Return true if the key did
+    /// not already exist in the map.
+    #[inline]
+    fn insert(&mut self, key: uint, value: T) -> bool {
+        self.swap(key, value).is_none()
+    }
+
+    /// Remove a key-value pair from the map. Return true if the key
+    /// was present in the map, otherwise false.
+    #[inline]
+    fn remove(&mut self, key: &uint) -> bool {
+        self.pop(key).is_some()
+    }
+
     /// Insert a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise None is returned.
     fn swap(&mut self, key: uint, value: T) -> Option<T> {
@@ -175,6 +194,10 @@ impl Container for TrieSet {
     /// Return the number of elements in the set
     #[inline]
     fn len(&self) -> uint { self.map.len() }
+
+    /// Return true if the set contains no elements
+    #[inline]
+    fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl Mutable for TrieSet {