about summary refs log tree commit diff
path: root/src/libstd/treemap.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/treemap.rs')
-rw-r--r--src/libstd/treemap.rs208
1 files changed, 0 insertions, 208 deletions
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index e4026d7306f..93f8d06ee08 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -105,45 +105,21 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
     }
 
     /// Visit all key-value pairs in order
-    #[cfg(stage0)]
-    fn each<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) {
-        each(&self.root, f);
-    }
-    /// Visit all key-value pairs in order
-    #[cfg(not(stage0))]
     fn each<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) -> bool {
         each(&self.root, f)
     }
 
     /// Visit all keys in order
-    #[cfg(stage0)]
-    fn each_key(&self, f: &fn(&K) -> bool) {
-        self.each(|k, _| f(k))
-    }
-    /// Visit all keys in order
-    #[cfg(not(stage0))]
     fn each_key(&self, f: &fn(&K) -> bool) -> bool {
         self.each(|k, _| f(k))
     }
 
     /// Visit all values in order
-    #[cfg(stage0)]
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) {
-        self.each(|_, v| f(v))
-    }
-    /// Visit all values in order
-    #[cfg(not(stage0))]
     fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool {
         self.each(|_, v| f(v))
     }
 
     /// Iterate over the map and mutate the contained values
-    #[cfg(stage0)]
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) {
-        mutate_values(&mut self.root, f);
-    }
-    /// Iterate over the map and mutate the contained values
-    #[cfg(not(stage0))]
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool {
         mutate_values(&mut self.root, f)
     }
@@ -201,33 +177,6 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
     }
 }
 
