1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! An ordered map and set implemented as self-balancing binary search
12 //! trees. The only requirement for the types is that the key implements
18 //! use std::collections::TreeSet;
20 //! let mut tree_set = TreeSet::new();
22 //! tree_set.insert(2i);
23 //! tree_set.insert(1i);
24 //! tree_set.insert(3i);
26 //! for i in tree_set.iter() {
27 //! println!("{}", i) // prints 1, then 2, then 3
33 use alloc::boxed::Box;
34 use core::default::Default;
37 use core::iter::Peekable;
39 use core::mem::{replace, swap};
41 use std::hash::{Writer, Hash};
43 use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
46 // This is implemented as an AA tree, which is a simplified variation of
47 // a red-black tree where red (horizontal) nodes can only be added
48 // as a right child. The time complexity is the same, and re-balancing
49 // operations are more frequent but also cheaper.
51 // Future improvements:
53 // range search - O(log n) retrieval of an iterator from some key
55 // (possibly) implement the overloads Python does for sets:
58 // * symmetric difference: ^
60 // These would be convenient since the methods work like `each`
64 pub struct TreeMap<K, V> {
65 root: Option<Box<TreeNode<K, V>>>,
69 impl<K: PartialEq + Ord, V: PartialEq> PartialEq for TreeMap<K, V> {
70 fn eq(&self, other: &TreeMap<K, V>) -> bool {
71 self.len() == other.len() &&
72 self.iter().zip(other.iter()).all(|(a, b)| a == b)
76 impl<K: Ord, V: PartialOrd> PartialOrd for TreeMap<K, V> {
78 fn partial_cmp(&self, other: &TreeMap<K, V>) -> Option<Ordering> {
79 iter::order::partial_cmp(self.iter(), other.iter())
83 impl<K: Ord + Show, V: Show> Show for TreeMap<K, V> {
84 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
85 try!(write!(f, "{{"));
87 for (i, (k, v)) in self.iter().enumerate() {
88 if i != 0 { try!(write!(f, ", ")); }
89 try!(write!(f, "{}: {}", *k, *v));
96 impl<K: Ord, V> Collection for TreeMap<K, V> {
97 fn len(&self) -> uint { self.length }
100 impl<K: Ord, V> Mutable for TreeMap<K, V> {
101 fn clear(&mut self) {
107 impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
108 // See comments on tree_find_with
110 fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
111 tree_find_with(&self.root, |k2| key.cmp(k2))
115 impl<K: Ord, V> MutableMap<K, V> for TreeMap<K, V> {
116 // See comments on def_tree_find_mut_with
118 fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
119 tree_find_mut_with(&mut self.root, |x| key.cmp(x))
122 fn swap(&mut self, key: K, value: V) -> Option<V> {
123 let ret = insert(&mut self.root, key, value);
124 if ret.is_none() { self.length += 1 }
128 fn pop(&mut self, key: &K) -> Option<V> {
129 let ret = remove(&mut self.root, key);
130 if ret.is_some() { self.length -= 1 }
135 impl<K: Ord, V> Default for TreeMap<K,V> {
137 fn default() -> TreeMap<K, V> { TreeMap::new() }
140 impl<K: Ord, V> TreeMap<K, V> {
141 /// Create an empty `TreeMap`.
142 pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
144 /// Get a lazy iterator over the keys in the map.
145 pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
146 self.iter().map(|(k, _v)| k)
149 /// Get a lazy iterator over the values in the map.
150 pub fn values<'a>(&'a self) -> Values<'a, K, V> {
151 self.iter().map(|(_k, v)| v)
154 /// Get a lazy iterator over the key-value pairs in the map.
155 /// Requires that it be frozen (immutable).
156 pub fn iter<'a>(&'a self) -> Entries<'a, K, V> {
159 node: deref(&self.root),
160 remaining_min: self.length,
161 remaining_max: self.length
165 /// Get a lazy reverse iterator over the key-value pairs in the map.
166 /// Requires that it be frozen (immutable).
167 pub fn rev_iter<'a>(&'a self) -> RevEntries<'a, K, V> {
168 RevEntries{iter: self.iter()}
171 /// Get a lazy forward iterator over the key-value pairs in the
172 /// map, with the values being mutable.
173 pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> {
176 node: mut_deref(&mut self.root),
177 remaining_min: self.length,
178 remaining_max: self.length
181 /// Get a lazy reverse iterator over the key-value pairs in the
182 /// map, with the values being mutable.
183 pub fn mut_rev_iter<'a>(&'a mut self) -> RevMutEntries<'a, K, V> {
184 RevMutEntries{iter: self.mut_iter()}
188 /// Get a lazy iterator that consumes the treemap.
189 pub fn move_iter(self) -> MoveEntries<K, V> {
190 let TreeMap { root: root, length: length } = self;
191 let stk = match root {
193 Some(box tn) => vec!(tn)
202 impl<K, V> TreeMap<K, V> {
203 /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
204 /// with current key and guides tree navigation. That means `f` should
205 /// be aware of natural ordering of the tree.
210 /// use collections::treemap::TreeMap;
212 /// fn get_headers() -> TreeMap<String, String> {
213 /// let mut result = TreeMap::new();
214 /// result.insert("Content-Type".to_string(), "application/xml".to_string());
215 /// result.insert("User-Agent".to_string(), "Curl-Rust/0.1".to_string());
219 /// let headers = get_headers();
220 /// let ua_key = "User-Agent";
221 /// let ua = headers.find_with(|k| {
222 /// ua_key.cmp(&k.as_slice())
225 /// assert_eq!((*ua.unwrap()).as_slice(), "Curl-Rust/0.1");
228 pub fn find_with<'a>(&'a self, f:|&K| -> Ordering) -> Option<&'a V> {
229 tree_find_with(&self.root, f)
232 /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
233 /// with current key and guides tree navigation. That means `f` should
234 /// be aware of natural ordering of the tree.
239 /// let mut t = collections::treemap::TreeMap::new();
240 /// t.insert("Content-Type", "application/xml");
241 /// t.insert("User-Agent", "Curl-Rust/0.1");
243 /// let new_ua = "Safari/156.0";
244 /// match t.find_mut_with(|k| "User-Agent".cmp(k)) {
245 /// Some(x) => *x = new_ua,
249 /// assert_eq!(t.find(&"User-Agent"), Some(&new_ua));
252 pub fn find_mut_with<'a>(&'a mut self, f:|&K| -> Ordering) -> Option<&'a mut V> {
253 tree_find_mut_with(&mut self.root, f)
259 macro_rules! bound_setup {
260 // initialiser of the iterator to manipulate
261 ($iter:expr, $k:expr,
262 // whether we are looking for the lower or upper bound.
263 $is_lower_bound:expr) => {
265 let mut iter = $iter;
267 if !iter.node.is_null() {
268 let node_k = unsafe {&(*iter.node).key};
269 match $k.cmp(node_k) {
270 Less => iter.traverse_left(),
271 Greater => iter.traverse_right(),
274 iter.traverse_complete();
277 iter.traverse_right()
282 iter.traverse_complete();
291 impl<K: Ord, V> TreeMap<K, V> {
292 /// Get a lazy iterator that should be initialized using
293 /// `traverse_left`/`traverse_right`/`traverse_complete`.
294 fn iter_for_traversal<'a>(&'a self) -> Entries<'a, K, V> {
297 node: deref(&self.root),
299 remaining_max: self.length
303 /// Return a lazy iterator to the first key-value pair whose key is not less than `k`
304 /// If all keys in map are less than `k` an empty iterator is returned.
305 pub fn lower_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
306 bound_setup!(self.iter_for_traversal(), k, true)
309 /// Return a lazy iterator to the first key-value pair whose key is greater than `k`
310 /// If all keys in map are not greater than `k` an empty iterator is returned.
311 pub fn upper_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
312 bound_setup!(self.iter_for_traversal(), k, false)
315 /// Get a lazy iterator that should be initialized using
316 /// `traverse_left`/`traverse_right`/`traverse_complete`.
317 fn mut_iter_for_traversal<'a>(&'a mut self) -> MutEntries<'a, K, V> {
320 node: mut_deref(&mut self.root),
322 remaining_max: self.length
326 /// Return a lazy value iterator to the first key-value pair (with
327 /// the value being mutable) whose key is not less than `k`.
329 /// If all keys in map are less than `k` an empty iterator is
331 pub fn mut_lower_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
332 bound_setup!(self.mut_iter_for_traversal(), k, true)
335 /// Return a lazy iterator to the first key-value pair (with the
336 /// value being mutable) whose key is greater than `k`.
338 /// If all keys in map are not greater than `k` an empty iterator
340 pub fn mut_upper_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
341 bound_setup!(self.mut_iter_for_traversal(), k, false)
345 /// Lazy forward iterator over a map
346 pub struct Entries<'a, K, V> {
347 stack: Vec<&'a TreeNode<K, V>>,
348 // See the comment on MutEntries; this is just to allow
349 // code-sharing (for this immutable-values iterator it *could* very
350 // well be Option<&'a TreeNode<K,V>>).
351 node: *const TreeNode<K, V>,
356 /// Lazy backward iterator over a map
357 pub struct RevEntries<'a, K, V> {
358 iter: Entries<'a, K, V>,
361 /// Lazy forward iterator over a map that allows for the mutation of
363 pub struct MutEntries<'a, K, V> {
364 stack: Vec<&'a mut TreeNode<K, V>>,
365 // Unfortunately, we require some unsafe-ness to get around the
366 // fact that we would be storing a reference *into* one of the
367 // nodes in the stack.
369 // As far as the compiler knows, this would let us invalidate the
370 // reference by assigning a new value to this node's position in
371 // its parent, which would cause this current one to be
372 // deallocated so this reference would be invalid. (i.e. the
373 // compilers complaints are 100% correct.)
375 // However, as far as you humans reading this code know (or are
376 // about to know, if you haven't read far enough down yet), we are
377 // only reading from the TreeNode.{left,right} fields. the only
378 // thing that is ever mutated is the .value field (although any
379 // actual mutation that happens is done externally, by the
380 // iterator consumer). So, don't be so concerned, rustc, we've got
383 // (This field can legitimately be null.)
384 node: *mut TreeNode<K, V>,
389 /// Lazy backward iterator over a map
390 pub struct RevMutEntries<'a, K, V> {
391 iter: MutEntries<'a, K, V>,
395 /// TreeMap keys iterator
396 pub type Keys<'a, K, V> =
397 iter::Map<'static, (&'a K, &'a V), &'a K, Entries<'a, K, V>>;
399 /// TreeMap values iterator
400 pub type Values<'a, K, V> =
401 iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
404 // FIXME #5846 we want to be able to choose between &x and &mut x
405 // (with many different `x`) below, so we need to optionally pass mut
406 // as a tt, but the only thing we can do with a `tt` is pass them to
407 // other macros, so this takes the `& <mutability> <operand>` token
408 // sequence and forces their evaluation as an expression.
409 macro_rules! addr { ($e:expr) => { $e }}
410 // putting an optional mut into type signatures
411 macro_rules! item { ($i:item) => { $i }}
413 macro_rules! define_iterator {
417 // the function to go from &m Option<Box<TreeNode>> to *m TreeNode
418 deref = $deref:ident,
420 // see comment on `addr!`, this is just an optional `mut`, but
421 // there's no support for 0-or-1 repeats.
422 addr_mut = $($addr_mut:tt)*
424 // private methods on the forward iterator (item!() for the
425 // addr_mut in the next_ return value)
426 item!(impl<'a, K, V> $name<'a, K, V> {
428 fn next_(&mut self, forward: bool) -> Option<(&'a K, &'a $($addr_mut)* V)> {
429 while !self.stack.is_empty() || !self.node.is_null() {
430 if !self.node.is_null() {
431 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
433 let next_node = if forward {
434 addr!(& $($addr_mut)* node.left)
436 addr!(& $($addr_mut)* node.right)
438 self.node = $deref(next_node);
440 self.stack.push(node);
442 let node = self.stack.pop().unwrap();
443 let next_node = if forward {
444 addr!(& $($addr_mut)* node.right)
446 addr!(& $($addr_mut)* node.left)
448 self.node = $deref(next_node);
449 self.remaining_max -= 1;
450 if self.remaining_min > 0 {
451 self.remaining_min -= 1;
453 return Some((&node.key, addr!(& $($addr_mut)* node.value)));
459 /// traverse_left, traverse_right and traverse_complete are
460 /// used to initialize Entries/MutEntries
461 /// pointing to element inside tree structure.
463 /// They should be used in following manner:
464 /// - create iterator using TreeMap::[mut_]iter_for_traversal
465 /// - find required node using `traverse_left`/`traverse_right`
466 /// (current node is `Entries::node` field)
467 /// - complete initialization with `traverse_complete`
469 /// After this, iteration will start from `self.node`. If
470 /// `self.node` is None iteration will start from last
471 /// node from which we traversed left.
473 fn traverse_left(&mut self) {
474 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
475 self.node = $deref(addr!(& $($addr_mut)* node.left));
476 self.stack.push(node);
480 fn traverse_right(&mut self) {
481 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
482 self.node = $deref(addr!(& $($addr_mut)* node.right));
486 fn traverse_complete(&mut self) {
487 if !self.node.is_null() {
489 self.stack.push(addr!(& $($addr_mut)* *self.node));
491 self.node = ptr::RawPtr::null();
496 // the forward Iterator impl.
497 item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $name<'a, K, V> {
498 /// Advance the iterator to the next node (in order) and return a
499 /// tuple with a reference to the key and value. If there are no
500 /// more nodes, return `None`.
501 fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
506 fn size_hint(&self) -> (uint, Option<uint>) {
507 (self.remaining_min, Some(self.remaining_max))
511 // the reverse Iterator impl.
512 item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $rev_name<'a, K, V> {
513 fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
514 self.iter.next_(false)
518 fn size_hint(&self) -> (uint, Option<uint>) {
519 self.iter.size_hint()
523 } // end of define_iterator
530 // immutable, so no mut
541 fn deref<'a, K, V>(node: &'a Option<Box<TreeNode<K, V>>>) -> *const TreeNode<K, V> {
544 let n: &TreeNode<K, V> = &**n;
545 n as *const TreeNode<K, V>
551 fn mut_deref<K, V>(x: &mut Option<Box<TreeNode<K, V>>>)
552 -> *mut TreeNode<K, V> {
555 let n: &mut TreeNode<K, V> = &mut **n;
556 n as *mut TreeNode<K, V>
558 None => ptr::mut_null()
564 /// Lazy forward iterator over a map that consumes the map while iterating
565 pub struct MoveEntries<K, V> {
566 stack: Vec<TreeNode<K, V>>,
570 impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
572 fn next(&mut self) -> Option<(K, V)> {
573 while !self.stack.is_empty() {
580 } = self.stack.pop().unwrap();
592 self.stack.push(left);
596 Some(box right) => self.stack.push(right),
600 return Some((key, value))
608 fn size_hint(&self) -> (uint, Option<uint>) {
609 (self.remaining, Some(self.remaining))
614 impl<'a, T> Iterator<&'a T> for SetItems<'a, T> {
616 fn next(&mut self) -> Option<&'a T> {
617 self.iter.next().map(|(value, _)| value)
621 impl<'a, T> Iterator<&'a T> for RevSetItems<'a, T> {
623 fn next(&mut self) -> Option<&'a T> {
624 self.iter.next().map(|(value, _)| value)
628 /// A implementation of the `Set` trait on top of the `TreeMap` container. The
629 /// only requirement is that the type of the elements contained ascribes to the
635 /// use std::collections::TreeSet;
637 /// let mut set = TreeSet::new();
643 /// for i in set.iter() {
644 /// println!("{}", i) // prints 1, then 2, then 3
649 /// if !set.contains(&3) {
650 /// println!("set does not contain a 3 anymore");
654 /// The easiest way to use `TreeSet` with a custom type is to implement `Ord`.
655 /// We must also implement `PartialEq`, `Eq` and `PartialOrd`.
658 /// use std::collections::TreeSet;
660 /// // We need `Eq` and `PartialEq`, these can be derived.
661 /// #[deriving(Eq, PartialEq)]
662 /// struct Troll<'a> {
667 /// // Implement `Ord` and sort trolls by level.
668 /// impl<'a> Ord for Troll<'a> {
669 /// fn cmp(&self, other: &Troll) -> Ordering {
670 /// // If we swap `self` and `other`, we get descended ordering.
671 /// self.level.cmp(&other.level)
675 /// // `PartialOrd` needs to be implemented as well.
676 /// impl<'a> PartialOrd for Troll<'a> {
677 /// fn partial_cmp(&self, other: &Troll) -> Option<Ordering> {
678 /// Some(self.cmp(other))
682 /// let mut trolls = TreeSet::new();
684 /// trolls.insert(Troll { name: "Orgarr", level: 2 });
685 /// trolls.insert(Troll { name: "Blargarr", level: 3 });
686 /// trolls.insert(Troll { name: "Kron the Smelly One", level: 4 });
687 /// trolls.insert(Troll { name: "Wartilda", level: 1 });
689 /// println!("You are facing {} trolls!", trolls.len());
691 /// // Print the trolls, ordered by level with smallest level first
692 /// for x in trolls.iter() {
693 /// println!("level {}: {}!", x.level, x.name);
696 /// // Kill all trolls
698 /// assert_eq!(trolls.len(), 0);
701 pub struct TreeSet<T> {
705 impl<T: PartialEq + Ord> PartialEq for TreeSet<T> {
707 fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
710 impl<T: Ord> PartialOrd for TreeSet<T> {
712 fn partial_cmp(&self, other: &TreeSet<T>) -> Option<Ordering> {
713 self.map.partial_cmp(&other.map)
717 impl<T: Ord + Show> Show for TreeSet<T> {
718 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
719 try!(write!(f, "{{"));
721 for (i, x) in self.iter().enumerate() {
722 if i != 0 { try!(write!(f, ", ")); }
723 try!(write!(f, "{}", *x));
730 impl<T: Ord> Collection for TreeSet<T> {
732 fn len(&self) -> uint { self.map.len() }
735 impl<T: Ord> Mutable for TreeSet<T> {
737 fn clear(&mut self) { self.map.clear() }
740 impl<T: Ord> Set<T> for TreeSet<T> {
742 fn contains(&self, value: &T) -> bool {
743 self.map.contains_key(value)
746 fn is_disjoint(&self, other: &TreeSet<T>) -> bool {
747 self.intersection(other).next().is_none()
750 fn is_subset(&self, other: &TreeSet<T>) -> bool {
751 let mut x = self.iter();
752 let mut y = other.iter();
753 let mut a = x.next();
754 let mut b = y.next();
765 Greater => return false,
766 Equal => a = x.next(),
775 impl<T: Ord> MutableSet<T> for TreeSet<T> {
777 fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
780 fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
783 impl<T: Ord> Default for TreeSet<T> {
785 fn default() -> TreeSet<T> { TreeSet::new() }
788 impl<T: Ord> TreeSet<T> {
789 /// Create an empty `TreeSet`.
794 /// use std::collections::TreeSet;
795 /// let mut set: TreeSet<int> = TreeSet::new();
798 pub fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
800 /// Get a lazy iterator over the values in the set, in ascending order.
805 /// use std::collections::TreeSet;
806 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
808 /// // Will print in ascending order.
809 /// for x in set.iter() {
810 /// println!("{}", x);
814 pub fn iter<'a>(&'a self) -> SetItems<'a, T> {
815 SetItems{iter: self.map.iter()}
818 /// Get a lazy iterator over the values in the set, in descending order.
823 /// use std::collections::TreeSet;
824 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
826 /// // Will print in descending order.
827 /// for x in set.rev_iter() {
828 /// println!("{}", x);
832 pub fn rev_iter<'a>(&'a self) -> RevSetItems<'a, T> {
833 RevSetItems{iter: self.map.rev_iter()}
836 /// Creates a consuming iterator, that is, one that moves each value out of the
837 /// set in ascending order. The set cannot be used after calling this.
842 /// use std::collections::TreeSet;
843 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
845 /// // Not possible with a regular `.iter()`
846 /// let v: Vec<int> = set.move_iter().collect();
847 /// assert_eq!(v, vec![1, 2, 3, 4, 5]);
850 pub fn move_iter(self) -> MoveSetItems<T> {
851 self.map.move_iter().map(|(value, _)| value)
854 /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal).
855 /// If all elements in the set are less than `v` empty iterator is returned.
857 pub fn lower_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
858 SetItems{iter: self.map.lower_bound(v)}
861 /// Get a lazy iterator pointing to the first value greater than `v`.
862 /// If all elements in the set are not greater than `v` empty iterator is returned.
864 pub fn upper_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
865 SetItems{iter: self.map.upper_bound(v)}
868 /// Visit the values representing the difference, in ascending order.
873 /// use std::collections::TreeSet;
874 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
875 /// let b: TreeSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
877 /// // Can be seen as `a - b`.
878 /// for x in a.difference(&b) {
879 /// println!("{}", x); // Print 1 then 2
882 /// let diff: TreeSet<int> = a.difference(&b).map(|&x| x).collect();
883 /// assert_eq!(diff, [1, 2].iter().map(|&x| x).collect());
885 /// // Note that difference is not symmetric,
886 /// // and `b - a` means something else:
887 /// let diff: TreeSet<int> = b.difference(&a).map(|&x| x).collect();
888 /// assert_eq!(diff, [4, 5].iter().map(|&x| x).collect());
890 pub fn difference<'a>(&'a self, other: &'a TreeSet<T>) -> DifferenceItems<'a, T> {
891 DifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
894 /// Visit the values representing the symmetric difference, in ascending order.
899 /// use std::collections::TreeSet;
900 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
901 /// let b: TreeSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
903 /// // Print 1, 2, 4, 5 in ascending order.
904 /// for x in a.symmetric_difference(&b) {
905 /// println!("{}", x);
908 /// let diff1: TreeSet<int> = a.symmetric_difference(&b).map(|&x| x).collect();
909 /// let diff2: TreeSet<int> = b.symmetric_difference(&a).map(|&x| x).collect();
911 /// assert_eq!(diff1, diff2);
912 /// assert_eq!(diff1, [1, 2, 4, 5].iter().map(|&x| x).collect());
914 pub fn symmetric_difference<'a>(&'a self, other: &'a TreeSet<T>)
915 -> SymDifferenceItems<'a, T> {
916 SymDifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
919 /// Visit the values representing the intersection, in ascending order.
924 /// use std::collections::TreeSet;
925 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
926 /// let b: TreeSet<int> = [2, 3, 4].iter().map(|&x| x).collect();
928 /// // Print 2, 3 in ascending order.
929 /// for x in a.intersection(&b) {
930 /// println!("{}", x);
933 /// let diff: TreeSet<int> = a.intersection(&b).map(|&x| x).collect();
934 /// assert_eq!(diff, [2, 3].iter().map(|&x| x).collect());
936 pub fn intersection<'a>(&'a self, other: &'a TreeSet<T>)
937 -> IntersectionItems<'a, T> {
938 IntersectionItems{a: self.iter().peekable(), b: other.iter().peekable()}
941 /// Visit the values representing the union, in ascending order.
946 /// use std::collections::HashSet;
947 /// let a: HashSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
948 /// let b: HashSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
950 /// // Print 1, 2, 3, 4, 5 in ascending order.
951 /// for x in a.union(&b) {
952 /// println!("{}", x);
955 /// let diff: HashSet<int> = a.union(&b).map(|&x| x).collect();
956 /// assert_eq!(diff, [1, 2, 3, 4, 5].iter().map(|&x| x).collect());
958 pub fn union<'a>(&'a self, other: &'a TreeSet<T>) -> UnionItems<'a, T> {
959 UnionItems{a: self.iter().peekable(), b: other.iter().peekable()}
963 /// Lazy forward iterator over a set
964 pub struct SetItems<'a, T> {
965 iter: Entries<'a, T, ()>
968 /// Lazy backward iterator over a set
969 pub struct RevSetItems<'a, T> {
970 iter: RevEntries<'a, T, ()>
973 /// Lazy forward iterator over a set that consumes the set while iterating
974 pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
976 /// Lazy iterator producing elements in the set difference (in-order)
977 pub struct DifferenceItems<'a, T> {
978 a: Peekable<&'a T, SetItems<'a, T>>,
979 b: Peekable<&'a T, SetItems<'a, T>>,
982 /// Lazy iterator producing elements in the set symmetric difference (in-order)
983 pub struct SymDifferenceItems<'a, T> {
984 a: Peekable<&'a T, SetItems<'a, T>>,
985 b: Peekable<&'a T, SetItems<'a, T>>,
988 /// Lazy iterator producing elements in the set intersection (in-order)
989 pub struct IntersectionItems<'a, T> {
990 a: Peekable<&'a T, SetItems<'a, T>>,
991 b: Peekable<&'a T, SetItems<'a, T>>,
994 /// Lazy iterator producing elements in the set union (in-order)
995 pub struct UnionItems<'a, T> {
996 a: Peekable<&'a T, SetItems<'a, T>>,
997 b: Peekable<&'a T, SetItems<'a, T>>,
1000 /// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
1001 fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
1002 short: Ordering, long: Ordering) -> Ordering {
1004 (None , _ ) => short,
1005 (_ , None ) => long,
1006 (Some(x1), Some(y1)) => x1.cmp(y1),
1010 impl<'a, T: Ord> Iterator<&'a T> for DifferenceItems<'a, T> {
1011 fn next(&mut self) -> Option<&'a T> {
1013 match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
1014 Less => return self.a.next(),
1015 Equal => { self.a.next(); self.b.next(); }
1016 Greater => { self.b.next(); }
1022 impl<'a, T: Ord> Iterator<&'a T> for SymDifferenceItems<'a, T> {
1023 fn next(&mut self) -> Option<&'a T> {
1025 match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
1026 Less => return self.a.next(),
1027 Equal => { self.a.next(); self.b.next(); }
1028 Greater => return self.b.next(),
1034 impl<'a, T: Ord> Iterator<&'a T> for IntersectionItems<'a, T> {
1035 fn next(&mut self) -> Option<&'a T> {
1037 let o_cmp = match (self.a.peek(), self.b.peek()) {
1038 (None , _ ) => None,
1039 (_ , None ) => None,
1040 (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
1043 None => return None,
1044 Some(Less) => { self.a.next(); }
1045 Some(Equal) => { self.b.next(); return self.a.next() }
1046 Some(Greater) => { self.b.next(); }
1052 impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
1053 fn next(&mut self) -> Option<&'a T> {
1055 match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
1056 Less => return self.a.next(),
1057 Equal => { self.b.next(); return self.a.next() }
1058 Greater => return self.b.next(),
1065 // Nodes keep track of their level in the tree, starting at 1 in the
1066 // leaves and with a red child sharing the level of the parent.
1068 struct TreeNode<K, V> {
1071 left: Option<Box<TreeNode<K, V>>>,
1072 right: Option<Box<TreeNode<K, V>>>,
1076 impl<K: Ord, V> TreeNode<K, V> {
1077 /// Creates a new tree node.
1079 pub fn new(key: K, value: V) -> TreeNode<K, V> {
1080 TreeNode{key: key, value: value, left: None, right: None, level: 1}
1084 // Remove left horizontal link by rotating right
1085 fn skew<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
1086 if node.left.as_ref().map_or(false, |x| x.level == node.level) {
1087 let mut save = node.left.take_unwrap();
1088 swap(&mut node.left, &mut save.right); // save.right now None
1089 swap(node, &mut save);
1090 node.right = Some(save);
1094 // Remove dual horizontal link by rotating left and increasing level of
1096 fn split<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
1097 if node.right.as_ref().map_or(false,
1098 |x| x.right.as_ref().map_or(false, |y| y.level == node.level)) {
1099 let mut save = node.right.take_unwrap();
1100 swap(&mut node.right, &mut save.left); // save.left now None
1102 swap(node, &mut save);
1103 node.left = Some(save);
1107 // Next 2 functions have the same convention: comparator gets
1108 // at input current key and returns search_key cmp cur_key
1109 // (i.e. search_key.cmp(&cur_key))
1110 fn tree_find_with<'r, K, V>(node: &'r Option<Box<TreeNode<K, V>>>,
1111 f: |&K| -> Ordering) -> Option<&'r V> {
1112 let mut current: &'r Option<Box<TreeNode<K, V>>> = node;
1117 Less => current = &r.left,
1118 Greater => current = &r.right,
1119 Equal => return Some(&r.value)
1127 // See comments above tree_find_with
1128 fn tree_find_mut_with<'r, K, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
1129 f: |&K| -> Ordering) -> Option<&'r mut V> {
1131 let mut current = node;
1133 let temp = current; // hack to appease borrowck
1135 Some(ref mut r) => {
1137 Less => current = &mut r.left,
1138 Greater => current = &mut r.right,
1139 Equal => return Some(&mut r.value)
1147 fn insert<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
1148 key: K, value: V) -> Option<V> {
1150 Some(ref mut save) => {
1151 match key.cmp(&save.key) {
1153 let inserted = insert(&mut save.left, key, value);
1159 let inserted = insert(&mut save.right, key, value);
1166 Some(replace(&mut save.value, value))
1171 *node = Some(box TreeNode::new(key, value));
1177 fn remove<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
1178 key: &K) -> Option<V> {
1179 fn heir_swap<K: Ord, V>(node: &mut Box<TreeNode<K, V>>,
1180 child: &mut Option<Box<TreeNode<K, V>>>) {
1181 // *could* be done without recursion, but it won't borrow check
1182 for x in child.mut_iter() {
1183 if x.right.is_some() {
1184 heir_swap(node, &mut x.right);
1186 swap(&mut node.key, &mut x.key);
1187 swap(&mut node.value, &mut x.value);
1194 return None; // bottom of tree
1196 Some(ref mut save) => {
1197 let (ret, rebalance) = match key.cmp(&save.key) {
1198 Less => (remove(&mut save.left, key), true),
1199 Greater => (remove(&mut save.right, key), true),
1201 if save.left.is_some() {
1202 if save.right.is_some() {
1203 let mut left = save.left.take_unwrap();
1204 if left.right.is_some() {
1205 heir_swap(save, &mut left.right);
1207 swap(&mut save.key, &mut left.key);
1208 swap(&mut save.value, &mut left.value);
1210 save.left = Some(left);
1211 (remove(&mut save.left, key), true)
1213 let new = save.left.take_unwrap();
1214 let box TreeNode{value, ..} = replace(save, new);
1215 *save = save.left.take_unwrap();
1218 } else if save.right.is_some() {
1219 let new = save.right.take_unwrap();
1220 let box TreeNode{value, ..} = replace(save, new);
1229 let left_level = save.left.as_ref().map_or(0, |x| x.level);
1230 let right_level = save.right.as_ref().map_or(0, |x| x.level);
1232 // re-balance, if necessary
1233 if left_level < save.level - 1 || right_level < save.level - 1 {
1236 if right_level > save.level {
1237 for x in save.right.mut_iter() { x.level = save.level }
1242 for right in save.right.mut_iter() {
1244 for x in right.right.mut_iter() { skew(x) }
1248 for x in save.right.mut_iter() { split(x) }
1255 return match node.take() {
1256 Some(box TreeNode{value, ..}) => Some(value), None => fail!()
1260 impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
1261 fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
1262 let mut map = TreeMap::new();
1268 impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
1270 fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
1271 for (k, v) in iter {
1277 impl<S: Writer, K: Ord + Hash<S>, V: Hash<S>> Hash<S> for TreeMap<K, V> {
1278 fn hash(&self, state: &mut S) {
1279 for elt in self.iter() {
1285 impl<T: Ord> FromIterator<T> for TreeSet<T> {
1286 fn from_iter<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
1287 let mut set = TreeSet::new();
1293 impl<T: Ord> Extendable<T> for TreeSet<T> {
1295 fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
1302 impl<S: Writer, T: Ord + Hash<S>> Hash<S> for TreeSet<T> {
1303 fn hash(&self, state: &mut S) {
1304 for elt in self.iter() {
1312 use std::prelude::*;
1316 use {Map, MutableMap, Mutable, MutableSeq};
1317 use super::{TreeMap, TreeNode};
1321 let m: TreeMap<int,int> = TreeMap::new();
1322 assert!(m.find(&5) == None);
1326 fn find_not_found() {
1327 let mut m = TreeMap::new();
1328 assert!(m.insert(1i, 2i));
1329 assert!(m.insert(5i, 3i));
1330 assert!(m.insert(9i, 3i));
1331 assert_eq!(m.find(&2), None);
1335 fn find_with_empty() {
1336 let m: TreeMap<&'static str,int> = TreeMap::new();
1337 assert!(m.find_with(|k| "test".cmp(k)) == None);
1341 fn find_with_not_found() {
1342 let mut m = TreeMap::new();
1343 assert!(m.insert("test1", 2i));
1344 assert!(m.insert("test2", 3i));
1345 assert!(m.insert("test3", 3i));
1346 assert_eq!(m.find_with(|k| "test4".cmp(k)), None);
1350 fn find_with_found() {
1351 let mut m = TreeMap::new();
1352 assert!(m.insert("test1", 2i));
1353 assert!(m.insert("test2", 3i));
1354 assert!(m.insert("test3", 4i));
1355 assert_eq!(m.find_with(|k| "test2".cmp(k)), Some(&3i));
1359 fn test_find_mut() {
1360 let mut m = TreeMap::new();
1361 assert!(m.insert(1i, 12i));
1362 assert!(m.insert(2, 8));
1363 assert!(m.insert(5, 14));
1365 match m.find_mut(&5) {
1366 None => fail!(), Some(x) => *x = new
1368 assert_eq!(m.find(&5), Some(&new));
1372 fn test_find_with_mut() {
1373 let mut m = TreeMap::new();
1374 assert!(m.insert("t1", 12i));
1375 assert!(m.insert("t2", 8));
1376 assert!(m.insert("t5", 14));
1378 match m.find_mut_with(|k| "t5".cmp(k)) {
1379 None => fail!(), Some(x) => *x = new
1381 assert_eq!(m.find_with(|k| "t5".cmp(k)), Some(&new));
1385 fn insert_replace() {
1386 let mut m = TreeMap::new();
1387 assert!(m.insert(5i, 2i));
1388 assert!(m.insert(2, 9));
1389 assert!(!m.insert(2, 11));
1390 assert_eq!(m.find(&2).unwrap(), &11);
1395 let mut m = TreeMap::new();
1397 assert!(m.insert(5i, 11i));
1398 assert!(m.insert(12, -3));
1399 assert!(m.insert(19, 2));
1401 assert!(m.find(&5).is_none());
1402 assert!(m.find(&12).is_none());
1403 assert!(m.find(&19).is_none());
1404 assert!(m.is_empty());
1409 let mut m = TreeMap::new();
1411 let k1 = "foo".as_bytes();
1412 let k2 = "bar".as_bytes();
1413 let v1 = "baz".as_bytes();
1414 let v2 = "foobar".as_bytes();
1416 m.insert(k1.clone(), v1.clone());
1417 m.insert(k2.clone(), v2.clone());
1419 assert_eq!(m.find(&k2), Some(&v2));
1420 assert_eq!(m.find(&k1), Some(&v1));
1423 fn check_equal<K: PartialEq + Ord, V: PartialEq>(ctrl: &[(K, V)],
1424 map: &TreeMap<K, V>) {
1425 assert_eq!(ctrl.is_empty(), map.is_empty());
1426 for x in ctrl.iter() {
1427 let &(ref k, ref v) = x;
1428 assert!(map.find(k).unwrap() == v)
1430 for (map_k, map_v) in map.iter() {
1431 let mut found = false;
1432 for x in ctrl.iter() {
1433 let &(ref ctrl_k, ref ctrl_v) = x;
1434 if *map_k == *ctrl_k {
1435 assert!(*map_v == *ctrl_v);
1444 fn check_left<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1445 parent: &Box<TreeNode<K, V>>) {
1448 assert_eq!(r.key.cmp(&parent.key), Less);
1449 assert!(r.level == parent.level - 1); // left is black
1450 check_left(&r.left, r);
1451 check_right(&r.right, r, false);
1453 None => assert!(parent.level == 1) // parent is leaf
1457 fn check_right<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1458 parent: &Box<TreeNode<K, V>>,
1462 assert_eq!(r.key.cmp(&parent.key), Greater);
1463 let red = r.level == parent.level;
1464 if parent_red { assert!(!red) } // no dual horizontal links
1465 // Right red or black
1466 assert!(red || r.level == parent.level - 1);
1467 check_left(&r.left, r);
1468 check_right(&r.right, r, red);
1470 None => assert!(parent.level == 1) // parent is leaf
1474 fn check_structure<K: Ord, V>(map: &TreeMap<K, V>) {
1477 check_left(&r.left, r);
1478 check_right(&r.right, r, false);
1485 fn test_rand_int() {
1486 let mut map: TreeMap<int,int> = TreeMap::new();
1487 let mut ctrl = vec![];
1489 check_equal(ctrl.as_slice(), &map);
1490 assert!(map.find(&5).is_none());
1492 let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(&[42]);
1494 for _ in range(0u, 3) {
1495 for _ in range(0u, 90) {
1498 if !ctrl.iter().any(|x| x == &(k, v)) {
1499 assert!(map.insert(k, v));
1501 check_structure(&map);
1502 check_equal(ctrl.as_slice(), &map);
1506 for _ in range(0u, 30) {
1507 let r = rng.gen_range(0, ctrl.len());
1508 let (key, _) = ctrl.remove(r).unwrap();
1509 assert!(map.remove(&key));
1510 check_structure(&map);
1511 check_equal(ctrl.as_slice(), &map);
1518 let mut m = TreeMap::new();
1519 assert!(m.insert(3i, 6i));
1520 assert_eq!(m.len(), 1);
1521 assert!(m.insert(0, 0));
1522 assert_eq!(m.len(), 2);
1523 assert!(m.insert(4, 8));
1524 assert_eq!(m.len(), 3);
1525 assert!(m.remove(&3));
1526 assert_eq!(m.len(), 2);
1527 assert!(!m.remove(&5));
1528 assert_eq!(m.len(), 2);
1529 assert!(m.insert(2, 4));
1530 assert_eq!(m.len(), 3);
1531 assert!(m.insert(1, 2));
1532 assert_eq!(m.len(), 4);
1536 fn test_iterator() {
1537 let mut m = TreeMap::new();
1539 assert!(m.insert(3i, 6i));
1540 assert!(m.insert(0, 0));
1541 assert!(m.insert(4, 8));
1542 assert!(m.insert(2, 4));
1543 assert!(m.insert(1, 2));
1546 for (k, v) in m.iter() {
1548 assert_eq!(*v, n * 2);
1555 fn test_interval_iteration() {
1556 let mut m = TreeMap::new();
1557 for i in range(1i, 100i) {
1558 assert!(m.insert(i * 2, i * 4));
1561 for i in range(1i, 198i) {
1562 let mut lb_it = m.lower_bound(&i);
1563 let (&k, &v) = lb_it.next().unwrap();
1566 assert_eq!(lb * 2, v);
1568 let mut ub_it = m.upper_bound(&i);
1569 let (&k, &v) = ub_it.next().unwrap();
1570 let ub = i + 2 - i % 2;
1572 assert_eq!(ub * 2, v);
1574 let mut end_it = m.lower_bound(&199);
1575 assert_eq!(end_it.next(), None);
1579 fn test_rev_iter() {
1580 let mut m = TreeMap::new();
1582 assert!(m.insert(3i, 6i));
1583 assert!(m.insert(0, 0));
1584 assert!(m.insert(4, 8));
1585 assert!(m.insert(2, 4));
1586 assert!(m.insert(1, 2));
1589 for (k, v) in m.rev_iter() {
1591 assert_eq!(*v, n * 2);
1597 fn test_mut_iter() {
1598 let mut m = TreeMap::new();
1599 for i in range(0u, 10) {
1600 assert!(m.insert(i, 100 * i));
1603 for (i, (&k, v)) in m.mut_iter().enumerate() {
1604 *v += k * 10 + i; // 000 + 00 + 0, 100 + 10 + 1, ...
1607 for (&k, &v) in m.iter() {
1608 assert_eq!(v, 111 * k);
1612 fn test_mut_rev_iter() {
1613 let mut m = TreeMap::new();
1614 for i in range(0u, 10) {
1615 assert!(m.insert(i, 100 * i));
1618 for (i, (&k, v)) in m.mut_rev_iter().enumerate() {
1619 *v += k * 10 + (9 - i); // 900 + 90 + (9 - 0), 800 + 80 + (9 - 1), ...
1622 for (&k, &v) in m.iter() {
1623 assert_eq!(v, 111 * k);
1628 fn test_mut_interval_iter() {
1629 let mut m_lower = TreeMap::new();
1630 let mut m_upper = TreeMap::new();
1631 for i in range(1i, 100i) {
1632 assert!(m_lower.insert(i * 2, i * 4));
1633 assert!(m_upper.insert(i * 2, i * 4));
1636 for i in range(1i, 199) {
1637 let mut lb_it = m_lower.mut_lower_bound(&i);
1638 let (&k, v) = lb_it.next().unwrap();
1643 for i in range(0i, 198) {
1644 let mut ub_it = m_upper.mut_upper_bound(&i);
1645 let (&k, v) = ub_it.next().unwrap();
1646 let ub = i + 2 - i % 2;
1651 assert!(m_lower.mut_lower_bound(&199).next().is_none());
1653 assert!(m_upper.mut_upper_bound(&198).next().is_none());
1655 assert!(m_lower.iter().all(|(_, &x)| x == 0));
1656 assert!(m_upper.iter().all(|(_, &x)| x == 0));
1661 let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
1662 let map = vec.move_iter().collect::<TreeMap<int, char>>();
1663 let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
1664 assert_eq!(keys.len(), 3);
1665 assert!(keys.contains(&1));
1666 assert!(keys.contains(&2));
1667 assert!(keys.contains(&3));
1672 let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
1673 let map = vec.move_iter().collect::<TreeMap<int, char>>();
1674 let values = map.values().map(|&v| v).collect::<Vec<char>>();
1675 assert_eq!(values.len(), 3);
1676 assert!(values.contains(&'a'));
1677 assert!(values.contains(&'b'));
1678 assert!(values.contains(&'c'));
1683 let mut a = TreeMap::new();
1684 let mut b = TreeMap::new();
1687 assert!(a.insert(0i, 5i));
1689 assert!(b.insert(0, 4));
1691 assert!(a.insert(5, 19));
1693 assert!(!b.insert(0, 5));
1695 assert!(b.insert(5, 19));
1701 let mut a = TreeMap::new();
1702 let mut b = TreeMap::new();
1704 assert!(!(a < b) && !(b < a));
1705 assert!(b.insert(0i, 5i));
1707 assert!(a.insert(0, 7));
1708 assert!(!(a < b) && b < a);
1709 assert!(b.insert(-2, 0));
1711 assert!(a.insert(-5, 2));
1713 assert!(a.insert(6, 2));
1714 assert!(a < b && !(b < a));
1719 let mut a = TreeMap::new();
1720 let mut b = TreeMap::new();
1722 assert!(a <= b && a >= b);
1723 assert!(a.insert(1i, 1i));
1724 assert!(a > b && a >= b);
1725 assert!(b < a && b <= a);
1726 assert!(b.insert(2, 2));
1727 assert!(b > a && b >= a);
1728 assert!(a < b && a <= b);
1733 let mut map: TreeMap<int, int> = TreeMap::new();
1734 let empty: TreeMap<int, int> = TreeMap::new();
1739 let map_str = format!("{}", map);
1741 assert!(map_str == "{1: 2, 3: 4}".to_string());
1742 assert_eq!(format!("{}", empty), "{}".to_string());
1746 fn test_lazy_iterator() {
1747 let mut m = TreeMap::new();
1748 let (x1, y1) = (2i, 5i);
1749 let (x2, y2) = (9, 12);
1750 let (x3, y3) = (20, -3);
1751 let (x4, y4) = (29, 5);
1752 let (x5, y5) = (103, 3);
1754 assert!(m.insert(x1, y1));
1755 assert!(m.insert(x2, y2));
1756 assert!(m.insert(x3, y3));
1757 assert!(m.insert(x4, y4));
1758 assert!(m.insert(x5, y5));
1761 let mut a = m.iter();
1763 assert_eq!(a.next().unwrap(), (&x1, &y1));
1764 assert_eq!(a.next().unwrap(), (&x2, &y2));
1765 assert_eq!(a.next().unwrap(), (&x3, &y3));
1766 assert_eq!(a.next().unwrap(), (&x4, &y4));
1767 assert_eq!(a.next().unwrap(), (&x5, &y5));
1769 assert!(a.next().is_none());
1771 let mut b = m.iter();
1773 let expected = [(&x1, &y1), (&x2, &y2), (&x3, &y3), (&x4, &y4),
1778 assert_eq!(expected[i], x);
1787 assert_eq!(expected[i], x);
1793 fn test_from_iter() {
1794 let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
1796 let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
1798 for &(k, v) in xs.iter() {
1799 assert_eq!(map.find(&k), Some(&v));
1810 use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
1814 pub fn insert_rand_100(b: &mut Bencher) {
1815 let mut m : TreeMap<uint,uint> = TreeMap::new();
1816 insert_rand_n(100, &mut m, b);
1820 pub fn insert_rand_10_000(b: &mut Bencher) {
1821 let mut m : TreeMap<uint,uint> = TreeMap::new();
1822 insert_rand_n(10_000, &mut m, b);
1827 pub fn insert_seq_100(b: &mut Bencher) {
1828 let mut m : TreeMap<uint,uint> = TreeMap::new();
1829 insert_seq_n(100, &mut m, b);
1833 pub fn insert_seq_10_000(b: &mut Bencher) {
1834 let mut m : TreeMap<uint,uint> = TreeMap::new();
1835 insert_seq_n(10_000, &mut m, b);
1840 pub fn find_rand_100(b: &mut Bencher) {
1841 let mut m : TreeMap<uint,uint> = TreeMap::new();
1842 find_rand_n(100, &mut m, b);
1846 pub fn find_rand_10_000(b: &mut Bencher) {
1847 let mut m : TreeMap<uint,uint> = TreeMap::new();
1848 find_rand_n(10_000, &mut m, b);
1853 pub fn find_seq_100(b: &mut Bencher) {
1854 let mut m : TreeMap<uint,uint> = TreeMap::new();
1855 find_seq_n(100, &mut m, b);
1859 pub fn find_seq_10_000(b: &mut Bencher) {
1860 let mut m : TreeMap<uint,uint> = TreeMap::new();
1861 find_seq_n(10_000, &mut m, b);
1867 use std::prelude::*;
1870 use {Set, MutableSet, Mutable, MutableMap, MutableSeq};
1871 use super::{TreeMap, TreeSet};
1875 let mut s = TreeSet::new();
1877 assert!(s.insert(5i));
1878 assert!(s.insert(12));
1879 assert!(s.insert(19));
1881 assert!(!s.contains(&5));
1882 assert!(!s.contains(&12));
1883 assert!(!s.contains(&19));
1884 assert!(s.is_empty());
1888 fn test_disjoint() {
1889 let mut xs = TreeSet::new();
1890 let mut ys = TreeSet::new();
1891 assert!(xs.is_disjoint(&ys));
1892 assert!(ys.is_disjoint(&xs));
1893 assert!(xs.insert(5i));
1894 assert!(ys.insert(11i));
1895 assert!(xs.is_disjoint(&ys));
1896 assert!(ys.is_disjoint(&xs));
1897 assert!(xs.insert(7));
1898 assert!(xs.insert(19));
1899 assert!(xs.insert(4));
1900 assert!(ys.insert(2));
1901 assert!(ys.insert(-11));
1902 assert!(xs.is_disjoint(&ys));
1903 assert!(ys.is_disjoint(&xs));
1904 assert!(ys.insert(7));
1905 assert!(!xs.is_disjoint(&ys));
1906 assert!(!ys.is_disjoint(&xs));
1910 fn test_subset_and_superset() {
1911 let mut a = TreeSet::new();
1912 assert!(a.insert(0i));
1913 assert!(a.insert(5));
1914 assert!(a.insert(11));
1915 assert!(a.insert(7));
1917 let mut b = TreeSet::new();
1918 assert!(b.insert(0i));
1919 assert!(b.insert(7));
1920 assert!(b.insert(19));
1921 assert!(b.insert(250));
1922 assert!(b.insert(11));
1923 assert!(b.insert(200));
1925 assert!(!a.is_subset(&b));
1926 assert!(!a.is_superset(&b));
1927 assert!(!b.is_subset(&a));
1928 assert!(!b.is_superset(&a));
1930 assert!(b.insert(5));
1932 assert!(a.is_subset(&b));
1933 assert!(!a.is_superset(&b));
1934 assert!(!b.is_subset(&a));
1935 assert!(b.is_superset(&a));
1939 fn test_iterator() {
1940 let mut m = TreeSet::new();
1942 assert!(m.insert(3i));
1943 assert!(m.insert(0));
1944 assert!(m.insert(4));
1945 assert!(m.insert(2));
1946 assert!(m.insert(1));
1956 fn test_rev_iter() {
1957 let mut m = TreeSet::new();
1959 assert!(m.insert(3i));
1960 assert!(m.insert(0));
1961 assert!(m.insert(4));
1962 assert!(m.insert(2));
1963 assert!(m.insert(1));
1966 for x in m.rev_iter() {
1973 fn test_move_iter() {
1974 let s: TreeSet<int> = range(0i, 5).collect();
1977 for x in s.move_iter() {
1984 fn test_move_iter_size_hint() {
1985 let s: TreeSet<int> = vec!(0i, 1).move_iter().collect();
1987 let mut it = s.move_iter();
1989 assert_eq!(it.size_hint(), (2, Some(2)));
1990 assert!(it.next() != None);
1992 assert_eq!(it.size_hint(), (1, Some(1)));
1993 assert!(it.next() != None);
1995 assert_eq!(it.size_hint(), (0, Some(0)));
1996 assert_eq!(it.next(), None);
2000 fn test_clone_eq() {
2001 let mut m = TreeSet::new();
2006 assert!(m.clone() == m);
2011 let mut x = TreeSet::new();
2012 let mut y = TreeSet::new();
2022 assert!(hash::hash(&x) == hash::hash(&y));
2028 f: |&TreeSet<int>, &TreeSet<int>, f: |&int| -> bool| -> bool) {
2029 let mut set_a = TreeSet::new();
2030 let mut set_b = TreeSet::new();
2032 for x in a.iter() { assert!(set_a.insert(*x)) }
2033 for y in b.iter() { assert!(set_b.insert(*y)) }
2036 f(&set_a, &set_b, |x| {
2037 assert_eq!(*x, expected[i]);
2041 assert_eq!(i, expected.len());
2045 fn test_intersection() {
2046 fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
2047 check(a, b, expected, |x, y, f| x.intersection(y).all(f))
2050 check_intersection([], [], []);
2051 check_intersection([1, 2, 3], [], []);
2052 check_intersection([], [1, 2, 3], []);
2053 check_intersection([2], [1, 2, 3], [2]);
2054 check_intersection([1, 2, 3], [2], [2]);
2055 check_intersection([11, 1, 3, 77, 103, 5, -5],
2056 [2, 11, 77, -9, -42, 5, 3],
2061 fn test_difference() {
2062 fn check_difference(a: &[int], b: &[int], expected: &[int]) {
2063 check(a, b, expected, |x, y, f| x.difference(y).all(f))
2066 check_difference([], [], []);
2067 check_difference([1, 12], [], [1, 12]);
2068 check_difference([], [1, 2, 3, 9], []);
2069 check_difference([1, 3, 5, 9, 11],
2072 check_difference([-5, 11, 22, 33, 40, 42],
2073 [-12, -5, 14, 23, 34, 38, 39, 50],
2074 [11, 22, 33, 40, 42]);
2078 fn test_symmetric_difference() {
2079 fn check_symmetric_difference(a: &[int], b: &[int],
2081 check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
2084 check_symmetric_difference([], [], []);
2085 check_symmetric_difference([1, 2, 3], [2], [1, 3]);
2086 check_symmetric_difference([2], [1, 2, 3], [1, 3]);
2087 check_symmetric_difference([1, 3, 5, 9, 11],
2089 [-2, 1, 5, 11, 14, 22]);
2094 fn check_union(a: &[int], b: &[int],
2096 check(a, b, expected, |x, y, f| x.union(y).all(f))
2099 check_union([], [], []);
2100 check_union([1, 2, 3], [2], [1, 2, 3]);
2101 check_union([2], [1, 2, 3], [1, 2, 3]);
2102 check_union([1, 3, 5, 9, 11, 16, 19, 24],
2103 [-2, 1, 5, 9, 13, 19],
2104 [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
2109 let mut x = TreeSet::new();
2114 let mut y = TreeSet::new();
2120 let mut z = x.iter().zip(y.iter());
2122 // FIXME: #5801: this needs a type hint to compile...
2123 let result: Option<(&uint, & &'static str)> = z.next();
2124 assert_eq!(result.unwrap(), (&5u, &("bar")));
2126 let result: Option<(&uint, & &'static str)> = z.next();
2127 assert_eq!(result.unwrap(), (&11u, &("foo")));
2129 let result: Option<(&uint, & &'static str)> = z.next();
2130 assert!(result.is_none());
2135 let mut m = TreeMap::new();
2136 assert_eq!(m.swap(1u, 2i), None);
2137 assert_eq!(m.swap(1u, 3i), Some(2));
2138 assert_eq!(m.swap(1u, 4i), Some(3));
2143 let mut m = TreeMap::new();
2145 assert_eq!(m.pop(&1), Some(2));
2146 assert_eq!(m.pop(&1), None);
2150 fn test_from_iter() {
2151 let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
2153 let set: TreeSet<int> = xs.iter().map(|&x| x).collect();
2155 for x in xs.iter() {
2156 assert!(set.contains(x));
2162 let mut set: TreeSet<int> = TreeSet::new();
2163 let empty: TreeSet<int> = TreeSet::new();
2168 let set_str = format!("{}", set);
2170 assert!(set_str == "{1, 2}".to_string());
2171 assert_eq!(format!("{}", empty), "{}".to_string());