From 0b35e3b5a3468d5a8b5b86f0f6b369b8f663ce17 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Fri, 9 Aug 2013 23:31:57 +0200 Subject: [PATCH] extra::treemap: Use IteratorUtil::peekable Replace the previous equivalent iterator adaptor with .peekable(). Refactor the set operation iterators so that they are easier to read. --- src/libextra/treemap.rs | 134 ++++++++++++++-------------------------- 1 file changed, 46 insertions(+), 88 deletions(-) diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs index 424492a3cfe..f5a61692509 100644 --- a/src/libextra/treemap.rs +++ b/src/libextra/treemap.rs @@ -14,7 +14,8 @@ use std::util::{swap, replace}; -use std::iterator::{FromIterator, Extendable}; +use std::iterator::{FromIterator, Extendable, Peekable}; +use std::cmp::Ordering; // This is implemented as an AA tree, which is a simplified variation of // a red-black tree where red (horizontal) nodes can only be added @@ -529,24 +530,24 @@ impl TreeSet { /// Visit the values (in-order) representing the difference pub fn difference<'a>(&'a self, other: &'a TreeSet) -> Difference<'a, T> { - Difference{a: Focus::new(self.iter()), b: Focus::new(other.iter())} + Difference{a: self.iter().peekable(), b: other.iter().peekable()} } /// Visit the values (in-order) representing the symmetric difference pub fn symmetric_difference<'a>(&'a self, other: &'a TreeSet) -> SymDifference<'a, T> { - SymDifference{a: Focus::new(self.iter()), b: Focus::new(other.iter())} + SymDifference{a: self.iter().peekable(), b: other.iter().peekable()} } /// Visit the values (in-order) representing the intersection pub fn intersection<'a>(&'a self, other: &'a TreeSet) -> Intersection<'a, T> { - Intersection{a: Focus::new(self.iter()), b: Focus::new(other.iter())} + Intersection{a: self.iter().peekable(), b: other.iter().peekable()} } /// Visit the values (in-order) representing the union pub fn union<'a>(&'a self, other: &'a TreeSet) -> Union<'a, T> { - Union{a: Focus::new(self.iter()), b: Focus::new(other.iter())} + Union{a: self.iter().peekable(), b: other.iter().peekable()} } } @@ -560,61 +561,47 @@ pub struct TreeSetRevIterator<'self, T> { priv iter: TreeMapRevIterator<'self, T, ()> } -// Encapsulate an iterator and hold its latest value until stepped forward -struct Focus { - priv iter: T, - priv focus: Option, -} - -impl> Focus { - fn new(mut it: T) -> Focus { - Focus{focus: it.next(), iter: it} - } - fn step(&mut self) { - self.focus = self.iter.next() - } -} - /// Lazy iterator producing elements in the set difference (in-order) pub struct Difference<'self, T> { - priv a: Focus<&'self T, TreeSetIterator<'self, T>>, - priv b: Focus<&'self T, TreeSetIterator<'self, T>>, + priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, + priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set symmetric difference (in-order) pub struct SymDifference<'self, T> { - priv a: Focus<&'self T, TreeSetIterator<'self, T>>, - priv b: Focus<&'self T, TreeSetIterator<'self, T>>, + priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, + priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set intersection (in-order) pub struct Intersection<'self, T> { - priv a: Focus<&'self T, TreeSetIterator<'self, T>>, - priv b: Focus<&'self T, TreeSetIterator<'self, T>>, + priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, + priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set intersection (in-order) pub struct Union<'self, T> { - priv a: Focus<&'self T, TreeSetIterator<'self, T>>, - priv b: Focus<&'self T, TreeSetIterator<'self, T>>, + priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, + priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, +} + +/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None +fn cmp_opt(x: Option<&T>, y: Option<&T>, + short: Ordering, long: Ordering) -> Ordering { + match (x, y) { + (None , _ ) => short, + (_ , None ) => long, + (Some(x1), Some(y1)) => x1.cmp(y1), + } } impl<'self, T: TotalOrd> Iterator<&'self T> for Difference<'self, T> { fn next(&mut self) -> Option<&'self T> { loop { - match (self.a.focus, self.b.focus) { - (None , _ ) => return None, - (ret , None ) => { self.a.step(); return ret }, - (Some(a1), Some(b1)) => { - let cmp = a1.cmp(b1); - if cmp == Less { - self.a.step(); - return Some(a1); - } else { - if cmp == Equal { self.a.step() } - self.b.step(); - } - } + match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) { + Less => return self.a.next(), + Equal => { self.a.next(); self.b.next(); } + Greater => { self.b.next(); } } } } @@ -623,23 +610,10 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for Difference<'self, T> { impl<'self, T: TotalOrd> Iterator<&'self T> for SymDifference<'self, T> { fn next(&mut self) -> Option<&'self T> { loop { - match (self.a.focus, self.b.focus) { - (ret , None ) => { self.a.step(); return ret }, - (None , ret ) => { self.b.step(); return ret }, - (Some(a1), Some(b1)) => { - let cmp = a1.cmp(b1); - if cmp == Less { - self.a.step(); - return Some(a1); - } else { - self.b.step(); - if cmp == Greater { - return Some(b1); - } else { - self.a.step(); - } - } - } + match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) { + Less => return self.a.next(), + Equal => { self.a.next(); self.b.next(); } + Greater => return self.b.next(), } } } @@ -648,20 +622,16 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for SymDifference<'self, T> { impl<'self, T: TotalOrd> Iterator<&'self T> for Intersection<'self, T> { fn next(&mut self) -> Option<&'self T> { loop { - match (self.a.focus, self.b.focus) { - (None , _ ) => return None, - (_ , None ) => return None, - (Some(a1), Some(b1)) => { - let cmp = a1.cmp(b1); - if cmp == Less { - self.a.step(); - } else { - self.b.step(); - if cmp == Equal { - return Some(a1); - } - } - }, + let o_cmp = match (self.a.peek(), self.b.peek()) { + (None , _ ) => None, + (_ , None ) => None, + (Some(a1), Some(b1)) => Some(a1.cmp(b1)), + }; + match o_cmp { + None => return None, + Some(Less) => { self.a.next(); } + Some(Equal) => { self.b.next(); return self.a.next() } + Some(Greater) => { self.b.next(); } } } } @@ -670,22 +640,10 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for Intersection<'self, T> { impl<'self, T: TotalOrd> Iterator<&'self T> for Union<'self, T> { fn next(&mut self) -> Option<&'self T> { loop { - match (self.a.focus, self.b.focus) { - (ret , None) => { self.a.step(); return ret }, - (None , ret ) => { self.b.step(); return ret }, - (Some(a1), Some(b1)) => { - let cmp = a1.cmp(b1); - if cmp == Greater { - self.b.step(); - return Some(b1); - } else { - self.a.step(); - if cmp == Equal { - self.b.step(); - } - return Some(a1); - } - } + match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) { + Less => return self.a.next(), + Equal => { self.b.next(); return self.a.next() } + Greater => return self.b.next(), } } }