-#[cfg(stage0)]
-pub impl<K: TotalOrd, V> TreeMap<K, V> {
-    /// Create an empty TreeMap
-    fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
-
-    /// Visit all key-value pairs in reverse order
-    fn each_reverse<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) {
-        each_reverse(&self.root, f);
-    }
-
-    /// Visit all keys in reverse order
-    fn each_key_reverse(&self, f: &fn(&K) -> bool) {
-        self.each_reverse(|k, _| f(k))
-    }
-
-    /// Visit all values in reverse order
-    fn each_value_reverse(&self, f: &fn(&V) -> bool) {
-        self.each_reverse(|_, v| f(v))
-    }
-
-    /// Get a lazy iterator over the key-value pairs in the map.
-    /// Requires that it be frozen (immutable).
-    fn iter<'a>(&'a self) -> TreeMapIterator<'a, K, V> {
-        TreeMapIterator{stack: ~[], node: &self.root}
-    }
-}
-#[cfg(not(stage0))]
 pub impl<K: TotalOrd, V> TreeMap<K, V> {
     /// Create an empty TreeMap
     fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
@@ -297,11 +246,6 @@ pub struct TreeSet<T> {
 impl<T: TotalOrd> BaseIter<T> for TreeSet<T> {
     /// Visit all values in order
     #[inline(always)]
-    #[cfg(stage0)]
-    fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
-    /// Visit all values in order
-    #[inline(always)]
-    #[cfg(not(stage0))]
     fn each(&self, f: &fn(&T) -> bool) -> bool { self.map.each_key(f) }
     #[inline(always)]
     fn size_hint(&self) -> Option<uint> { Some(self.len()) }
@@ -309,13 +253,6 @@ impl<T: TotalOrd> BaseIter<T> for TreeSet<T> {
 
 impl<T: TotalOrd> ReverseIter<T> for TreeSet<T> {
     /// Visit all values in reverse order
-    #[cfg(stage0)]
-    #[inline(always)]
-    fn each_reverse(&self, f: &fn(&T) -> bool) {
-        self.map.each_key_reverse(f)
-    }
-    /// Visit all values in reverse order
-    #[cfg(not(stage0))]
     #[inline(always)]
     fn each_reverse(&self, f: &fn(&T) -> bool) -> bool {
         self.map.each_key_reverse(f)
@@ -424,37 +361,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 
     /// Visit the values (in-order) representing the difference
-    #[cfg(stage0)]
-    fn difference(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) {
-        let mut x = self.iter();
-        let mut y = other.iter();
-
-        let mut a = x.next();
-        let mut b = y.next();
-
-        while a.is_some() {
-            if b.is_none() {
-                return do a.while_some() |a1| {
-                    if f(a1) { x.next() } else { None }
-                }
-            }
-
-            let a1 = a.unwrap();
-            let b1 = b.unwrap();
-
-            let cmp = a1.cmp(b1);
-
-            if cmp == Less {
-                if !f(a1) { return }
-                a = x.next();
-            } else {
-                if cmp == Equal { a = x.next() }
-                b = y.next();
-            }
-        }
-    }
-    /// Visit the values (in-order) representing the difference
-    #[cfg(not(stage0))]
     fn difference(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) -> bool {
         let mut x = self.iter();
         let mut y = other.iter();
@@ -484,45 +390,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 
     /// Visit the values (in-order) representing the symmetric difference
-    #[cfg(stage0)]
-    fn symmetric_difference(&self, other: &TreeSet<T>,
-                                 f: &fn(&T) -> bool) {
-        let mut x = self.iter();
-        let mut y = other.iter();
-
-        let mut a = x.next();
-        let mut b = y.next();
-
-        while a.is_some() {
-            if b.is_none() {
-                return do a.while_some() |a1| {
-                    if f(a1) { x.next() } else { None }
-                }
-            }
-
-            let a1 = a.unwrap();
-            let b1 = b.unwrap();
-
-            let cmp = a1.cmp(b1);
-
-            if cmp == Less {
-                if !f(a1) { return }
-                a = x.next();
-            } else {
-                if cmp == Greater {
-                    if !f(b1) { return }
-                } else {
-                    a = x.next();
-                }
-                b = y.next();
-            }
-        }
-        do b.while_some |b1| {
-            if f(b1) { y.next() } else { None }
-        }
-    }
-    /// Visit the values (in-order) representing the symmetric difference
-    #[cfg(not(stage0))]
     fn symmetric_difference(&self, other: &TreeSet<T>,
                             f: &fn(&T) -> bool) -> bool {
         let mut x = self.iter();
@@ -557,32 +424,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 
     /// Visit the values (in-order) representing the intersection
-    #[cfg(stage0)]
-    fn intersection(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) {
-        let mut x = self.iter();
-        let mut y = other.iter();
-
-        let mut a = x.next();
-        let mut b = y.next();
-
-        while a.is_some() && b.is_some() {
-            let a1 = a.unwrap();
-            let b1 = b.unwrap();
-
-            let cmp = a1.cmp(b1);
-
-            if cmp == Less {
-                a = x.next();
-            } else {
-                if cmp == Equal {
-                    if !f(a1) { return }
-                }
-                b = y.next();
-            }
-        }
-    }
-    /// Visit the values (in-order) representing the intersection
-    #[cfg(not(stage0))]
     fn intersection(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) -> bool {
         let mut x = self.iter();
         let mut y = other.iter();
@@ -609,43 +450,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 
     /// Visit the values (in-order) representing the union
-    #[cfg(stage0)]
-    fn union(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) {
-        let mut x = self.iter();
-        let mut y = other.iter();
-
-        let mut a = x.next();
-        let mut b = y.next();
-
-        while a.is_some() {
-            if b.is_none() {
-                return do a.while_some() |a1| {
-                    if f(a1) { x.next() } else { None }
-                }
-            }
-
-            let a1 = a.unwrap();
-            let b1 = b.unwrap();
-
-            let cmp = a1.cmp(b1);
-
-            if cmp == Greater {
-                if !f(b1) { return }
-                b = y.next();
-            } else {
-                if !f(a1) { return }
-                if cmp == Equal {
-                    b = y.next();
-                }
-                a = x.next();
-            }
-        }
-        do b.while_some |b1| {
-            if f(b1) { y.next() } else { None }
-        }
-    }
-    /// Visit the values (in-order) representing the union
-    #[cfg(not(stage0))]
     fn union(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) -> bool {
         let mut x = self.iter();
         let mut y = other.iter();
@@ -713,24 +517,12 @@ pub impl<K: TotalOrd, V> TreeNode<K, V> {
     }
 }
 
-#[cfg(stage0)]
-fn each<'r, K: TotalOrd, V>(_: &'r Option<~TreeNode<K, V>>,
-                            _: &fn(&'r K, &'r V) -> bool) -> bool {
-    fail!("don't use me in stage0!")
-}
-#[cfg(not(stage0))]
 fn each<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
                             f: &fn(&'r K, &'r V) -> bool) -> bool {
     node.each(|x| each(&x.left, f) && f(&x.key, &x.value) &&
                   each(&x.right, f))
 }
 
-#[cfg(stage0)]
-fn each_reverse<'r, K: TotalOrd, V>(_: &'r Option<~TreeNode<K, V>>,
-                                    _: &fn(&'r K, &'r V) -> bool) -> bool {
-    fail!("don't use me in stage0!")
-}
-#[cfg(not(stage0))]
 fn each_reverse<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
                                     f: &fn(&'r K, &'r V) -> bool) -> bool {
     node.each(|x| each_reverse(&x.right, f) && f(&x.key, &x.value) &&
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-28 14:25:01 +0000