From 37e998696f840ffea047efc50814819422750c20 Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Wed, 6 Feb 2013 02:27:33 -0500 Subject: [PATCH] get rid of implicit vec copies in treemap iterator Each call to next() was doing a copy rather than a move. There's currently no way for this to be a method that uses &mut self, so it has to be a free function. Closes #4763. --- src/libstd/treemap.rs | 136 +++++++++++++++++++++--------------------- 1 file changed, 67 insertions(+), 69 deletions(-) diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 87801d76505..610f2f5a59c 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -49,8 +49,8 @@ impl TreeMap: Eq { let mut y = other.iter(); for self.len().times { unsafe { // unsafe as a purity workaround - x = x.next(); - y = y.next(); + map_next(&mut x); + map_next(&mut y); // FIXME: #4492 (ICE), x.get() == y.get() let (x1, x2) = x.get().unwrap(); let (y1, y2) = y.get().unwrap(); @@ -74,8 +74,8 @@ pure fn lt(a: &TreeMap, b: &TreeMap) -> bool { let (a_len, b_len) = (a.len(), b.len()); for uint::min(a_len, b_len).times { unsafe { // purity workaround - x = x.next(); - y = y.next(); + map_next(&mut x); + map_next(&mut y); let (key_a,_) = x.get().unwrap(); let (key_b,_) = y.get().unwrap(); if *key_a < *key_b { return true; } @@ -210,32 +210,30 @@ impl TreeMapIterator { // Returns the current node, or None if this iterator is at the end. fn get(&const self) -> Option<(&self/K, &self/V)> { match self.current { - Some(res) => Some((&res.key, &res.value)), - None => None + Some(res) => Some((&res.key, &res.value)), + None => None } } +} - /// Advance the iterator to the next node (in order). If this iterator - /// is finished, does nothing. - fn next(self) -> TreeMapIterator/&self { - let mut this = self; - while !this.stack.is_empty() || this.node.is_some() { - match *this.node { - Some(ref x) => { - this.stack.push(x); - this.node = &x.left; - } - None => { - let res = this.stack.pop(); - this.node = &res.right; - this.current = Some(res); - return this; - } - } +/// Advance the iterator to the next node (in order). If this iterator +/// is finished, does nothing. +fn map_next(iter: &mut TreeMapIterator/&a) { + while !iter.stack.is_empty() || iter.node.is_some() { + match *iter.node { + Some(ref x) => { + iter.stack.push(x); + iter.node = &x.left; + } + None => { + let res = iter.stack.pop(); + iter.node = &res.right; + iter.current = Some(res); + return; + } } - this.current = None; - return this; } + iter.current = None; } pub struct TreeSet { @@ -297,18 +295,18 @@ impl TreeSet: Set { let mut x = self.iter(); let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); while a.is_some() && b.is_some() { let a1 = a.unwrap(); let b1 = b.unwrap(); if a1 < b1 { - x = x.next(); + set_next(&mut x); a = x.get(); } else if b1 < a1 { - y = y.next(); + set_next(&mut y); b = y.get(); } else { return false; @@ -328,8 +326,8 @@ impl TreeSet: Set { let mut x = self.iter(); let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); while b.is_some() { @@ -345,10 +343,10 @@ impl TreeSet: Set { } if !(a1 < b1) { - y = y.next(); + set_next(&mut y); b = y.get(); } - x = x.next(); + set_next(&mut x); a = x.get(); } } @@ -361,15 +359,15 @@ impl TreeSet: Set { let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); while a.is_some() { if b.is_none() { return do a.while_some() |a1| { - if f(a1) { x = x.next(); x.get() } else { None } + if f(a1) { set_next(&mut x); x.get() } else { None } } } @@ -378,11 +376,11 @@ impl TreeSet: Set { if a1 < b1 { if !f(a1) { return } - x = x.next(); + set_next(&mut x); a = x.get(); } else { - if !(b1 < a1) { x = x.next(); a = x.get() } - y = y.next(); + if !(b1 < a1) { set_next(&mut x); a = x.get() } + set_next(&mut y); b = y.get(); } } @@ -396,15 +394,15 @@ impl TreeSet: Set { let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); while a.is_some() { if b.is_none() { return do a.while_some() |a1| { - if f(a1) { x.next(); x.get() } else { None } + if f(a1) { set_next(&mut x); x.get() } else { None } } } @@ -413,21 +411,21 @@ impl TreeSet: Set { if a1 < b1 { if !f(a1) { return } - x = x.next(); + set_next(&mut x); a = x.get(); } else { if b1 < a1 { if !f(b1) { return } } else { - x = x.next(); + set_next(&mut x); a = x.get(); } - y = y.next(); + set_next(&mut y); b = y.get(); } } do b.while_some |b1| { - if f(b1) { y = y.next(); y.get() } else { None } + if f(b1) { set_next(&mut y); y.get() } else { None } } } } @@ -438,8 +436,8 @@ impl TreeSet: Set { let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); @@ -447,13 +445,13 @@ impl TreeSet: Set { let a1 = a.unwrap(); let b1 = b.unwrap(); if a1 < b1 { - x = x.next(); + set_next(&mut x); a = x.get(); } else { if !(b1 < a1) { if !f(a1) { return } } - y = y.next(); + set_next(&mut y); b = y.get(); } } @@ -466,15 +464,15 @@ impl TreeSet: Set { let mut y = other.iter(); unsafe { // purity workaround - x = x.next(); - y = y.next(); + set_next(&mut x); + set_next(&mut y); let mut a = x.get(); let mut b = y.get(); while a.is_some() { if b.is_none() { return do a.while_some() |a1| { - if f(a1) { x = x.next(); x.get() } else { None } + if f(a1) { set_next(&mut x); x.get() } else { None } } } @@ -483,15 +481,15 @@ impl TreeSet: Set { if b1 < a1 { if !f(b1) { return } - y = y.next(); + set_next(&mut y); b = y.get(); } else { if !f(a1) { return } if !(a1 < b1) { - y = y.next(); + set_next(&mut y); b = y.get() } - x = x.next(); + set_next(&mut x); a = x.get(); } } @@ -524,16 +522,16 @@ impl TreeSetIterator { /// Returns the current node, or None if this iterator is at the end. fn get(&const self) -> Option<&self/T> { match self.iter.get() { - None => None, - Some((k, _)) => Some(k) + None => None, + Some((k, _)) => Some(k) } } +} - /// Advance the iterator to the next node (in order). If this iterator is - /// finished, does nothing. - fn next(self) -> TreeSetIterator/&self { - TreeSetIterator { iter: self.iter.next() } - } +/// Advance the iterator to the next node (in order). If this iterator is +/// finished, does nothing. +fn set_next(iter: &mut TreeSetIterator/&a) { + map_next(&mut iter.iter); } // Nodes keep track of their level in the tree, starting at 1 in the @@ -967,18 +965,18 @@ mod test_treemap { // FIXME: #4492 (ICE): iter.next() == Some((&x1, &y1)) - iter = iter.next(); + map_next(&mut iter); assert iter.get().unwrap() == (&x1, &y1); - iter = iter.next(); + map_next(&mut iter); assert iter.get().unwrap() == (&x2, &y2); - iter = iter.next(); + map_next(&mut iter); assert iter.get().unwrap() == (&x3, &y3); - iter = iter.next(); + map_next(&mut iter); assert iter.get().unwrap() == (&x4, &y4); - iter = iter.next(); + map_next(&mut iter); assert iter.get().unwrap() == (&x5, &y5); - iter = iter.next(); + map_next(&mut iter); assert iter.get().is_none(); } }