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.
54 /// use std::collections::TreeMap;
56 /// let mut map = TreeMap::new();
58 /// map.insert(2i, "bar");
59 /// map.insert(1i, "foo");
60 /// map.insert(3i, "quux");
62 /// // In ascending order by keys
63 /// for (key, value) in map.iter() {
64 /// println!("{}: {}", key, value);
68 /// for key in map.keys() {
69 /// println!("{}", key);
72 /// // Print `foo`, `bar`, `quux`
73 /// for key in map.values() {
74 /// println!("{}", key);
78 /// assert_eq!(map.len(), 2);
80 /// if !map.contains_key(&1) {
81 /// println!("1 is no more");
84 /// for key in range(0, 4) {
85 /// match map.find(&key) {
86 /// Some(val) => println!("{} has a value: {}", key, val),
87 /// None => println!("{} not in map", key),
92 /// assert!(map.is_empty());
95 /// The easiest way to use `TreeMap` with a custom type as keys is to implement `Ord`.
96 /// We must also implement `PartialEq`, `Eq` and `PartialOrd`.
99 /// use std::collections::TreeMap;
101 /// // We need `Eq` and `PartialEq`, these can be derived.
102 /// #[deriving(Eq, PartialEq)]
103 /// struct Troll<'a> {
108 /// // Implement `Ord` and sort trolls by level.
109 /// impl<'a> Ord for Troll<'a> {
110 /// fn cmp(&self, other: &Troll) -> Ordering {
111 /// // If we swap `self` and `other`, we get descended ordering.
112 /// self.level.cmp(&other.level)
116 /// // `PartialOrd` needs to be implemented as well.
117 /// impl<'a> PartialOrd for Troll<'a> {
118 /// fn partial_cmp(&self, other: &Troll) -> Option<Ordering> {
119 /// Some(self.cmp(other))
123 /// // Use a map to store trolls, sorted by level, and track a list of
125 /// let mut trolls = TreeMap::new();
127 /// trolls.insert(Troll { name: "Orgarr", level: 2 },
128 /// vec!["King Karl"]);
129 /// trolls.insert(Troll { name: "Blargarr", level: 3 },
131 /// trolls.insert(Troll { name: "Kron the Smelly One", level: 4 },
132 /// vec!["Omar the Brave", "Peter: Slayer of Trolls"]);
133 /// trolls.insert(Troll { name: "Wartilda", level: 1 },
136 /// println!("You are facing {} trolls!", trolls.len());
138 /// // Print the trolls, ordered by level with smallest level first
139 /// for (troll, heroes) in trolls.iter() {
140 /// let what = if heroes.len() == 1u { "hero" }
141 /// else { "heroes" };
143 /// println!("level {}: '{}' has slain {} {}",
144 /// troll.level, troll.name, heroes.len(), what);
147 /// // Kill all trolls
149 /// assert_eq!(trolls.len(), 0);
152 // Future improvements:
154 // range search - O(log n) retrieval of an iterator from some key
156 // (possibly) implement the overloads Python does for sets:
159 // * symmetric difference: ^
161 // These would be convenient since the methods work like `each`
164 pub struct TreeMap<K, V> {
165 root: Option<Box<TreeNode<K, V>>>,
169 impl<K: PartialEq + Ord, V: PartialEq> PartialEq for TreeMap<K, V> {
170 fn eq(&self, other: &TreeMap<K, V>) -> bool {
171 self.len() == other.len() &&
172 self.iter().zip(other.iter()).all(|(a, b)| a == b)
176 impl<K: Ord, V: PartialOrd> PartialOrd for TreeMap<K, V> {
178 fn partial_cmp(&self, other: &TreeMap<K, V>) -> Option<Ordering> {
179 iter::order::partial_cmp(self.iter(), other.iter())
183 impl<K: Ord + Show, V: Show> Show for TreeMap<K, V> {
184 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
185 try!(write!(f, "{{"));
187 for (i, (k, v)) in self.iter().enumerate() {
188 if i != 0 { try!(write!(f, ", ")); }
189 try!(write!(f, "{}: {}", *k, *v));
196 impl<K: Ord, V> Collection for TreeMap<K, V> {
197 fn len(&self) -> uint { self.length }
200 impl<K: Ord, V> Mutable for TreeMap<K, V> {
201 fn clear(&mut self) {
207 impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
208 // See comments on tree_find_with
210 fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
211 tree_find_with(&self.root, |k2| key.cmp(k2))
215 impl<K: Ord, V> MutableMap<K, V> for TreeMap<K, V> {
216 // See comments on def_tree_find_mut_with
218 fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
219 tree_find_mut_with(&mut self.root, |x| key.cmp(x))
222 fn swap(&mut self, key: K, value: V) -> Option<V> {
223 let ret = insert(&mut self.root, key, value);
224 if ret.is_none() { self.length += 1 }
228 fn pop(&mut self, key: &K) -> Option<V> {
229 let ret = remove(&mut self.root, key);
230 if ret.is_some() { self.length -= 1 }
235 impl<K: Ord, V> Default for TreeMap<K,V> {
237 fn default() -> TreeMap<K, V> { TreeMap::new() }
240 impl<K: Ord, V> TreeMap<K, V> {
241 /// Create an empty `TreeMap`.
246 /// use std::collections::TreeMap;
247 /// let mut map: TreeMap<&str, int> = TreeMap::new();
249 pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
251 /// Get a lazy iterator over the keys in the map, in ascending order.
256 /// use std::collections::TreeMap;
257 /// let mut map = TreeMap::new();
258 /// map.insert("a", 1i);
259 /// map.insert("c", 3i);
260 /// map.insert("b", 2i);
262 /// // Print "a", "b", "c" in order.
263 /// for x in map.keys() {
264 /// println!("{}", x);
267 pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
268 self.iter().map(|(k, _v)| k)
271 /// Get a lazy iterator over the values in the map, in ascending order
272 /// with respect to the corresponding keys.
277 /// use std::collections::TreeMap;
278 /// let mut map = TreeMap::new();
279 /// map.insert("a", 1i);
280 /// map.insert("c", 3i);
281 /// map.insert("b", 2i);
283 /// // Print 1, 2, 3 ordered by keys.
284 /// for x in map.values() {
285 /// println!("{}", x);
288 pub fn values<'a>(&'a self) -> Values<'a, K, V> {
289 self.iter().map(|(_k, v)| v)
292 /// Get a lazy iterator over the key-value pairs in the map, in ascending order.
293 /// Requires that it be frozen (immutable).
298 /// use std::collections::TreeMap;
299 /// let mut map = TreeMap::new();
300 /// map.insert("a", 1i);
301 /// map.insert("c", 3i);
302 /// map.insert("b", 2i);
304 /// // Print contents in ascending order
305 /// for (key, value) in map.iter() {
306 /// println!("{}: {}", key, value);
309 pub fn iter<'a>(&'a self) -> Entries<'a, K, V> {
312 node: deref(&self.root),
313 remaining_min: self.length,
314 remaining_max: self.length
318 /// Get a lazy reverse iterator over the key-value pairs in the map, in descending order.
319 /// Requires that it be frozen (immutable).
324 /// use std::collections::TreeMap;
325 /// let mut map = TreeMap::new();
326 /// map.insert("a", 1i);
327 /// map.insert("c", 3i);
328 /// map.insert("b", 2i);
330 /// // Print contents in descending order
331 /// for (key, value) in map.rev_iter() {
332 /// println!("{}: {}", key, value);
335 pub fn rev_iter<'a>(&'a self) -> RevEntries<'a, K, V> {
336 RevEntries{iter: self.iter()}
339 /// Get a lazy forward iterator over the key-value pairs in the
340 /// map, with the values being mutable.
345 /// use std::collections::TreeMap;
346 /// let mut map = TreeMap::new();
347 /// map.insert("a", 1i);
348 /// map.insert("c", 3i);
349 /// map.insert("b", 2i);
351 /// // Add 10 until we find "b"
352 /// for (key, value) in map.mut_iter() {
354 /// if key == &"b" { break }
357 /// assert_eq!(map.find(&"a"), Some(&11));
358 /// assert_eq!(map.find(&"b"), Some(&12));
359 /// assert_eq!(map.find(&"c"), Some(&3));
361 pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> {
364 node: mut_deref(&mut self.root),
365 remaining_min: self.length,
366 remaining_max: self.length
369 /// Get a lazy reverse iterator over the key-value pairs in the
370 /// map, with the values being mutable.
375 /// use std::collections::TreeMap;
376 /// let mut map = TreeMap::new();
377 /// map.insert("a", 1i);
378 /// map.insert("c", 3i);
379 /// map.insert("b", 2i);
381 /// // Add 10 until we find "b"
382 /// for (key, value) in map.mut_rev_iter() {
384 /// if key == &"b" { break }
387 /// assert_eq!(map.find(&"a"), Some(&1));
388 /// assert_eq!(map.find(&"b"), Some(&12));
389 /// assert_eq!(map.find(&"c"), Some(&13));
391 pub fn mut_rev_iter<'a>(&'a mut self) -> RevMutEntries<'a, K, V> {
392 RevMutEntries{iter: self.mut_iter()}
396 /// Get a lazy iterator that consumes the treemap, it is not usable
397 /// after calling this.
402 /// use std::collections::TreeMap;
403 /// let mut map = TreeMap::new();
404 /// map.insert("a", 1i);
405 /// map.insert("c", 3i);
406 /// map.insert("b", 2i);
408 /// // Not possible with a regular `.iter()`
409 /// let vec: Vec<(&str, int)> = map.move_iter().collect();
410 /// assert_eq!(vec, vec![("a", 1), ("b", 2), ("c", 3)]);
412 pub fn move_iter(self) -> MoveEntries<K, V> {
413 let TreeMap { root: root, length: length } = self;
414 let stk = match root {
416 Some(box tn) => vec!(tn)
425 impl<K, V> TreeMap<K, V> {
426 /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
427 /// with current key and guides tree navigation. That means `f` should
428 /// be aware of natural ordering of the tree.
433 /// use collections::treemap::TreeMap;
435 /// fn get_headers() -> TreeMap<String, String> {
436 /// let mut result = TreeMap::new();
437 /// result.insert("Content-Type".to_string(), "application/xml".to_string());
438 /// result.insert("User-Agent".to_string(), "Curl-Rust/0.1".to_string());
442 /// let headers = get_headers();
443 /// let ua_key = "User-Agent";
444 /// let ua = headers.find_with(|k| {
445 /// ua_key.cmp(&k.as_slice())
448 /// assert_eq!((*ua.unwrap()).as_slice(), "Curl-Rust/0.1");
451 pub fn find_with<'a>(&'a self, f:|&K| -> Ordering) -> Option<&'a V> {
452 tree_find_with(&self.root, f)
455 /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
456 /// with current key and guides tree navigation. That means `f` should
457 /// be aware of natural ordering of the tree.
462 /// let mut t = collections::treemap::TreeMap::new();
463 /// t.insert("Content-Type", "application/xml");
464 /// t.insert("User-Agent", "Curl-Rust/0.1");
466 /// let new_ua = "Safari/156.0";
467 /// match t.find_mut_with(|k| "User-Agent".cmp(k)) {
468 /// Some(x) => *x = new_ua,
472 /// assert_eq!(t.find(&"User-Agent"), Some(&new_ua));
475 pub fn find_mut_with<'a>(&'a mut self, f:|&K| -> Ordering) -> Option<&'a mut V> {
476 tree_find_mut_with(&mut self.root, f)
482 macro_rules! bound_setup {
483 // initialiser of the iterator to manipulate
484 ($iter:expr, $k:expr,
485 // whether we are looking for the lower or upper bound.
486 $is_lower_bound:expr) => {
488 let mut iter = $iter;
490 if !iter.node.is_null() {
491 let node_k = unsafe {&(*iter.node).key};
492 match $k.cmp(node_k) {
493 Less => iter.traverse_left(),
494 Greater => iter.traverse_right(),
497 iter.traverse_complete();
500 iter.traverse_right()
505 iter.traverse_complete();
514 impl<K: Ord, V> TreeMap<K, V> {
515 /// Get a lazy iterator that should be initialized using
516 /// `traverse_left`/`traverse_right`/`traverse_complete`.
517 fn iter_for_traversal<'a>(&'a self) -> Entries<'a, K, V> {
520 node: deref(&self.root),
522 remaining_max: self.length
526 /// Return a lazy iterator to the first key-value pair whose key is not less than `k`
527 /// If all keys in map are less than `k` an empty iterator is returned.
532 /// use std::collections::TreeMap;
534 /// let mut map = TreeMap::new();
535 /// map.insert(2i, "a");
536 /// map.insert(4, "b");
537 /// map.insert(6, "c");
538 /// map.insert(8, "d");
540 /// assert_eq!(map.lower_bound(&4).next(), Some((&4, &"b")));
541 /// assert_eq!(map.lower_bound(&5).next(), Some((&6, &"c")));
542 /// assert_eq!(map.lower_bound(&10).next(), None);
544 pub fn lower_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
545 bound_setup!(self.iter_for_traversal(), k, true)
548 /// Return a lazy iterator to the first key-value pair whose key is greater than `k`
549 /// If all keys in map are less than or equal to `k` an empty iterator is returned.
554 /// use std::collections::TreeMap;
556 /// let mut map = TreeMap::new();
557 /// map.insert(2i, "a");
558 /// map.insert(4, "b");
559 /// map.insert(6, "c");
560 /// map.insert(8, "d");
562 /// assert_eq!(map.upper_bound(&4).next(), Some((&6, &"c")));
563 /// assert_eq!(map.upper_bound(&5).next(), Some((&6, &"c")));
564 /// assert_eq!(map.upper_bound(&10).next(), None);
566 pub fn upper_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
567 bound_setup!(self.iter_for_traversal(), k, false)
570 /// Get a lazy iterator that should be initialized using
571 /// `traverse_left`/`traverse_right`/`traverse_complete`.
572 fn mut_iter_for_traversal<'a>(&'a mut self) -> MutEntries<'a, K, V> {
575 node: mut_deref(&mut self.root),
577 remaining_max: self.length
581 /// Return a lazy value iterator to the first key-value pair (with
582 /// the value being mutable) whose key is not less than `k`.
584 /// If all keys in map are less than `k` an empty iterator is
590 /// use std::collections::TreeMap;
592 /// let mut map = TreeMap::new();
593 /// map.insert(2i, "a");
594 /// map.insert(4, "b");
595 /// map.insert(6, "c");
596 /// map.insert(8, "d");
598 /// assert_eq!(map.mut_lower_bound(&4).next(), Some((&4, &mut "b")));
599 /// assert_eq!(map.mut_lower_bound(&5).next(), Some((&6, &mut "c")));
600 /// assert_eq!(map.mut_lower_bound(&10).next(), None);
602 /// for (key, value) in map.mut_lower_bound(&4) {
603 /// *value = "changed";
606 /// assert_eq!(map.find(&2), Some(&"a"));
607 /// assert_eq!(map.find(&4), Some(&"changed"));
608 /// assert_eq!(map.find(&6), Some(&"changed"));
609 /// assert_eq!(map.find(&8), Some(&"changed"));
611 pub fn mut_lower_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
612 bound_setup!(self.mut_iter_for_traversal(), k, true)
615 /// Return a lazy iterator to the first key-value pair (with the
616 /// value being mutable) whose key is greater than `k`.
618 /// If all keys in map are less than or equal to `k` an empty iterator
624 /// use std::collections::TreeMap;
626 /// let mut map = TreeMap::new();
627 /// map.insert(2i, "a");
628 /// map.insert(4, "b");
629 /// map.insert(6, "c");
630 /// map.insert(8, "d");
632 /// assert_eq!(map.mut_upper_bound(&4).next(), Some((&6, &mut "c")));
633 /// assert_eq!(map.mut_upper_bound(&5).next(), Some((&6, &mut "c")));
634 /// assert_eq!(map.mut_upper_bound(&10).next(), None);
636 /// for (key, value) in map.mut_upper_bound(&4) {
637 /// *value = "changed";
640 /// assert_eq!(map.find(&2), Some(&"a"));
641 /// assert_eq!(map.find(&4), Some(&"b"));
642 /// assert_eq!(map.find(&6), Some(&"changed"));
643 /// assert_eq!(map.find(&8), Some(&"changed"));
645 pub fn mut_upper_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
646 bound_setup!(self.mut_iter_for_traversal(), k, false)
650 /// Lazy forward iterator over a map
651 pub struct Entries<'a, K, V> {
652 stack: Vec<&'a TreeNode<K, V>>,
653 // See the comment on MutEntries; this is just to allow
654 // code-sharing (for this immutable-values iterator it *could* very
655 // well be Option<&'a TreeNode<K,V>>).
656 node: *const TreeNode<K, V>,
661 /// Lazy backward iterator over a map
662 pub struct RevEntries<'a, K, V> {
663 iter: Entries<'a, K, V>,
666 /// Lazy forward iterator over a map that allows for the mutation of
668 pub struct MutEntries<'a, K, V> {
669 stack: Vec<&'a mut TreeNode<K, V>>,
670 // Unfortunately, we require some unsafe-ness to get around the
671 // fact that we would be storing a reference *into* one of the
672 // nodes in the stack.
674 // As far as the compiler knows, this would let us invalidate the
675 // reference by assigning a new value to this node's position in
676 // its parent, which would cause this current one to be
677 // deallocated so this reference would be invalid. (i.e. the
678 // compilers complaints are 100% correct.)
680 // However, as far as you humans reading this code know (or are
681 // about to know, if you haven't read far enough down yet), we are
682 // only reading from the TreeNode.{left,right} fields. the only
683 // thing that is ever mutated is the .value field (although any
684 // actual mutation that happens is done externally, by the
685 // iterator consumer). So, don't be so concerned, rustc, we've got
688 // (This field can legitimately be null.)
689 node: *mut TreeNode<K, V>,
694 /// Lazy backward iterator over a map
695 pub struct RevMutEntries<'a, K, V> {
696 iter: MutEntries<'a, K, V>,
700 /// TreeMap keys iterator
701 pub type Keys<'a, K, V> =
702 iter::Map<'static, (&'a K, &'a V), &'a K, Entries<'a, K, V>>;
704 /// TreeMap values iterator
705 pub type Values<'a, K, V> =
706 iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
709 // FIXME #5846 we want to be able to choose between &x and &mut x
710 // (with many different `x`) below, so we need to optionally pass mut
711 // as a tt, but the only thing we can do with a `tt` is pass them to
712 // other macros, so this takes the `& <mutability> <operand>` token
713 // sequence and forces their evaluation as an expression.
714 macro_rules! addr { ($e:expr) => { $e }}
715 // putting an optional mut into type signatures
716 macro_rules! item { ($i:item) => { $i }}
718 macro_rules! define_iterator {
722 // the function to go from &m Option<Box<TreeNode>> to *m TreeNode
723 deref = $deref:ident,
725 // see comment on `addr!`, this is just an optional `mut`, but
726 // there's no support for 0-or-1 repeats.
727 addr_mut = $($addr_mut:tt)*
729 // private methods on the forward iterator (item!() for the
730 // addr_mut in the next_ return value)
731 item!(impl<'a, K, V> $name<'a, K, V> {
733 fn next_(&mut self, forward: bool) -> Option<(&'a K, &'a $($addr_mut)* V)> {
734 while !self.stack.is_empty() || !self.node.is_null() {
735 if !self.node.is_null() {
736 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
738 let next_node = if forward {
739 addr!(& $($addr_mut)* node.left)
741 addr!(& $($addr_mut)* node.right)
743 self.node = $deref(next_node);
745 self.stack.push(node);
747 let node = self.stack.pop().unwrap();
748 let next_node = if forward {
749 addr!(& $($addr_mut)* node.right)
751 addr!(& $($addr_mut)* node.left)
753 self.node = $deref(next_node);
754 self.remaining_max -= 1;
755 if self.remaining_min > 0 {
756 self.remaining_min -= 1;
758 return Some((&node.key, addr!(& $($addr_mut)* node.value)));
764 /// traverse_left, traverse_right and traverse_complete are
765 /// used to initialize Entries/MutEntries
766 /// pointing to element inside tree structure.
768 /// They should be used in following manner:
769 /// - create iterator using TreeMap::[mut_]iter_for_traversal
770 /// - find required node using `traverse_left`/`traverse_right`
771 /// (current node is `Entries::node` field)
772 /// - complete initialization with `traverse_complete`
774 /// After this, iteration will start from `self.node`. If
775 /// `self.node` is None iteration will start from last
776 /// node from which we traversed left.
778 fn traverse_left(&mut self) {
779 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
780 self.node = $deref(addr!(& $($addr_mut)* node.left));
781 self.stack.push(node);
785 fn traverse_right(&mut self) {
786 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
787 self.node = $deref(addr!(& $($addr_mut)* node.right));
791 fn traverse_complete(&mut self) {
792 if !self.node.is_null() {
794 self.stack.push(addr!(& $($addr_mut)* *self.node));
796 self.node = ptr::RawPtr::null();
801 // the forward Iterator impl.
802 item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $name<'a, K, V> {
803 /// Advance the iterator to the next node (in order) and return a
804 /// tuple with a reference to the key and value. If there are no
805 /// more nodes, return `None`.
806 fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
811 fn size_hint(&self) -> (uint, Option<uint>) {
812 (self.remaining_min, Some(self.remaining_max))
816 // the reverse Iterator impl.
817 item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $rev_name<'a, K, V> {
818 fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
819 self.iter.next_(false)
823 fn size_hint(&self) -> (uint, Option<uint>) {
824 self.iter.size_hint()
828 } // end of define_iterator
835 // immutable, so no mut
846 fn deref<'a, K, V>(node: &'a Option<Box<TreeNode<K, V>>>) -> *const TreeNode<K, V> {
849 let n: &TreeNode<K, V> = &**n;
850 n as *const TreeNode<K, V>
856 fn mut_deref<K, V>(x: &mut Option<Box<TreeNode<K, V>>>)
857 -> *mut TreeNode<K, V> {
860 let n: &mut TreeNode<K, V> = &mut **n;
861 n as *mut TreeNode<K, V>
863 None => ptr::mut_null()
869 /// Lazy forward iterator over a map that consumes the map while iterating
870 pub struct MoveEntries<K, V> {
871 stack: Vec<TreeNode<K, V>>,
875 impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
877 fn next(&mut self) -> Option<(K, V)> {
878 while !self.stack.is_empty() {
885 } = self.stack.pop().unwrap();
897 self.stack.push(left);
901 Some(box right) => self.stack.push(right),
905 return Some((key, value))
913 fn size_hint(&self) -> (uint, Option<uint>) {
914 (self.remaining, Some(self.remaining))
919 impl<'a, T> Iterator<&'a T> for SetItems<'a, T> {
921 fn next(&mut self) -> Option<&'a T> {
922 self.iter.next().map(|(value, _)| value)
926 impl<'a, T> Iterator<&'a T> for RevSetItems<'a, T> {
928 fn next(&mut self) -> Option<&'a T> {
929 self.iter.next().map(|(value, _)| value)
933 /// A implementation of the `Set` trait on top of the `TreeMap` container. The
934 /// only requirement is that the type of the elements contained ascribes to the
940 /// use std::collections::TreeSet;
942 /// let mut set = TreeSet::new();
948 /// for i in set.iter() {
949 /// println!("{}", i) // prints 1, then 2, then 3
954 /// if !set.contains(&3) {
955 /// println!("set does not contain a 3 anymore");
959 /// The easiest way to use `TreeSet` with a custom type is to implement `Ord`.
960 /// We must also implement `PartialEq`, `Eq` and `PartialOrd`.
963 /// use std::collections::TreeSet;
965 /// // We need `Eq` and `PartialEq`, these can be derived.
966 /// #[deriving(Eq, PartialEq)]
967 /// struct Troll<'a> {
972 /// // Implement `Ord` and sort trolls by level.
973 /// impl<'a> Ord for Troll<'a> {
974 /// fn cmp(&self, other: &Troll) -> Ordering {
975 /// // If we swap `self` and `other`, we get descended ordering.
976 /// self.level.cmp(&other.level)
980 /// // `PartialOrd` needs to be implemented as well.
981 /// impl<'a> PartialOrd for Troll<'a> {
982 /// fn partial_cmp(&self, other: &Troll) -> Option<Ordering> {
983 /// Some(self.cmp(other))
987 /// let mut trolls = TreeSet::new();
989 /// trolls.insert(Troll { name: "Orgarr", level: 2 });
990 /// trolls.insert(Troll { name: "Blargarr", level: 3 });
991 /// trolls.insert(Troll { name: "Kron the Smelly One", level: 4 });
992 /// trolls.insert(Troll { name: "Wartilda", level: 1 });
994 /// println!("You are facing {} trolls!", trolls.len());
996 /// // Print the trolls, ordered by level with smallest level first
997 /// for x in trolls.iter() {
998 /// println!("level {}: {}!", x.level, x.name);
1001 /// // Kill all trolls
1003 /// assert_eq!(trolls.len(), 0);
1006 pub struct TreeSet<T> {
1010 impl<T: PartialEq + Ord> PartialEq for TreeSet<T> {
1012 fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
1015 impl<T: Ord> PartialOrd for TreeSet<T> {
1017 fn partial_cmp(&self, other: &TreeSet<T>) -> Option<Ordering> {
1018 self.map.partial_cmp(&other.map)
1022 impl<T: Ord + Show> Show for TreeSet<T> {
1023 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1024 try!(write!(f, "{{"));
1026 for (i, x) in self.iter().enumerate() {
1027 if i != 0 { try!(write!(f, ", ")); }
1028 try!(write!(f, "{}", *x));
1035 impl<T: Ord> Collection for TreeSet<T> {
1037 fn len(&self) -> uint { self.map.len() }
1040 impl<T: Ord> Mutable for TreeSet<T> {
1042 fn clear(&mut self) { self.map.clear() }
1045 impl<T: Ord> Set<T> for TreeSet<T> {
1047 fn contains(&self, value: &T) -> bool {
1048 self.map.contains_key(value)
1051 fn is_disjoint(&self, other: &TreeSet<T>) -> bool {
1052 self.intersection(other).next().is_none()
1055 fn is_subset(&self, other: &TreeSet<T>) -> bool {
1056 let mut x = self.iter();
1057 let mut y = other.iter();
1058 let mut a = x.next();
1059 let mut b = y.next();
1065 let a1 = a.unwrap();
1066 let b1 = b.unwrap();
1070 Greater => return false,
1071 Equal => a = x.next(),
1080 impl<T: Ord> MutableSet<T> for TreeSet<T> {
1082 fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
1085 fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
1088 impl<T: Ord> Default for TreeSet<T> {
1090 fn default() -> TreeSet<T> { TreeSet::new() }
1093 impl<T: Ord> TreeSet<T> {
1094 /// Create an empty `TreeSet`.
1099 /// use std::collections::TreeSet;
1100 /// let mut set: TreeSet<int> = TreeSet::new();
1103 pub fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
1105 /// Get a lazy iterator over the values in the set, in ascending order.
1110 /// use std::collections::TreeSet;
1111 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
1113 /// // Will print in ascending order.
1114 /// for x in set.iter() {
1115 /// println!("{}", x);
1119 pub fn iter<'a>(&'a self) -> SetItems<'a, T> {
1120 SetItems{iter: self.map.iter()}
1123 /// Get a lazy iterator over the values in the set, in descending order.
1128 /// use std::collections::TreeSet;
1129 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
1131 /// // Will print in descending order.
1132 /// for x in set.rev_iter() {
1133 /// println!("{}", x);
1137 pub fn rev_iter<'a>(&'a self) -> RevSetItems<'a, T> {
1138 RevSetItems{iter: self.map.rev_iter()}
1141 /// Creates a consuming iterator, that is, one that moves each value out of the
1142 /// set in ascending order. The set cannot be used after calling this.
1147 /// use std::collections::TreeSet;
1148 /// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
1150 /// // Not possible with a regular `.iter()`
1151 /// let v: Vec<int> = set.move_iter().collect();
1152 /// assert_eq!(v, vec![1, 2, 3, 4, 5]);
1155 pub fn move_iter(self) -> MoveSetItems<T> {
1156 self.map.move_iter().map(|(value, _)| value)
1159 /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal).
1160 /// If all elements in the set are less than `v` empty iterator is returned.
1165 /// use std::collections::TreeSet;
1166 /// let set: TreeSet<int> = [2, 4, 6, 8].iter().map(|&x| x).collect();
1168 /// assert_eq!(set.lower_bound(&4).next(), Some(&4));
1169 /// assert_eq!(set.lower_bound(&5).next(), Some(&6));
1170 /// assert_eq!(set.lower_bound(&10).next(), None);
1173 pub fn lower_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
1174 SetItems{iter: self.map.lower_bound(v)}
1177 /// Get a lazy iterator pointing to the first value greater than `v`.
1178 /// If all elements in the set are less than or equal to `v` an
1179 /// empty iterator is returned.
1184 /// use std::collections::TreeSet;
1185 /// let set: TreeSet<int> = [2, 4, 6, 8].iter().map(|&x| x).collect();
1187 /// assert_eq!(set.upper_bound(&4).next(), Some(&6));
1188 /// assert_eq!(set.upper_bound(&5).next(), Some(&6));
1189 /// assert_eq!(set.upper_bound(&10).next(), None);
1192 pub fn upper_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
1193 SetItems{iter: self.map.upper_bound(v)}
1196 /// Visit the values representing the difference, in ascending order.
1201 /// use std::collections::TreeSet;
1203 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
1204 /// let b: TreeSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
1206 /// // Can be seen as `a - b`.
1207 /// for x in a.difference(&b) {
1208 /// println!("{}", x); // Print 1 then 2
1211 /// let diff: TreeSet<int> = a.difference(&b).map(|&x| x).collect();
1212 /// assert_eq!(diff, [1, 2].iter().map(|&x| x).collect());
1214 /// // Note that difference is not symmetric,
1215 /// // and `b - a` means something else:
1216 /// let diff: TreeSet<int> = b.difference(&a).map(|&x| x).collect();
1217 /// assert_eq!(diff, [4, 5].iter().map(|&x| x).collect());
1219 pub fn difference<'a>(&'a self, other: &'a TreeSet<T>) -> DifferenceItems<'a, T> {
1220 DifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
1223 /// Visit the values representing the symmetric difference, in ascending order.
1228 /// use std::collections::TreeSet;
1230 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
1231 /// let b: TreeSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
1233 /// // Print 1, 2, 4, 5 in ascending order.
1234 /// for x in a.symmetric_difference(&b) {
1235 /// println!("{}", x);
1238 /// let diff1: TreeSet<int> = a.symmetric_difference(&b).map(|&x| x).collect();
1239 /// let diff2: TreeSet<int> = b.symmetric_difference(&a).map(|&x| x).collect();
1241 /// assert_eq!(diff1, diff2);
1242 /// assert_eq!(diff1, [1, 2, 4, 5].iter().map(|&x| x).collect());
1244 pub fn symmetric_difference<'a>(&'a self, other: &'a TreeSet<T>)
1245 -> SymDifferenceItems<'a, T> {
1246 SymDifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
1249 /// Visit the values representing the intersection, in ascending order.
1254 /// use std::collections::TreeSet;
1256 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
1257 /// let b: TreeSet<int> = [2, 3, 4].iter().map(|&x| x).collect();
1259 /// // Print 2, 3 in ascending order.
1260 /// for x in a.intersection(&b) {
1261 /// println!("{}", x);
1264 /// let diff: TreeSet<int> = a.intersection(&b).map(|&x| x).collect();
1265 /// assert_eq!(diff, [2, 3].iter().map(|&x| x).collect());
1267 pub fn intersection<'a>(&'a self, other: &'a TreeSet<T>)
1268 -> IntersectionItems<'a, T> {
1269 IntersectionItems{a: self.iter().peekable(), b: other.iter().peekable()}
1272 /// Visit the values representing the union, in ascending order.
1277 /// use std::collections::TreeSet;
1279 /// let a: TreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
1280 /// let b: TreeSet<int> = [3, 4, 5].iter().map(|&x| x).collect();
1282 /// // Print 1, 2, 3, 4, 5 in ascending order.
1283 /// for x in a.union(&b) {
1284 /// println!("{}", x);
1287 /// let diff: TreeSet<int> = a.union(&b).map(|&x| x).collect();
1288 /// assert_eq!(diff, [1, 2, 3, 4, 5].iter().map(|&x| x).collect());
1290 pub fn union<'a>(&'a self, other: &'a TreeSet<T>) -> UnionItems<'a, T> {
1291 UnionItems{a: self.iter().peekable(), b: other.iter().peekable()}
1295 /// Lazy forward iterator over a set
1296 pub struct SetItems<'a, T> {
1297 iter: Entries<'a, T, ()>
1300 /// Lazy backward iterator over a set
1301 pub struct RevSetItems<'a, T> {
1302 iter: RevEntries<'a, T, ()>
1305 /// Lazy forward iterator over a set that consumes the set while iterating
1306 pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
1308 /// Lazy iterator producing elements in the set difference (in-order)
1309 pub struct DifferenceItems<'a, T> {
1310 a: Peekable<&'a T, SetItems<'a, T>>,
1311 b: Peekable<&'a T, SetItems<'a, T>>,
1314 /// Lazy iterator producing elements in the set symmetric difference (in-order)
1315 pub struct SymDifferenceItems<'a, T> {
1316 a: Peekable<&'a T, SetItems<'a, T>>,
1317 b: Peekable<&'a T, SetItems<'a, T>>,
1320 /// Lazy iterator producing elements in the set intersection (in-order)
1321 pub struct IntersectionItems<'a, T> {
1322 a: Peekable<&'a T, SetItems<'a, T>>,
1323 b: Peekable<&'a T, SetItems<'a, T>>,
1326 /// Lazy iterator producing elements in the set union (in-order)
1327 pub struct UnionItems<'a, T> {
1328 a: Peekable<&'a T, SetItems<'a, T>>,
1329 b: Peekable<&'a T, SetItems<'a, T>>,
1332 /// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
1333 fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
1334 short: Ordering, long: Ordering) -> Ordering {
1336 (None , _ ) => short,
1337 (_ , None ) => long,
1338 (Some(x1), Some(y1)) => x1.cmp(y1),
1342 impl<'a, T: Ord> Iterator<&'a T> for DifferenceItems<'a, T> {
1343 fn next(&mut self) -> Option<&'a T> {
1345 match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
1346 Less => return self.a.next(),
1347 Equal => { self.a.next(); self.b.next(); }
1348 Greater => { self.b.next(); }
1354 impl<'a, T: Ord> Iterator<&'a T> for SymDifferenceItems<'a, T> {
1355 fn next(&mut self) -> Option<&'a T> {
1357 match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
1358 Less => return self.a.next(),
1359 Equal => { self.a.next(); self.b.next(); }
1360 Greater => return self.b.next(),
1366 impl<'a, T: Ord> Iterator<&'a T> for IntersectionItems<'a, T> {
1367 fn next(&mut self) -> Option<&'a T> {
1369 let o_cmp = match (self.a.peek(), self.b.peek()) {
1370 (None , _ ) => None,
1371 (_ , None ) => None,
1372 (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
1375 None => return None,
1376 Some(Less) => { self.a.next(); }
1377 Some(Equal) => { self.b.next(); return self.a.next() }
1378 Some(Greater) => { self.b.next(); }
1384 impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
1385 fn next(&mut self) -> Option<&'a T> {
1387 match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
1388 Less => return self.a.next(),
1389 Equal => { self.b.next(); return self.a.next() }
1390 Greater => return self.b.next(),
1397 // Nodes keep track of their level in the tree, starting at 1 in the
1398 // leaves and with a red child sharing the level of the parent.
1400 struct TreeNode<K, V> {
1403 left: Option<Box<TreeNode<K, V>>>,
1404 right: Option<Box<TreeNode<K, V>>>,
1408 impl<K: Ord, V> TreeNode<K, V> {
1409 /// Creates a new tree node.
1411 pub fn new(key: K, value: V) -> TreeNode<K, V> {
1412 TreeNode{key: key, value: value, left: None, right: None, level: 1}
1416 // Remove left horizontal link by rotating right
1417 fn skew<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
1418 if node.left.as_ref().map_or(false, |x| x.level == node.level) {
1419 let mut save = node.left.take_unwrap();
1420 swap(&mut node.left, &mut save.right); // save.right now None
1421 swap(node, &mut save);
1422 node.right = Some(save);
1426 // Remove dual horizontal link by rotating left and increasing level of
1428 fn split<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
1429 if node.right.as_ref().map_or(false,
1430 |x| x.right.as_ref().map_or(false, |y| y.level == node.level)) {
1431 let mut save = node.right.take_unwrap();
1432 swap(&mut node.right, &mut save.left); // save.left now None
1434 swap(node, &mut save);
1435 node.left = Some(save);
1439 // Next 2 functions have the same convention: comparator gets
1440 // at input current key and returns search_key cmp cur_key
1441 // (i.e. search_key.cmp(&cur_key))
1442 fn tree_find_with<'r, K, V>(node: &'r Option<Box<TreeNode<K, V>>>,
1443 f: |&K| -> Ordering) -> Option<&'r V> {
1444 let mut current: &'r Option<Box<TreeNode<K, V>>> = node;
1449 Less => current = &r.left,
1450 Greater => current = &r.right,
1451 Equal => return Some(&r.value)
1459 // See comments above tree_find_with
1460 fn tree_find_mut_with<'r, K, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
1461 f: |&K| -> Ordering) -> Option<&'r mut V> {
1463 let mut current = node;
1465 let temp = current; // hack to appease borrowck
1467 Some(ref mut r) => {
1469 Less => current = &mut r.left,
1470 Greater => current = &mut r.right,
1471 Equal => return Some(&mut r.value)
1479 fn insert<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
1480 key: K, value: V) -> Option<V> {
1482 Some(ref mut save) => {
1483 match key.cmp(&save.key) {
1485 let inserted = insert(&mut save.left, key, value);
1491 let inserted = insert(&mut save.right, key, value);
1498 Some(replace(&mut save.value, value))
1503 *node = Some(box TreeNode::new(key, value));
1509 fn remove<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
1510 key: &K) -> Option<V> {
1511 fn heir_swap<K: Ord, V>(node: &mut Box<TreeNode<K, V>>,
1512 child: &mut Option<Box<TreeNode<K, V>>>) {
1513 // *could* be done without recursion, but it won't borrow check
1514 for x in child.mut_iter() {
1515 if x.right.is_some() {
1516 heir_swap(node, &mut x.right);
1518 swap(&mut node.key, &mut x.key);
1519 swap(&mut node.value, &mut x.value);
1526 return None; // bottom of tree
1528 Some(ref mut save) => {
1529 let (ret, rebalance) = match key.cmp(&save.key) {
1530 Less => (remove(&mut save.left, key), true),
1531 Greater => (remove(&mut save.right, key), true),
1533 if save.left.is_some() {
1534 if save.right.is_some() {
1535 let mut left = save.left.take_unwrap();
1536 if left.right.is_some() {
1537 heir_swap(save, &mut left.right);
1539 swap(&mut save.key, &mut left.key);
1540 swap(&mut save.value, &mut left.value);
1542 save.left = Some(left);
1543 (remove(&mut save.left, key), true)
1545 let new = save.left.take_unwrap();
1546 let box TreeNode{value, ..} = replace(save, new);
1547 *save = save.left.take_unwrap();
1550 } else if save.right.is_some() {
1551 let new = save.right.take_unwrap();
1552 let box TreeNode{value, ..} = replace(save, new);
1561 let left_level = save.left.as_ref().map_or(0, |x| x.level);
1562 let right_level = save.right.as_ref().map_or(0, |x| x.level);
1564 // re-balance, if necessary
1565 if left_level < save.level - 1 || right_level < save.level - 1 {
1568 if right_level > save.level {
1569 for x in save.right.mut_iter() { x.level = save.level }
1574 for right in save.right.mut_iter() {
1576 for x in right.right.mut_iter() { skew(x) }
1580 for x in save.right.mut_iter() { split(x) }
1587 return match node.take() {
1588 Some(box TreeNode{value, ..}) => Some(value), None => fail!()
1592 impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
1593 fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
1594 let mut map = TreeMap::new();
1600 impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
1602 fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
1603 for (k, v) in iter {
1609 impl<S: Writer, K: Ord + Hash<S>, V: Hash<S>> Hash<S> for TreeMap<K, V> {
1610 fn hash(&self, state: &mut S) {
1611 for elt in self.iter() {
1617 impl<T: Ord> FromIterator<T> for TreeSet<T> {
1618 fn from_iter<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
1619 let mut set = TreeSet::new();
1625 impl<T: Ord> Extendable<T> for TreeSet<T> {
1627 fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
1634 impl<S: Writer, T: Ord + Hash<S>> Hash<S> for TreeSet<T> {
1635 fn hash(&self, state: &mut S) {
1636 for elt in self.iter() {
1644 use std::prelude::*;
1648 use {Map, MutableMap, Mutable, MutableSeq};
1649 use super::{TreeMap, TreeNode};
1653 let m: TreeMap<int,int> = TreeMap::new();
1654 assert!(m.find(&5) == None);
1658 fn find_not_found() {
1659 let mut m = TreeMap::new();
1660 assert!(m.insert(1i, 2i));
1661 assert!(m.insert(5i, 3i));
1662 assert!(m.insert(9i, 3i));
1663 assert_eq!(m.find(&2), None);
1667 fn find_with_empty() {
1668 let m: TreeMap<&'static str,int> = TreeMap::new();
1669 assert!(m.find_with(|k| "test".cmp(k)) == None);
1673 fn find_with_not_found() {
1674 let mut m = TreeMap::new();
1675 assert!(m.insert("test1", 2i));
1676 assert!(m.insert("test2", 3i));
1677 assert!(m.insert("test3", 3i));
1678 assert_eq!(m.find_with(|k| "test4".cmp(k)), None);
1682 fn find_with_found() {
1683 let mut m = TreeMap::new();
1684 assert!(m.insert("test1", 2i));
1685 assert!(m.insert("test2", 3i));
1686 assert!(m.insert("test3", 4i));
1687 assert_eq!(m.find_with(|k| "test2".cmp(k)), Some(&3i));
1691 fn test_find_mut() {
1692 let mut m = TreeMap::new();
1693 assert!(m.insert(1i, 12i));
1694 assert!(m.insert(2, 8));
1695 assert!(m.insert(5, 14));
1697 match m.find_mut(&5) {
1698 None => fail!(), Some(x) => *x = new
1700 assert_eq!(m.find(&5), Some(&new));
1704 fn test_find_with_mut() {
1705 let mut m = TreeMap::new();
1706 assert!(m.insert("t1", 12i));
1707 assert!(m.insert("t2", 8));
1708 assert!(m.insert("t5", 14));
1710 match m.find_mut_with(|k| "t5".cmp(k)) {
1711 None => fail!(), Some(x) => *x = new
1713 assert_eq!(m.find_with(|k| "t5".cmp(k)), Some(&new));
1717 fn insert_replace() {
1718 let mut m = TreeMap::new();
1719 assert!(m.insert(5i, 2i));
1720 assert!(m.insert(2, 9));
1721 assert!(!m.insert(2, 11));
1722 assert_eq!(m.find(&2).unwrap(), &11);
1727 let mut m = TreeMap::new();
1729 assert!(m.insert(5i, 11i));
1730 assert!(m.insert(12, -3));
1731 assert!(m.insert(19, 2));
1733 assert!(m.find(&5).is_none());
1734 assert!(m.find(&12).is_none());
1735 assert!(m.find(&19).is_none());
1736 assert!(m.is_empty());
1741 let mut m = TreeMap::new();
1743 let k1 = "foo".as_bytes();
1744 let k2 = "bar".as_bytes();
1745 let v1 = "baz".as_bytes();
1746 let v2 = "foobar".as_bytes();
1748 m.insert(k1.clone(), v1.clone());
1749 m.insert(k2.clone(), v2.clone());
1751 assert_eq!(m.find(&k2), Some(&v2));
1752 assert_eq!(m.find(&k1), Some(&v1));
1755 fn check_equal<K: PartialEq + Ord, V: PartialEq>(ctrl: &[(K, V)],
1756 map: &TreeMap<K, V>) {
1757 assert_eq!(ctrl.is_empty(), map.is_empty());
1758 for x in ctrl.iter() {
1759 let &(ref k, ref v) = x;
1760 assert!(map.find(k).unwrap() == v)
1762 for (map_k, map_v) in map.iter() {
1763 let mut found = false;
1764 for x in ctrl.iter() {
1765 let &(ref ctrl_k, ref ctrl_v) = x;
1766 if *map_k == *ctrl_k {
1767 assert!(*map_v == *ctrl_v);
1776 fn check_left<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1777 parent: &Box<TreeNode<K, V>>) {
1780 assert_eq!(r.key.cmp(&parent.key), Less);
1781 assert!(r.level == parent.level - 1); // left is black
1782 check_left(&r.left, r);
1783 check_right(&r.right, r, false);
1785 None => assert!(parent.level == 1) // parent is leaf
1789 fn check_right<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1790 parent: &Box<TreeNode<K, V>>,
1794 assert_eq!(r.key.cmp(&parent.key), Greater);
1795 let red = r.level == parent.level;
1796 if parent_red { assert!(!red) } // no dual horizontal links
1797 // Right red or black
1798 assert!(red || r.level == parent.level - 1);
1799 check_left(&r.left, r);
1800 check_right(&r.right, r, red);
1802 None => assert!(parent.level == 1) // parent is leaf
1806 fn check_structure<K: Ord, V>(map: &TreeMap<K, V>) {
1809 check_left(&r.left, r);
1810 check_right(&r.right, r, false);
1817 fn test_rand_int() {
1818 let mut map: TreeMap<int,int> = TreeMap::new();
1819 let mut ctrl = vec![];
1821 check_equal(ctrl.as_slice(), &map);
1822 assert!(map.find(&5).is_none());
1824 let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(&[42]);
1826 for _ in range(0u, 3) {
1827 for _ in range(0u, 90) {
1830 if !ctrl.iter().any(|x| x == &(k, v)) {
1831 assert!(map.insert(k, v));
1833 check_structure(&map);
1834 check_equal(ctrl.as_slice(), &map);
1838 for _ in range(0u, 30) {
1839 let r = rng.gen_range(0, ctrl.len());
1840 let (key, _) = ctrl.remove(r).unwrap();
1841 assert!(map.remove(&key));
1842 check_structure(&map);
1843 check_equal(ctrl.as_slice(), &map);
1850 let mut m = TreeMap::new();
1851 assert!(m.insert(3i, 6i));
1852 assert_eq!(m.len(), 1);
1853 assert!(m.insert(0, 0));
1854 assert_eq!(m.len(), 2);
1855 assert!(m.insert(4, 8));
1856 assert_eq!(m.len(), 3);
1857 assert!(m.remove(&3));
1858 assert_eq!(m.len(), 2);
1859 assert!(!m.remove(&5));
1860 assert_eq!(m.len(), 2);
1861 assert!(m.insert(2, 4));
1862 assert_eq!(m.len(), 3);
1863 assert!(m.insert(1, 2));
1864 assert_eq!(m.len(), 4);
1868 fn test_iterator() {
1869 let mut m = TreeMap::new();
1871 assert!(m.insert(3i, 6i));
1872 assert!(m.insert(0, 0));
1873 assert!(m.insert(4, 8));
1874 assert!(m.insert(2, 4));
1875 assert!(m.insert(1, 2));
1878 for (k, v) in m.iter() {
1880 assert_eq!(*v, n * 2);
1887 fn test_interval_iteration() {
1888 let mut m = TreeMap::new();
1889 for i in range(1i, 100i) {
1890 assert!(m.insert(i * 2, i * 4));
1893 for i in range(1i, 198i) {
1894 let mut lb_it = m.lower_bound(&i);
1895 let (&k, &v) = lb_it.next().unwrap();
1898 assert_eq!(lb * 2, v);
1900 let mut ub_it = m.upper_bound(&i);
1901 let (&k, &v) = ub_it.next().unwrap();
1902 let ub = i + 2 - i % 2;
1904 assert_eq!(ub * 2, v);
1906 let mut end_it = m.lower_bound(&199);
1907 assert_eq!(end_it.next(), None);
1911 fn test_rev_iter() {
1912 let mut m = TreeMap::new();
1914 assert!(m.insert(3i, 6i));
1915 assert!(m.insert(0, 0));
1916 assert!(m.insert(4, 8));
1917 assert!(m.insert(2, 4));
1918 assert!(m.insert(1, 2));
1921 for (k, v) in m.rev_iter() {
1923 assert_eq!(*v, n * 2);
1929 fn test_mut_iter() {
1930 let mut m = TreeMap::new();
1931 for i in range(0u, 10) {
1932 assert!(m.insert(i, 100 * i));
1935 for (i, (&k, v)) in m.mut_iter().enumerate() {
1936 *v += k * 10 + i; // 000 + 00 + 0, 100 + 10 + 1, ...
1939 for (&k, &v) in m.iter() {
1940 assert_eq!(v, 111 * k);
1944 fn test_mut_rev_iter() {
1945 let mut m = TreeMap::new();
1946 for i in range(0u, 10) {
1947 assert!(m.insert(i, 100 * i));
1950 for (i, (&k, v)) in m.mut_rev_iter().enumerate() {
1951 *v += k * 10 + (9 - i); // 900 + 90 + (9 - 0), 800 + 80 + (9 - 1), ...
1954 for (&k, &v) in m.iter() {
1955 assert_eq!(v, 111 * k);
1960 fn test_mut_interval_iter() {
1961 let mut m_lower = TreeMap::new();
1962 let mut m_upper = TreeMap::new();
1963 for i in range(1i, 100i) {
1964 assert!(m_lower.insert(i * 2, i * 4));
1965 assert!(m_upper.insert(i * 2, i * 4));
1968 for i in range(1i, 199) {
1969 let mut lb_it = m_lower.mut_lower_bound(&i);
1970 let (&k, v) = lb_it.next().unwrap();
1975 for i in range(0i, 198) {
1976 let mut ub_it = m_upper.mut_upper_bound(&i);
1977 let (&k, v) = ub_it.next().unwrap();
1978 let ub = i + 2 - i % 2;
1983 assert!(m_lower.mut_lower_bound(&199).next().is_none());
1985 assert!(m_upper.mut_upper_bound(&198).next().is_none());
1987 assert!(m_lower.iter().all(|(_, &x)| x == 0));
1988 assert!(m_upper.iter().all(|(_, &x)| x == 0));
1993 let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
1994 let map = vec.move_iter().collect::<TreeMap<int, char>>();
1995 let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
1996 assert_eq!(keys.len(), 3);
1997 assert!(keys.contains(&1));
1998 assert!(keys.contains(&2));
1999 assert!(keys.contains(&3));
2004 let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
2005 let map = vec.move_iter().collect::<TreeMap<int, char>>();
2006 let values = map.values().map(|&v| v).collect::<Vec<char>>();
2007 assert_eq!(values.len(), 3);
2008 assert!(values.contains(&'a'));
2009 assert!(values.contains(&'b'));
2010 assert!(values.contains(&'c'));
2015 let mut a = TreeMap::new();
2016 let mut b = TreeMap::new();
2019 assert!(a.insert(0i, 5i));
2021 assert!(b.insert(0, 4));
2023 assert!(a.insert(5, 19));
2025 assert!(!b.insert(0, 5));
2027 assert!(b.insert(5, 19));
2033 let mut a = TreeMap::new();
2034 let mut b = TreeMap::new();
2036 assert!(!(a < b) && !(b < a));
2037 assert!(b.insert(0i, 5i));
2039 assert!(a.insert(0, 7));
2040 assert!(!(a < b) && b < a);
2041 assert!(b.insert(-2, 0));
2043 assert!(a.insert(-5, 2));
2045 assert!(a.insert(6, 2));
2046 assert!(a < b && !(b < a));
2051 let mut a = TreeMap::new();
2052 let mut b = TreeMap::new();
2054 assert!(a <= b && a >= b);
2055 assert!(a.insert(1i, 1i));
2056 assert!(a > b && a >= b);
2057 assert!(b < a && b <= a);
2058 assert!(b.insert(2, 2));
2059 assert!(b > a && b >= a);
2060 assert!(a < b && a <= b);
2065 let mut map: TreeMap<int, int> = TreeMap::new();
2066 let empty: TreeMap<int, int> = TreeMap::new();
2071 let map_str = format!("{}", map);
2073 assert!(map_str == "{1: 2, 3: 4}".to_string());
2074 assert_eq!(format!("{}", empty), "{}".to_string());
2078 fn test_lazy_iterator() {
2079 let mut m = TreeMap::new();
2080 let (x1, y1) = (2i, 5i);
2081 let (x2, y2) = (9, 12);
2082 let (x3, y3) = (20, -3);
2083 let (x4, y4) = (29, 5);
2084 let (x5, y5) = (103, 3);
2086 assert!(m.insert(x1, y1));
2087 assert!(m.insert(x2, y2));
2088 assert!(m.insert(x3, y3));
2089 assert!(m.insert(x4, y4));
2090 assert!(m.insert(x5, y5));
2093 let mut a = m.iter();
2095 assert_eq!(a.next().unwrap(), (&x1, &y1));
2096 assert_eq!(a.next().unwrap(), (&x2, &y2));
2097 assert_eq!(a.next().unwrap(), (&x3, &y3));
2098 assert_eq!(a.next().unwrap(), (&x4, &y4));
2099 assert_eq!(a.next().unwrap(), (&x5, &y5));
2101 assert!(a.next().is_none());
2103 let mut b = m.iter();
2105 let expected = [(&x1, &y1), (&x2, &y2), (&x3, &y3), (&x4, &y4),
2110 assert_eq!(expected[i], x);
2119 assert_eq!(expected[i], x);
2125 fn test_from_iter() {
2126 let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
2128 let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
2130 for &(k, v) in xs.iter() {
2131 assert_eq!(map.find(&k), Some(&v));
2142 use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
2146 pub fn insert_rand_100(b: &mut Bencher) {
2147 let mut m : TreeMap<uint,uint> = TreeMap::new();
2148 insert_rand_n(100, &mut m, b);
2152 pub fn insert_rand_10_000(b: &mut Bencher) {
2153 let mut m : TreeMap<uint,uint> = TreeMap::new();
2154 insert_rand_n(10_000, &mut m, b);
2159 pub fn insert_seq_100(b: &mut Bencher) {
2160 let mut m : TreeMap<uint,uint> = TreeMap::new();
2161 insert_seq_n(100, &mut m, b);
2165 pub fn insert_seq_10_000(b: &mut Bencher) {
2166 let mut m : TreeMap<uint,uint> = TreeMap::new();
2167 insert_seq_n(10_000, &mut m, b);
2172 pub fn find_rand_100(b: &mut Bencher) {
2173 let mut m : TreeMap<uint,uint> = TreeMap::new();
2174 find_rand_n(100, &mut m, b);
2178 pub fn find_rand_10_000(b: &mut Bencher) {
2179 let mut m : TreeMap<uint,uint> = TreeMap::new();
2180 find_rand_n(10_000, &mut m, b);
2185 pub fn find_seq_100(b: &mut Bencher) {
2186 let mut m : TreeMap<uint,uint> = TreeMap::new();
2187 find_seq_n(100, &mut m, b);
2191 pub fn find_seq_10_000(b: &mut Bencher) {
2192 let mut m : TreeMap<uint,uint> = TreeMap::new();
2193 find_seq_n(10_000, &mut m, b);
2199 use std::prelude::*;
2202 use {Set, MutableSet, Mutable, MutableMap, MutableSeq};
2203 use super::{TreeMap, TreeSet};
2207 let mut s = TreeSet::new();
2209 assert!(s.insert(5i));
2210 assert!(s.insert(12));
2211 assert!(s.insert(19));
2213 assert!(!s.contains(&5));
2214 assert!(!s.contains(&12));
2215 assert!(!s.contains(&19));
2216 assert!(s.is_empty());
2220 fn test_disjoint() {
2221 let mut xs = TreeSet::new();
2222 let mut ys = TreeSet::new();
2223 assert!(xs.is_disjoint(&ys));
2224 assert!(ys.is_disjoint(&xs));
2225 assert!(xs.insert(5i));
2226 assert!(ys.insert(11i));
2227 assert!(xs.is_disjoint(&ys));
2228 assert!(ys.is_disjoint(&xs));
2229 assert!(xs.insert(7));
2230 assert!(xs.insert(19));
2231 assert!(xs.insert(4));
2232 assert!(ys.insert(2));
2233 assert!(ys.insert(-11));
2234 assert!(xs.is_disjoint(&ys));
2235 assert!(ys.is_disjoint(&xs));
2236 assert!(ys.insert(7));
2237 assert!(!xs.is_disjoint(&ys));
2238 assert!(!ys.is_disjoint(&xs));
2242 fn test_subset_and_superset() {
2243 let mut a = TreeSet::new();
2244 assert!(a.insert(0i));
2245 assert!(a.insert(5));
2246 assert!(a.insert(11));
2247 assert!(a.insert(7));
2249 let mut b = TreeSet::new();
2250 assert!(b.insert(0i));
2251 assert!(b.insert(7));
2252 assert!(b.insert(19));
2253 assert!(b.insert(250));
2254 assert!(b.insert(11));
2255 assert!(b.insert(200));
2257 assert!(!a.is_subset(&b));
2258 assert!(!a.is_superset(&b));
2259 assert!(!b.is_subset(&a));
2260 assert!(!b.is_superset(&a));
2262 assert!(b.insert(5));
2264 assert!(a.is_subset(&b));
2265 assert!(!a.is_superset(&b));
2266 assert!(!b.is_subset(&a));
2267 assert!(b.is_superset(&a));
2271 fn test_iterator() {
2272 let mut m = TreeSet::new();
2274 assert!(m.insert(3i));
2275 assert!(m.insert(0));
2276 assert!(m.insert(4));
2277 assert!(m.insert(2));
2278 assert!(m.insert(1));
2288 fn test_rev_iter() {
2289 let mut m = TreeSet::new();
2291 assert!(m.insert(3i));
2292 assert!(m.insert(0));
2293 assert!(m.insert(4));
2294 assert!(m.insert(2));
2295 assert!(m.insert(1));
2298 for x in m.rev_iter() {
2305 fn test_move_iter() {
2306 let s: TreeSet<int> = range(0i, 5).collect();
2309 for x in s.move_iter() {
2316 fn test_move_iter_size_hint() {
2317 let s: TreeSet<int> = vec!(0i, 1).move_iter().collect();
2319 let mut it = s.move_iter();
2321 assert_eq!(it.size_hint(), (2, Some(2)));
2322 assert!(it.next() != None);
2324 assert_eq!(it.size_hint(), (1, Some(1)));
2325 assert!(it.next() != None);
2327 assert_eq!(it.size_hint(), (0, Some(0)));
2328 assert_eq!(it.next(), None);
2332 fn test_clone_eq() {
2333 let mut m = TreeSet::new();
2338 assert!(m.clone() == m);
2343 let mut x = TreeSet::new();
2344 let mut y = TreeSet::new();
2354 assert!(hash::hash(&x) == hash::hash(&y));
2360 f: |&TreeSet<int>, &TreeSet<int>, f: |&int| -> bool| -> bool) {
2361 let mut set_a = TreeSet::new();
2362 let mut set_b = TreeSet::new();
2364 for x in a.iter() { assert!(set_a.insert(*x)) }
2365 for y in b.iter() { assert!(set_b.insert(*y)) }
2368 f(&set_a, &set_b, |x| {
2369 assert_eq!(*x, expected[i]);
2373 assert_eq!(i, expected.len());
2377 fn test_intersection() {
2378 fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
2379 check(a, b, expected, |x, y, f| x.intersection(y).all(f))
2382 check_intersection([], [], []);
2383 check_intersection([1, 2, 3], [], []);
2384 check_intersection([], [1, 2, 3], []);
2385 check_intersection([2], [1, 2, 3], [2]);
2386 check_intersection([1, 2, 3], [2], [2]);
2387 check_intersection([11, 1, 3, 77, 103, 5, -5],
2388 [2, 11, 77, -9, -42, 5, 3],
2393 fn test_difference() {
2394 fn check_difference(a: &[int], b: &[int], expected: &[int]) {
2395 check(a, b, expected, |x, y, f| x.difference(y).all(f))
2398 check_difference([], [], []);
2399 check_difference([1, 12], [], [1, 12]);
2400 check_difference([], [1, 2, 3, 9], []);
2401 check_difference([1, 3, 5, 9, 11],
2404 check_difference([-5, 11, 22, 33, 40, 42],
2405 [-12, -5, 14, 23, 34, 38, 39, 50],
2406 [11, 22, 33, 40, 42]);
2410 fn test_symmetric_difference() {
2411 fn check_symmetric_difference(a: &[int], b: &[int],
2413 check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
2416 check_symmetric_difference([], [], []);
2417 check_symmetric_difference([1, 2, 3], [2], [1, 3]);
2418 check_symmetric_difference([2], [1, 2, 3], [1, 3]);
2419 check_symmetric_difference([1, 3, 5, 9, 11],
2421 [-2, 1, 5, 11, 14, 22]);
2426 fn check_union(a: &[int], b: &[int],
2428 check(a, b, expected, |x, y, f| x.union(y).all(f))
2431 check_union([], [], []);
2432 check_union([1, 2, 3], [2], [1, 2, 3]);
2433 check_union([2], [1, 2, 3], [1, 2, 3]);
2434 check_union([1, 3, 5, 9, 11, 16, 19, 24],
2435 [-2, 1, 5, 9, 13, 19],
2436 [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
2441 let mut x = TreeSet::new();
2446 let mut y = TreeSet::new();
2452 let mut z = x.iter().zip(y.iter());
2454 // FIXME: #5801: this needs a type hint to compile...
2455 let result: Option<(&uint, & &'static str)> = z.next();
2456 assert_eq!(result.unwrap(), (&5u, &("bar")));
2458 let result: Option<(&uint, & &'static str)> = z.next();
2459 assert_eq!(result.unwrap(), (&11u, &("foo")));
2461 let result: Option<(&uint, & &'static str)> = z.next();
2462 assert!(result.is_none());
2467 let mut m = TreeMap::new();
2468 assert_eq!(m.swap(1u, 2i), None);
2469 assert_eq!(m.swap(1u, 3i), Some(2));
2470 assert_eq!(m.swap(1u, 4i), Some(3));
2475 let mut m = TreeMap::new();
2477 assert_eq!(m.pop(&1), Some(2));
2478 assert_eq!(m.pop(&1), None);
2482 fn test_from_iter() {
2483 let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
2485 let set: TreeSet<int> = xs.iter().map(|&x| x).collect();
2487 for x in xs.iter() {
2488 assert!(set.contains(x));
2494 let mut set: TreeSet<int> = TreeSet::new();
2495 let empty: TreeSet<int> = TreeSet::new();
2500 let set_str = format!("{}", set);
2502 assert!(set_str == "{1, 2}".to_string());
2503 assert_eq!(format!("{}", empty), "{}".to_string());