src/libcollections/treemap.rs

   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.
   4 //
   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.
  10
  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
  13 //! `Ord`.
  14
  15 use core::prelude::*;
  16
  17 use alloc::owned::Box;
  18 use core::default::Default;
  19 use core::fmt;
  20 use core::fmt::Show;
  21 use core::iter::Peekable;
  22 use core::iter;
  23 use core::mem::{replace, swap};
  24 use core::ptr;
  25
  26 use {Collection, Mutable, Set, MutableSet, MutableMap, Map};
  27 use vec::Vec;
  28
  29 // This is implemented as an AA tree, which is a simplified variation of
  30 // a red-black tree where red (horizontal) nodes can only be added
  31 // as a right child. The time complexity is the same, and re-balancing
  32 // operations are more frequent but also cheaper.
  33
  34 // Future improvements:
  35
  36 // range search - O(log n) retrieval of an iterator from some key
  37
  38 // (possibly) implement the overloads Python does for sets:
  39 //   * intersection: &
  40 //   * difference: -
  41 //   * symmetric difference: ^
  42 //   * union: |
  43 // These would be convenient since the methods work like `each`
  44
  45 #[allow(missing_doc)]
  46 #[deriving(Clone)]
  47 pub struct TreeMap<K, V> {
  48     root: Option<Box<TreeNode<K, V>>>,
  49     length: uint
  50 }
  51
  52 impl<K: PartialEq + Ord, V: PartialEq> PartialEq for TreeMap<K, V> {
  53     fn eq(&self, other: &TreeMap<K, V>) -> bool {
  54         self.len() == other.len() &&
  55             self.iter().zip(other.iter()).all(|(a, b)| a == b)
  56     }
  57 }
  58
  59 // Lexicographical comparison
  60 fn lt<K: PartialOrd + Ord, V: PartialOrd>(a: &TreeMap<K, V>,
  61                                  b: &TreeMap<K, V>) -> bool {
  62     // the Zip iterator is as long as the shortest of a and b.
  63     for ((key_a, value_a), (key_b, value_b)) in a.iter().zip(b.iter()) {
  64         if *key_a < *key_b { return true; }
  65         if *key_a > *key_b { return false; }
  66         if *value_a < *value_b { return true; }
  67         if *value_a > *value_b { return false; }
  68     }
  69
  70     a.len() < b.len()
  71 }
  72
  73 impl<K: PartialOrd + Ord, V: PartialOrd> PartialOrd for TreeMap<K, V> {
  74     #[inline]
  75     fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
  76 }
  77
  78 impl<K: Ord + Show, V: Show> Show for TreeMap<K, V> {
  79     #[cfg(stage0)]
  80     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  81         try!(write!(f, r"\{"));
  82
  83         for (i, (k, v)) in self.iter().enumerate() {
  84             if i != 0 { try!(write!(f, ", ")); }
  85             try!(write!(f, "{}: {}", *k, *v));
  86         }
  87
  88         write!(f, r"\}")
  89     }
  90     #[cfg(not(stage0))]
  91     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  92         try!(write!(f, "{{"));
  93
  94         for (i, (k, v)) in self.iter().enumerate() {
  95             if i != 0 { try!(write!(f, ", ")); }
  96             try!(write!(f, "{}: {}", *k, *v));
  97         }
  98
  99         write!(f, "}}")
 100     }
 101 }
 102
 103 impl<K: Ord, V> Collection for TreeMap<K, V> {
 104     fn len(&self) -> uint { self.length }
 105 }
 106
 107 impl<K: Ord, V> Mutable for TreeMap<K, V> {
 108     fn clear(&mut self) {
 109         self.root = None;
 110         self.length = 0
 111     }
 112 }
 113
 114 impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
 115     fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
 116         let mut current: &'a Option<Box<TreeNode<K, V>>> = &self.root;
 117         loop {
 118             match *current {
 119               Some(ref r) => {
 120                 match key.cmp(&r.key) {
 121                   Less => current = &r.left,
 122                   Greater => current = &r.right,
 123                   Equal => return Some(&r.value)
 124                 }
 125               }
 126               None => return None
 127             }
 128         }
 129     }
 130 }
 131
 132 impl<K: Ord, V> MutableMap<K, V> for TreeMap<K, V> {
 133     #[inline]
 134     fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
 135         find_mut(&mut self.root, key)
 136     }
 137
 138     fn swap(&mut self, key: K, value: V) -> Option<V> {
 139         let ret = insert(&mut self.root, key, value);
 140         if ret.is_none() { self.length += 1 }
 141         ret
 142     }
 143
 144     fn pop(&mut self, key: &K) -> Option<V> {
 145         let ret = remove(&mut self.root, key);
 146         if ret.is_some() { self.length -= 1 }
 147         ret
 148     }
 149 }
 150
 151 impl<K: Ord, V> Default for TreeMap<K,V> {
 152     #[inline]
 153     fn default() -> TreeMap<K, V> { TreeMap::new() }
 154 }
 155
 156 impl<K: Ord, V> TreeMap<K, V> {
 157     /// Create an empty TreeMap
 158     pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
 159
 160     /// Get a lazy iterator over the key-value pairs in the map.
 161     /// Requires that it be frozen (immutable).
 162     pub fn iter<'a>(&'a self) -> Entries<'a, K, V> {
 163         Entries {
 164             stack: vec!(),
 165             node: deref(&self.root),
 166             remaining_min: self.length,
 167             remaining_max: self.length
 168         }
 169     }
 170
 171     /// Get a lazy reverse iterator over the key-value pairs in the map.
 172     /// Requires that it be frozen (immutable).
 173     pub fn rev_iter<'a>(&'a self) -> RevEntries<'a, K, V> {
 174         RevEntries{iter: self.iter()}
 175     }
 176
 177     /// Get a lazy forward iterator over the key-value pairs in the
 178     /// map, with the values being mutable.
 179     pub fn mut_iter<'a>(&'a mut self) -> MutEntries<'a, K, V> {
 180         MutEntries {
 181             stack: vec!(),
 182             node: mut_deref(&mut self.root),
 183             remaining_min: self.length,
 184             remaining_max: self.length
 185         }
 186     }
 187     /// Get a lazy reverse iterator over the key-value pairs in the
 188     /// map, with the values being mutable.
 189     pub fn mut_rev_iter<'a>(&'a mut self) -> RevMutEntries<'a, K, V> {
 190         RevMutEntries{iter: self.mut_iter()}
 191     }
 192
 193
 194     /// Get a lazy iterator that consumes the treemap.
 195     pub fn move_iter(self) -> MoveEntries<K, V> {
 196         let TreeMap { root: root, length: length } = self;
 197         let stk = match root {
 198             None => vec!(),
 199             Some(box tn) => vec!(tn)
 200         };
 201         MoveEntries {
 202             stack: stk,
 203             remaining: length
 204         }
 205     }
 206 }
 207
 208 // range iterators.
 209
 210 macro_rules! bound_setup {
 211     // initialiser of the iterator to manipulate
 212     ($iter:expr,
 213      // whether we are looking for the lower or upper bound.
 214      $is_lower_bound:expr) => {
 215         {
 216             let mut iter = $iter;
 217             loop {
 218                 if !iter.node.is_null() {
 219                     let node_k = unsafe {&(*iter.node).key};
 220                     match k.cmp(node_k) {
 221                         Less => iter.traverse_left(),
 222                         Greater => iter.traverse_right(),
 223                         Equal => {
 224                             if $is_lower_bound {
 225                                 iter.traverse_complete();
 226                                 return iter;
 227                             } else {
 228                                 iter.traverse_right()
 229                             }
 230                         }
 231                     }
 232                 } else {
 233                     iter.traverse_complete();
 234                     return iter;
 235                 }
 236             }
 237         }
 238     }
 239 }
 240
 241
 242 impl<K: Ord, V> TreeMap<K, V> {
 243     /// Get a lazy iterator that should be initialized using
 244     /// `traverse_left`/`traverse_right`/`traverse_complete`.
 245     fn iter_for_traversal<'a>(&'a self) -> Entries<'a, K, V> {
 246         Entries {
 247             stack: vec!(),
 248             node: deref(&self.root),
 249             remaining_min: 0,
 250             remaining_max: self.length
 251         }
 252     }
 253
 254     /// Return a lazy iterator to the first key-value pair whose key is not less than `k`
 255     /// If all keys in map are less than `k` an empty iterator is returned.
 256     pub fn lower_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
 257         bound_setup!(self.iter_for_traversal(), true)
 258     }
 259
 260     /// Return a lazy iterator to the first key-value pair whose key is greater than `k`
 261     /// If all keys in map are not greater than `k` an empty iterator is returned.
 262     pub fn upper_bound<'a>(&'a self, k: &K) -> Entries<'a, K, V> {
 263         bound_setup!(self.iter_for_traversal(), false)
 264     }
 265
 266     /// Get a lazy iterator that should be initialized using
 267     /// `traverse_left`/`traverse_right`/`traverse_complete`.
 268     fn mut_iter_for_traversal<'a>(&'a mut self) -> MutEntries<'a, K, V> {
 269         MutEntries {
 270             stack: vec!(),
 271             node: mut_deref(&mut self.root),
 272             remaining_min: 0,
 273             remaining_max: self.length
 274         }
 275     }
 276
 277     /// Return a lazy value iterator to the first key-value pair (with
 278     /// the value being mutable) whose key is not less than `k`.
 279     ///
 280     /// If all keys in map are less than `k` an empty iterator is
 281     /// returned.
 282     pub fn mut_lower_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
 283         bound_setup!(self.mut_iter_for_traversal(), true)
 284     }
 285
 286     /// Return a lazy iterator to the first key-value pair (with the
 287     /// value being mutable) whose key is greater than `k`.
 288     ///
 289     /// If all keys in map are not greater than `k` an empty iterator
 290     /// is returned.
 291     pub fn mut_upper_bound<'a>(&'a mut self, k: &K) -> MutEntries<'a, K, V> {
 292         bound_setup!(self.mut_iter_for_traversal(), false)
 293     }
 294 }
 295
 296 /// Lazy forward iterator over a map
 297 pub struct Entries<'a, K, V> {
 298     stack: Vec<&'a TreeNode<K, V>>,
 299     // See the comment on MutEntries; this is just to allow
 300     // code-sharing (for this immutable-values iterator it *could* very
 301     // well be Option<&'a TreeNode<K,V>>).
 302     node: *TreeNode<K, V>,
 303     remaining_min: uint,
 304     remaining_max: uint
 305 }
 306
 307 /// Lazy backward iterator over a map
 308 pub struct RevEntries<'a, K, V> {
 309     iter: Entries<'a, K, V>,
 310 }
 311
 312 /// Lazy forward iterator over a map that allows for the mutation of
 313 /// the values.
 314 pub struct MutEntries<'a, K, V> {
 315     stack: Vec<&'a mut TreeNode<K, V>>,
 316     // Unfortunately, we require some unsafe-ness to get around the
 317     // fact that we would be storing a reference *into* one of the
 318     // nodes in the stack.
 319     //
 320     // As far as the compiler knows, this would let us invalidate the
 321     // reference by assigning a new value to this node's position in
 322     // its parent, which would cause this current one to be
 323     // deallocated so this reference would be invalid. (i.e. the
 324     // compilers complaints are 100% correct.)
 325     //
 326     // However, as far as you humans reading this code know (or are
 327     // about to know, if you haven't read far enough down yet), we are
 328     // only reading from the TreeNode.{left,right} fields. the only
 329     // thing that is ever mutated is the .value field (although any
 330     // actual mutation that happens is done externally, by the
 331     // iterator consumer). So, don't be so concerned, rustc, we've got
 332     // it under control.
 333     //
 334     // (This field can legitimately be null.)
 335     node: *mut TreeNode<K, V>,
 336     remaining_min: uint,
 337     remaining_max: uint
 338 }
 339
 340 /// Lazy backward iterator over a map
 341 pub struct RevMutEntries<'a, K, V> {
 342     iter: MutEntries<'a, K, V>,
 343 }
 344
 345
 346 // FIXME #5846 we want to be able to choose between &x and &mut x
 347 // (with many different `x`) below, so we need to optionally pass mut
 348 // as a tt, but the only thing we can do with a `tt` is pass them to
 349 // other macros, so this takes the `& <mutability> <operand>` token
 350 // sequence and forces their evaluation as an expression.
 351 macro_rules! addr { ($e:expr) => { $e }}
 352 // putting an optional mut into type signatures
 353 macro_rules! item { ($i:item) => { $i }}
 354
 355 macro_rules! define_iterator {
 356     ($name:ident,
 357      $rev_name:ident,
 358
 359      // the function to go from &m Option<Box<TreeNode>> to *m TreeNode
 360      deref = $deref:ident,
 361
 362      // see comment on `addr!`, this is just an optional `mut`, but
 363      // there's no support for 0-or-1 repeats.
 364      addr_mut = $($addr_mut:tt)*
 365      ) => {
 366         // private methods on the forward iterator (item!() for the
 367         // addr_mut in the next_ return value)
 368         item!(impl<'a, K, V> $name<'a, K, V> {
 369             #[inline(always)]
 370             fn next_(&mut self, forward: bool) -> Option<(&'a K, &'a $($addr_mut)* V)> {
 371                 while !self.stack.is_empty() || !self.node.is_null() {
 372                     if !self.node.is_null() {
 373                         let node = unsafe {addr!(& $($addr_mut)* *self.node)};
 374                         {
 375                             let next_node = if forward {
 376                                 addr!(& $($addr_mut)* node.left)
 377                             } else {
 378                                 addr!(& $($addr_mut)* node.right)
 379                             };
 380                             self.node = $deref(next_node);
 381                         }
 382                         self.stack.push(node);
 383                     } else {
 384                         let node = self.stack.pop().unwrap();
 385                         let next_node = if forward {
 386                             addr!(& $($addr_mut)* node.right)
 387                         } else {
 388                             addr!(& $($addr_mut)* node.left)
 389                         };
 390                         self.node = $deref(next_node);
 391                         self.remaining_max -= 1;
 392                         if self.remaining_min > 0 {
 393                             self.remaining_min -= 1;
 394                         }
 395                         return Some((&node.key, addr!(& $($addr_mut)* node.value)));
 396                     }
 397                 }
 398                 None
 399             }
 400
 401             /// traverse_left, traverse_right and traverse_complete are
 402             /// used to initialize Entries/MutEntries
 403             /// pointing to element inside tree structure.
 404             ///
 405             /// They should be used in following manner:
 406             ///   - create iterator using TreeMap::[mut_]iter_for_traversal
 407             ///   - find required node using `traverse_left`/`traverse_right`
 408             ///     (current node is `Entries::node` field)
 409             ///   - complete initialization with `traverse_complete`
 410             ///
 411             /// After this, iteration will start from `self.node`.  If
 412             /// `self.node` is None iteration will start from last
 413             /// node from which we traversed left.
 414             #[inline]
 415             fn traverse_left(&mut self) {
 416                 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
 417                 self.node = $deref(addr!(& $($addr_mut)* node.left));
 418                 self.stack.push(node);
 419             }
 420
 421             #[inline]
 422             fn traverse_right(&mut self) {
 423                 let node = unsafe {addr!(& $($addr_mut)* *self.node)};
 424                 self.node = $deref(addr!(& $($addr_mut)* node.right));
 425             }
 426
 427             #[inline]
 428             fn traverse_complete(&mut self) {
 429                 if !self.node.is_null() {
 430                     unsafe {
 431                         self.stack.push(addr!(& $($addr_mut)* *self.node));
 432                     }
 433                     self.node = ptr::RawPtr::null();
 434                 }
 435             }
 436         })
 437
 438         // the forward Iterator impl.
 439         item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $name<'a, K, V> {
 440             /// Advance the iterator to the next node (in order) and return a
 441             /// tuple with a reference to the key and value. If there are no
 442             /// more nodes, return `None`.
 443             fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
 444                 self.next_(true)
 445             }
 446
 447             #[inline]
 448             fn size_hint(&self) -> (uint, Option<uint>) {
 449                 (self.remaining_min, Some(self.remaining_max))
 450             }
 451         })
 452
 453         // the reverse Iterator impl.
 454         item!(impl<'a, K, V> Iterator<(&'a K, &'a $($addr_mut)* V)> for $rev_name<'a, K, V> {
 455             fn next(&mut self) -> Option<(&'a K, &'a $($addr_mut)* V)> {
 456                 self.iter.next_(false)
 457             }
 458
 459             #[inline]
 460             fn size_hint(&self) -> (uint, Option<uint>) {
 461                 self.iter.size_hint()
 462             }
 463         })
 464     }
 465 } // end of define_iterator
 466
 467 define_iterator! {
 468     Entries,
 469     RevEntries,
 470     deref = deref,
 471
 472     // immutable, so no mut
 473     addr_mut =
 474 }
 475 define_iterator! {
 476     MutEntries,
 477     RevMutEntries,
 478     deref = mut_deref,
 479
 480     addr_mut = mut
 481 }
 482
 483 fn deref<'a, K, V>(node: &'a Option<Box<TreeNode<K, V>>>) -> *TreeNode<K, V> {
 484     match *node {
 485         Some(ref n) => {
 486             let n: &TreeNode<K, V> = *n;
 487             n as *TreeNode<K, V>
 488         }
 489         None => ptr::null()
 490     }
 491 }
 492
 493 fn mut_deref<K, V>(x: &mut Option<Box<TreeNode<K, V>>>)
 494              -> *mut TreeNode<K, V> {
 495     match *x {
 496         Some(ref mut n) => {
 497             let n: &mut TreeNode<K, V> = *n;
 498             n as *mut TreeNode<K, V>
 499         }
 500         None => ptr::mut_null()
 501     }
 502 }
 503
 504
 505
 506 /// Lazy forward iterator over a map that consumes the map while iterating
 507 pub struct MoveEntries<K, V> {
 508     stack: Vec<TreeNode<K, V>>,
 509     remaining: uint
 510 }
 511
 512 impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
 513     #[inline]
 514     fn next(&mut self) -> Option<(K, V)> {
 515         while !self.stack.is_empty() {
 516             let TreeNode {
 517                 key: key,
 518                 value: value,
 519                 left: left,
 520                 right: right,
 521                 level: level
 522             } = self.stack.pop().unwrap();
 523
 524             match left {
 525                 Some(box left) => {
 526                     let n = TreeNode {
 527                         key: key,
 528                         value: value,
 529                         left: None,
 530                         right: right,
 531                         level: level
 532                     };
 533                     self.stack.push(n);
 534                     self.stack.push(left);
 535                 }
 536                 None => {
 537                     match right {
 538                         Some(box right) => self.stack.push(right),
 539                         None => ()
 540                     }
 541                     self.remaining -= 1;
 542                     return Some((key, value))
 543                 }
 544             }
 545         }
 546         None
 547     }
 548
 549     #[inline]
 550     fn size_hint(&self) -> (uint, Option<uint>) {
 551         (self.remaining, Some(self.remaining))
 552     }
 553
 554 }
 555
 556 impl<'a, T> Iterator<&'a T> for SetItems<'a, T> {
 557     #[inline]
 558     fn next(&mut self) -> Option<&'a T> {
 559         self.iter.next().map(|(value, _)| value)
 560     }
 561 }
 562
 563 impl<'a, T> Iterator<&'a T> for RevSetItems<'a, T> {
 564     #[inline]
 565     fn next(&mut self) -> Option<&'a T> {
 566         self.iter.next().map(|(value, _)| value)
 567     }
 568 }
 569
 570 /// A implementation of the `Set` trait on top of the `TreeMap` container. The
 571 /// only requirement is that the type of the elements contained ascribes to the
 572 /// `Ord` trait.
 573 #[deriving(Clone)]
 574 pub struct TreeSet<T> {
 575     map: TreeMap<T, ()>
 576 }
 577
 578 impl<T: PartialEq + Ord> PartialEq for TreeSet<T> {
 579     #[inline]
 580     fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
 581 }
 582
 583 impl<T: PartialOrd + Ord> PartialOrd for TreeSet<T> {
 584     #[inline]
 585     fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
 586 }
 587
 588 impl<T: Ord + Show> Show for TreeSet<T> {
 589     #[cfg(stage0)]
 590     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 591         try!(write!(f, r"\{"));
 592
 593         for (i, x) in self.iter().enumerate() {
 594             if i != 0 { try!(write!(f, ", ")); }
 595             try!(write!(f, "{}", *x));
 596         }
 597
 598         write!(f, r"\}")
 599     }
 600     #[cfg(not(stage0))]
 601     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 602         try!(write!(f, "{{"));
 603
 604         for (i, x) in self.iter().enumerate() {
 605             if i != 0 { try!(write!(f, ", ")); }
 606             try!(write!(f, "{}", *x));
 607         }
 608
 609         write!(f, "}}")
 610     }
 611 }
 612
 613 impl<T: Ord> Collection for TreeSet<T> {
 614     #[inline]
 615     fn len(&self) -> uint { self.map.len() }
 616 }
 617
 618 impl<T: Ord> Mutable for TreeSet<T> {
 619     #[inline]
 620     fn clear(&mut self) { self.map.clear() }
 621 }
 622
 623 impl<T: Ord> Set<T> for TreeSet<T> {
 624     #[inline]
 625     fn contains(&self, value: &T) -> bool {
 626         self.map.contains_key(value)
 627     }
 628
 629     fn is_disjoint(&self, other: &TreeSet<T>) -> bool {
 630         self.intersection(other).next().is_none()
 631     }
 632
 633     fn is_subset(&self, other: &TreeSet<T>) -> bool {
 634         let mut x = self.iter();
 635         let mut y = other.iter();
 636         let mut a = x.next();
 637         let mut b = y.next();
 638         while a.is_some() {
 639             if b.is_none() {
 640                 return false;
 641             }
 642
 643             let a1 = a.unwrap();
 644             let b1 = b.unwrap();
 645
 646             match b1.cmp(a1) {
 647                 Less => (),
 648                 Greater => return false,
 649                 Equal => a = x.next(),
 650             }
 651
 652             b = y.next();
 653         }
 654         true
 655     }
 656 }
 657
 658 impl<T: Ord> MutableSet<T> for TreeSet<T> {
 659     #[inline]
 660     fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
 661
 662     #[inline]
 663     fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
 664 }
 665
 666 impl<T: Ord> Default for TreeSet<T> {
 667     #[inline]
 668     fn default() -> TreeSet<T> { TreeSet::new() }
 669 }
 670
 671 impl<T: Ord> TreeSet<T> {
 672     /// Create an empty TreeSet
 673     #[inline]
 674     pub fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
 675
 676     /// Get a lazy iterator over the values in the set.
 677     /// Requires that it be frozen (immutable).
 678     #[inline]
 679     pub fn iter<'a>(&'a self) -> SetItems<'a, T> {
 680         SetItems{iter: self.map.iter()}
 681     }
 682
 683     /// Get a lazy iterator over the values in the set.
 684     /// Requires that it be frozen (immutable).
 685     #[inline]
 686     pub fn rev_iter<'a>(&'a self) -> RevSetItems<'a, T> {
 687         RevSetItems{iter: self.map.rev_iter()}
 688     }
 689
 690     /// Get a lazy iterator that consumes the set.
 691     #[inline]
 692     pub fn move_iter(self) -> MoveSetItems<T> {
 693         self.map.move_iter().map(|(value, _)| value)
 694     }
 695
 696     /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal).
 697     /// If all elements in the set are less than `v` empty iterator is returned.
 698     #[inline]
 699     pub fn lower_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
 700         SetItems{iter: self.map.lower_bound(v)}
 701     }
 702
 703     /// Get a lazy iterator pointing to the first value greater than `v`.
 704     /// If all elements in the set are not greater than `v` empty iterator is returned.
 705     #[inline]
 706     pub fn upper_bound<'a>(&'a self, v: &T) -> SetItems<'a, T> {
 707         SetItems{iter: self.map.upper_bound(v)}
 708     }
 709
 710     /// Visit the values (in-order) representing the difference
 711     pub fn difference<'a>(&'a self, other: &'a TreeSet<T>) -> DifferenceItems<'a, T> {
 712         DifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
 713     }
 714
 715     /// Visit the values (in-order) representing the symmetric difference
 716     pub fn symmetric_difference<'a>(&'a self, other: &'a TreeSet<T>)
 717         -> SymDifferenceItems<'a, T> {
 718         SymDifferenceItems{a: self.iter().peekable(), b: other.iter().peekable()}
 719     }
 720
 721     /// Visit the values (in-order) representing the intersection
 722     pub fn intersection<'a>(&'a self, other: &'a TreeSet<T>)
 723         -> IntersectionItems<'a, T> {
 724         IntersectionItems{a: self.iter().peekable(), b: other.iter().peekable()}
 725     }
 726
 727     /// Visit the values (in-order) representing the union
 728     pub fn union<'a>(&'a self, other: &'a TreeSet<T>) -> UnionItems<'a, T> {
 729         UnionItems{a: self.iter().peekable(), b: other.iter().peekable()}
 730     }
 731 }
 732
 733 /// Lazy forward iterator over a set
 734 pub struct SetItems<'a, T> {
 735     iter: Entries<'a, T, ()>
 736 }
 737
 738 /// Lazy backward iterator over a set
 739 pub struct RevSetItems<'a, T> {
 740     iter: RevEntries<'a, T, ()>
 741 }
 742
 743 /// Lazy forward iterator over a set that consumes the set while iterating
 744 pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
 745
 746 /// Lazy iterator producing elements in the set difference (in-order)
 747 pub struct DifferenceItems<'a, T> {
 748     a: Peekable<&'a T, SetItems<'a, T>>,
 749     b: Peekable<&'a T, SetItems<'a, T>>,
 750 }
 751
 752 /// Lazy iterator producing elements in the set symmetric difference (in-order)
 753 pub struct SymDifferenceItems<'a, T> {
 754     a: Peekable<&'a T, SetItems<'a, T>>,
 755     b: Peekable<&'a T, SetItems<'a, T>>,
 756 }
 757
 758 /// Lazy iterator producing elements in the set intersection (in-order)
 759 pub struct IntersectionItems<'a, T> {
 760     a: Peekable<&'a T, SetItems<'a, T>>,
 761     b: Peekable<&'a T, SetItems<'a, T>>,
 762 }
 763
 764 /// Lazy iterator producing elements in the set union (in-order)
 765 pub struct UnionItems<'a, T> {
 766     a: Peekable<&'a T, SetItems<'a, T>>,
 767     b: Peekable<&'a T, SetItems<'a, T>>,
 768 }
 769
 770 /// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
 771 fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
 772                         short: Ordering, long: Ordering) -> Ordering {
 773     match (x, y) {
 774         (None    , _       ) => short,
 775         (_       , None    ) => long,
 776         (Some(x1), Some(y1)) => x1.cmp(y1),
 777     }
 778 }
 779
 780 impl<'a, T: Ord> Iterator<&'a T> for DifferenceItems<'a, T> {
 781     fn next(&mut self) -> Option<&'a T> {
 782         loop {
 783             match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
 784                 Less    => return self.a.next(),
 785                 Equal   => { self.a.next(); self.b.next(); }
 786                 Greater => { self.b.next(); }
 787             }
 788         }
 789     }
 790 }
 791
 792 impl<'a, T: Ord> Iterator<&'a T> for SymDifferenceItems<'a, T> {
 793     fn next(&mut self) -> Option<&'a T> {
 794         loop {
 795             match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
 796                 Less    => return self.a.next(),
 797                 Equal   => { self.a.next(); self.b.next(); }
 798                 Greater => return self.b.next(),
 799             }
 800         }
 801     }
 802 }
 803
 804 impl<'a, T: Ord> Iterator<&'a T> for IntersectionItems<'a, T> {
 805     fn next(&mut self) -> Option<&'a T> {
 806         loop {
 807             let o_cmp = match (self.a.peek(), self.b.peek()) {
 808                 (None    , _       ) => None,
 809                 (_       , None    ) => None,
 810                 (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
 811             };
 812             match o_cmp {
 813                 None          => return None,
 814                 Some(Less)    => { self.a.next(); }
 815                 Some(Equal)   => { self.b.next(); return self.a.next() }
 816                 Some(Greater) => { self.b.next(); }
 817             }
 818         }
 819     }
 820 }
 821
 822 impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
 823     fn next(&mut self) -> Option<&'a T> {
 824         loop {
 825             match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
 826                 Less    => return self.a.next(),
 827                 Equal   => { self.b.next(); return self.a.next() }
 828                 Greater => return self.b.next(),
 829             }
 830         }
 831     }
 832 }
 833
 834
 835 // Nodes keep track of their level in the tree, starting at 1 in the
 836 // leaves and with a red child sharing the level of the parent.
 837 #[deriving(Clone)]
 838 struct TreeNode<K, V> {
 839     key: K,
 840     value: V,
 841     left: Option<Box<TreeNode<K, V>>>,
 842     right: Option<Box<TreeNode<K, V>>>,
 843     level: uint
 844 }
 845
 846 impl<K: Ord, V> TreeNode<K, V> {
 847     /// Creates a new tree node.
 848     #[inline]
 849     pub fn new(key: K, value: V) -> TreeNode<K, V> {
 850         TreeNode{key: key, value: value, left: None, right: None, level: 1}
 851     }
 852 }
 853
 854 // Remove left horizontal link by rotating right
 855 fn skew<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
 856     if node.left.as_ref().map_or(false, |x| x.level == node.level) {
 857         let mut save = node.left.take_unwrap();
 858         swap(&mut node.left, &mut save.right); // save.right now None
 859         swap(node, &mut save);
 860         node.right = Some(save);
 861     }
 862 }
 863
 864 // Remove dual horizontal link by rotating left and increasing level of
 865 // the parent
 866 fn split<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
 867     if node.right.as_ref().map_or(false,
 868       |x| x.right.as_ref().map_or(false, |y| y.level == node.level)) {
 869         let mut save = node.right.take_unwrap();
 870         swap(&mut node.right, &mut save.left); // save.left now None
 871         save.level += 1;
 872         swap(node, &mut save);
 873         node.left = Some(save);
 874     }
 875 }
 876
 877 fn find_mut<'r, K: Ord, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
 878                                 key: &K)
 879                              -> Option<&'r mut V> {
 880     match *node {
 881       Some(ref mut x) => {
 882         match key.cmp(&x.key) {
 883           Less => find_mut(&mut x.left, key),
 884           Greater => find_mut(&mut x.right, key),
 885           Equal => Some(&mut x.value),
 886         }
 887       }
 888       None => None
 889     }
 890 }
 891
 892 fn insert<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
 893                           key: K, value: V) -> Option<V> {
 894     match *node {
 895       Some(ref mut save) => {
 896         match key.cmp(&save.key) {
 897           Less => {
 898             let inserted = insert(&mut save.left, key, value);
 899             skew(save);
 900             split(save);
 901             inserted
 902           }
 903           Greater => {
 904             let inserted = insert(&mut save.right, key, value);
 905             skew(save);
 906             split(save);
 907             inserted
 908           }
 909           Equal => {
 910             save.key = key;
 911             Some(replace(&mut save.value, value))
 912           }
 913         }
 914       }
 915       None => {
 916        *node = Some(box TreeNode::new(key, value));
 917         None
 918       }
 919     }
 920 }
 921
 922 fn remove<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
 923                           key: &K) -> Option<V> {
 924     fn heir_swap<K: Ord, V>(node: &mut Box<TreeNode<K, V>>,
 925                                  child: &mut Option<Box<TreeNode<K, V>>>) {
 926         // *could* be done without recursion, but it won't borrow check
 927         for x in child.mut_iter() {
 928             if x.right.is_some() {
 929                 heir_swap(node, &mut x.right);
 930             } else {
 931                 swap(&mut node.key, &mut x.key);
 932                 swap(&mut node.value, &mut x.value);
 933             }
 934         }
 935     }
 936
 937     match *node {
 938       None => {
 939         return None; // bottom of tree
 940       }
 941       Some(ref mut save) => {
 942         let (ret, rebalance) = match key.cmp(&save.key) {
 943           Less => (remove(&mut save.left, key), true),
 944           Greater => (remove(&mut save.right, key), true),
 945           Equal => {
 946             if save.left.is_some() {
 947                 if save.right.is_some() {
 948                     let mut left = save.left.take_unwrap();
 949                     if left.right.is_some() {
 950                         heir_swap(save, &mut left.right);
 951                     } else {
 952                         swap(&mut save.key, &mut left.key);
 953                         swap(&mut save.value, &mut left.value);
 954                     }
 955                     save.left = Some(left);
 956                     (remove(&mut save.left, key), true)
 957                 } else {
 958                     let new = save.left.take_unwrap();
 959                     let box TreeNode{value, ..} = replace(save, new);
 960                     *save = save.left.take_unwrap();
 961                     (Some(value), true)
 962                 }
 963             } else if save.right.is_some() {
 964                 let new = save.right.take_unwrap();
 965                 let box TreeNode{value, ..} = replace(save, new);
 966                 (Some(value), true)
 967             } else {
 968                 (None, false)
 969             }
 970           }
 971         };
 972
 973         if rebalance {
 974             let left_level = save.left.as_ref().map_or(0, |x| x.level);
 975             let right_level = save.right.as_ref().map_or(0, |x| x.level);
 976
 977             // re-balance, if necessary
 978             if left_level < save.level - 1 || right_level < save.level - 1 {
 979                 save.level -= 1;
 980
 981                 if right_level > save.level {
 982                     for x in save.right.mut_iter() { x.level = save.level }
 983                 }
 984
 985                 skew(save);
 986
 987                 for right in save.right.mut_iter() {
 988                     skew(right);
 989                     for x in right.right.mut_iter() { skew(x) }
 990                 }
 991
 992                 split(save);
 993                 for x in save.right.mut_iter() { split(x) }
 994             }
 995
 996             return ret;
 997         }
 998       }
 999     }
1000     return match node.take() {
1001         Some(box TreeNode{value, ..}) => Some(value), None => fail!()
1002     };
1003 }
1004
1005 impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
1006     fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
1007         let mut map = TreeMap::new();
1008         map.extend(iter);
1009         map
1010     }
1011 }
1012
1013 impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
1014     #[inline]
1015     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
1016         for (k, v) in iter {
1017             self.insert(k, v);
1018         }
1019     }
1020 }
1021
1022 impl<T: Ord> FromIterator<T> for TreeSet<T> {
1023     fn from_iter<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
1024         let mut set = TreeSet::new();
1025         set.extend(iter);
1026         set
1027     }
1028 }
1029
1030 impl<T: Ord> Extendable<T> for TreeSet<T> {
1031     #[inline]
1032     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
1033         for elem in iter {
1034             self.insert(elem);
1035         }
1036     }
1037 }
1038
1039 #[cfg(test)]
1040 mod test_treemap {
1041     use std::prelude::*;
1042     use std::rand::Rng;
1043     use std::rand;
1044
1045     use {Map, MutableMap, Mutable};
1046     use super::{TreeMap, TreeNode};
1047
1048     #[test]
1049     fn find_empty() {
1050         let m: TreeMap<int,int> = TreeMap::new();
1051         assert!(m.find(&5) == None);
1052     }
1053
1054     #[test]
1055     fn find_not_found() {
1056         let mut m = TreeMap::new();
1057         assert!(m.insert(1, 2));
1058         assert!(m.insert(5, 3));
1059         assert!(m.insert(9, 3));
1060         assert_eq!(m.find(&2), None);
1061     }
1062
1063     #[test]
1064     fn test_find_mut() {
1065         let mut m = TreeMap::new();
1066         assert!(m.insert(1, 12));
1067         assert!(m.insert(2, 8));
1068         assert!(m.insert(5, 14));
1069         let new = 100;
1070         match m.find_mut(&5) {
1071           None => fail!(), Some(x) => *x = new
1072         }
1073         assert_eq!(m.find(&5), Some(&new));
1074     }
1075
1076     #[test]
1077     fn insert_replace() {
1078         let mut m = TreeMap::new();
1079         assert!(m.insert(5, 2));
1080         assert!(m.insert(2, 9));
1081         assert!(!m.insert(2, 11));
1082         assert_eq!(m.find(&2).unwrap(), &11);
1083     }
1084
1085     #[test]
1086     fn test_clear() {
1087         let mut m = TreeMap::new();
1088         m.clear();
1089         assert!(m.insert(5, 11));
1090         assert!(m.insert(12, -3));
1091         assert!(m.insert(19, 2));
1092         m.clear();
1093         assert!(m.find(&5).is_none());
1094         assert!(m.find(&12).is_none());
1095         assert!(m.find(&19).is_none());
1096         assert!(m.is_empty());
1097     }
1098
1099     #[test]
1100     fn u8_map() {
1101         let mut m = TreeMap::new();
1102
1103         let k1 = "foo".as_bytes();
1104         let k2 = "bar".as_bytes();
1105         let v1 = "baz".as_bytes();
1106         let v2 = "foobar".as_bytes();
1107
1108         m.insert(k1.clone(), v1.clone());
1109         m.insert(k2.clone(), v2.clone());
1110
1111         assert_eq!(m.find(&k2), Some(&v2));
1112         assert_eq!(m.find(&k1), Some(&v1));
1113     }
1114
1115     fn check_equal<K: PartialEq + Ord, V: PartialEq>(ctrl: &[(K, V)],
1116                                             map: &TreeMap<K, V>) {
1117         assert_eq!(ctrl.is_empty(), map.is_empty());
1118         for x in ctrl.iter() {
1119             let &(ref k, ref v) = x;
1120             assert!(map.find(k).unwrap() == v)
1121         }
1122         for (map_k, map_v) in map.iter() {
1123             let mut found = false;
1124             for x in ctrl.iter() {
1125                 let &(ref ctrl_k, ref ctrl_v) = x;
1126                 if *map_k == *ctrl_k {
1127                     assert!(*map_v == *ctrl_v);
1128                     found = true;
1129                     break;
1130                 }
1131             }
1132             assert!(found);
1133         }
1134     }
1135
1136     fn check_left<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1137                                   parent: &Box<TreeNode<K, V>>) {
1138         match *node {
1139           Some(ref r) => {
1140             assert_eq!(r.key.cmp(&parent.key), Less);
1141             assert!(r.level == parent.level - 1); // left is black
1142             check_left(&r.left, r);
1143             check_right(&r.right, r, false);
1144           }
1145           None => assert!(parent.level == 1) // parent is leaf
1146         }
1147     }
1148
1149     fn check_right<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
1150                                    parent: &Box<TreeNode<K, V>>,
1151                                    parent_red: bool) {
1152         match *node {
1153           Some(ref r) => {
1154             assert_eq!(r.key.cmp(&parent.key), Greater);
1155             let red = r.level == parent.level;
1156             if parent_red { assert!(!red) } // no dual horizontal links
1157             // Right red or black
1158             assert!(red || r.level == parent.level - 1);
1159             check_left(&r.left, r);
1160             check_right(&r.right, r, red);
1161           }
1162           None => assert!(parent.level == 1) // parent is leaf
1163         }
1164     }
1165
1166     fn check_structure<K: Ord, V>(map: &TreeMap<K, V>) {
1167         match map.root {
1168           Some(ref r) => {
1169             check_left(&r.left, r);
1170             check_right(&r.right, r, false);
1171           }
1172           None => ()
1173         }
1174     }
1175
1176     #[test]
1177     fn test_rand_int() {
1178         let mut map: TreeMap<int,int> = TreeMap::new();
1179         let mut ctrl = vec![];
1180
1181         check_equal(ctrl.as_slice(), &map);
1182         assert!(map.find(&5).is_none());
1183
1184         let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(&[42]);
1185
1186         for _ in range(0, 3) {
1187             for _ in range(0, 90) {
1188                 let k = rng.gen();
1189                 let v = rng.gen();
1190                 if !ctrl.iter().any(|x| x == &(k, v)) {
1191                     assert!(map.insert(k, v));
1192                     ctrl.push((k, v));
1193                     check_structure(&map);
1194                     check_equal(ctrl.as_slice(), &map);
1195                 }
1196             }
1197
1198             for _ in range(0, 30) {
1199                 let r = rng.gen_range(0, ctrl.len());
1200                 let (key, _) = ctrl.remove(r).unwrap();
1201                 assert!(map.remove(&key));
1202                 check_structure(&map);
1203                 check_equal(ctrl.as_slice(), &map);
1204             }
1205         }
1206     }
1207
1208     #[test]
1209     fn test_len() {
1210         let mut m = TreeMap::new();
1211         assert!(m.insert(3, 6));
1212         assert_eq!(m.len(), 1);
1213         assert!(m.insert(0, 0));
1214         assert_eq!(m.len(), 2);
1215         assert!(m.insert(4, 8));
1216         assert_eq!(m.len(), 3);
1217         assert!(m.remove(&3));
1218         assert_eq!(m.len(), 2);
1219         assert!(!m.remove(&5));
1220         assert_eq!(m.len(), 2);
1221         assert!(m.insert(2, 4));
1222         assert_eq!(m.len(), 3);
1223         assert!(m.insert(1, 2));
1224         assert_eq!(m.len(), 4);
1225     }
1226
1227     #[test]
1228     fn test_iterator() {
1229         let mut m = TreeMap::new();
1230
1231         assert!(m.insert(3, 6));
1232         assert!(m.insert(0, 0));
1233         assert!(m.insert(4, 8));
1234         assert!(m.insert(2, 4));
1235         assert!(m.insert(1, 2));
1236
1237         let mut n = 0;
1238         for (k, v) in m.iter() {
1239             assert_eq!(*k, n);
1240             assert_eq!(*v, n * 2);
1241             n += 1;
1242         }
1243         assert_eq!(n, 5);
1244     }
1245
1246     #[test]
1247     fn test_interval_iteration() {
1248         let mut m = TreeMap::new();
1249         for i in range(1, 100) {
1250             assert!(m.insert(i * 2, i * 4));
1251         }
1252
1253         for i in range(1, 198) {
1254             let mut lb_it = m.lower_bound(&i);
1255             let (&k, &v) = lb_it.next().unwrap();
1256             let lb = i + i % 2;
1257             assert_eq!(lb, k);
1258             assert_eq!(lb * 2, v);
1259
1260             let mut ub_it = m.upper_bound(&i);
1261             let (&k, &v) = ub_it.next().unwrap();
1262             let ub = i + 2 - i % 2;
1263             assert_eq!(ub, k);
1264             assert_eq!(ub * 2, v);
1265         }
1266         let mut end_it = m.lower_bound(&199);
1267         assert_eq!(end_it.next(), None);
1268     }
1269
1270     #[test]
1271     fn test_rev_iter() {
1272         let mut m = TreeMap::new();
1273
1274         assert!(m.insert(3, 6));
1275         assert!(m.insert(0, 0));
1276         assert!(m.insert(4, 8));
1277         assert!(m.insert(2, 4));
1278         assert!(m.insert(1, 2));
1279
1280         let mut n = 4;
1281         for (k, v) in m.rev_iter() {
1282             assert_eq!(*k, n);
1283             assert_eq!(*v, n * 2);
1284             n -= 1;
1285         }
1286     }
1287
1288     #[test]
1289     fn test_mut_iter() {
1290         let mut m = TreeMap::new();
1291         for i in range(0u, 10) {
1292             assert!(m.insert(i, 100 * i));
1293         }
1294
1295         for (i, (&k, v)) in m.mut_iter().enumerate() {
1296             *v += k * 10 + i; // 000 + 00 + 0, 100 + 10 + 1, ...
1297         }
1298
1299         for (&k, &v) in m.iter() {
1300             assert_eq!(v, 111 * k);
1301         }
1302     }
1303     #[test]
1304     fn test_mut_rev_iter() {
1305         let mut m = TreeMap::new();
1306         for i in range(0u, 10) {
1307             assert!(m.insert(i, 100 * i));
1308         }
1309
1310         for (i, (&k, v)) in m.mut_rev_iter().enumerate() {
1311             *v += k * 10 + (9 - i); // 900 + 90 + (9 - 0), 800 + 80 + (9 - 1), ...
1312         }
1313
1314         for (&k, &v) in m.iter() {
1315             assert_eq!(v, 111 * k);
1316         }
1317     }
1318
1319     #[test]
1320     fn test_mut_interval_iter() {
1321         let mut m_lower = TreeMap::new();
1322         let mut m_upper = TreeMap::new();
1323         for i in range(1, 100) {
1324             assert!(m_lower.insert(i * 2, i * 4));
1325             assert!(m_upper.insert(i * 2, i * 4));
1326         }
1327
1328         for i in range(1, 199) {
1329             let mut lb_it = m_lower.mut_lower_bound(&i);
1330             let (&k, v) = lb_it.next().unwrap();
1331             let lb = i + i % 2;
1332             assert_eq!(lb, k);
1333             *v -= k;
1334         }
1335         for i in range(0, 198) {
1336             let mut ub_it = m_upper.mut_upper_bound(&i);
1337             let (&k, v) = ub_it.next().unwrap();
1338             let ub = i + 2 - i % 2;
1339             assert_eq!(ub, k);
1340             *v -= k;
1341         }
1342
1343         assert!(m_lower.mut_lower_bound(&199).next().is_none());
1344
1345         assert!(m_upper.mut_upper_bound(&198).next().is_none());
1346
1347         assert!(m_lower.iter().all(|(_, &x)| x == 0));
1348         assert!(m_upper.iter().all(|(_, &x)| x == 0));
1349     }
1350
1351     #[test]
1352     fn test_eq() {
1353         let mut a = TreeMap::new();
1354         let mut b = TreeMap::new();
1355
1356         assert!(a == b);
1357         assert!(a.insert(0, 5));
1358         assert!(a != b);
1359         assert!(b.insert(0, 4));
1360         assert!(a != b);
1361         assert!(a.insert(5, 19));
1362         assert!(a != b);
1363         assert!(!b.insert(0, 5));
1364         assert!(a != b);
1365         assert!(b.insert(5, 19));
1366         assert!(a == b);
1367     }
1368
1369     #[test]
1370     fn test_lt() {
1371         let mut a = TreeMap::new();
1372         let mut b = TreeMap::new();
1373
1374         assert!(!(a < b) && !(b < a));
1375         assert!(b.insert(0, 5));
1376         assert!(a < b);
1377         assert!(a.insert(0, 7));
1378         assert!(!(a < b) && b < a);
1379         assert!(b.insert(-2, 0));
1380         assert!(b < a);
1381         assert!(a.insert(-5, 2));
1382         assert!(a < b);
1383         assert!(a.insert(6, 2));
1384         assert!(a < b && !(b < a));
1385     }
1386
1387     #[test]
1388     fn test_ord() {
1389         let mut a = TreeMap::new();
1390         let mut b = TreeMap::new();
1391
1392         assert!(a <= b && a >= b);
1393         assert!(a.insert(1, 1));
1394         assert!(a > b && a >= b);
1395         assert!(b < a && b <= a);
1396         assert!(b.insert(2, 2));
1397         assert!(b > a && b >= a);
1398         assert!(a < b && a <= b);
1399     }
1400
1401     #[test]
1402     fn test_show() {
1403         let mut map: TreeMap<int, int> = TreeMap::new();
1404         let empty: TreeMap<int, int> = TreeMap::new();
1405
1406         map.insert(1, 2);
1407         map.insert(3, 4);
1408
1409         let map_str = format!("{}", map);
1410
1411         assert!(map_str == "{1: 2, 3: 4}".to_string());
1412         assert_eq!(format!("{}", empty), "{}".to_string());
1413     }
1414
1415     #[test]
1416     fn test_lazy_iterator() {
1417         let mut m = TreeMap::new();
1418         let (x1, y1) = (2, 5);
1419         let (x2, y2) = (9, 12);
1420         let (x3, y3) = (20, -3);
1421         let (x4, y4) = (29, 5);
1422         let (x5, y5) = (103, 3);
1423
1424         assert!(m.insert(x1, y1));
1425         assert!(m.insert(x2, y2));
1426         assert!(m.insert(x3, y3));
1427         assert!(m.insert(x4, y4));
1428         assert!(m.insert(x5, y5));
1429
1430         let m = m;
1431         let mut a = m.iter();
1432
1433         assert_eq!(a.next().unwrap(), (&x1, &y1));
1434         assert_eq!(a.next().unwrap(), (&x2, &y2));
1435         assert_eq!(a.next().unwrap(), (&x3, &y3));
1436         assert_eq!(a.next().unwrap(), (&x4, &y4));
1437         assert_eq!(a.next().unwrap(), (&x5, &y5));
1438
1439         assert!(a.next().is_none());
1440
1441         let mut b = m.iter();
1442
1443         let expected = [(&x1, &y1), (&x2, &y2), (&x3, &y3), (&x4, &y4),
1444                         (&x5, &y5)];
1445         let mut i = 0;
1446
1447         for x in b {
1448             assert_eq!(expected[i], x);
1449             i += 1;
1450
1451             if i == 2 {
1452                 break
1453             }
1454         }
1455
1456         for x in b {
1457             assert_eq!(expected[i], x);
1458             i += 1;
1459         }
1460     }
1461
1462     #[test]
1463     fn test_from_iter() {
1464         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
1465
1466         let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
1467
1468         for &(k, v) in xs.iter() {
1469             assert_eq!(map.find(&k), Some(&v));
1470         }
1471     }
1472
1473 }
1474
1475 #[cfg(test)]
1476 mod bench {
1477     use test::Bencher;
1478
1479     use super::TreeMap;
1480     use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
1481
1482     // Find seq
1483     #[bench]
1484     pub fn insert_rand_100(b: &mut Bencher) {
1485         let mut m : TreeMap<uint,uint> = TreeMap::new();
1486         insert_rand_n(100, &mut m, b);
1487     }
1488
1489     #[bench]
1490     pub fn insert_rand_10_000(b: &mut Bencher) {
1491         let mut m : TreeMap<uint,uint> = TreeMap::new();
1492         insert_rand_n(10_000, &mut m, b);
1493     }
1494
1495     // Insert seq
1496     #[bench]
1497     pub fn insert_seq_100(b: &mut Bencher) {
1498         let mut m : TreeMap<uint,uint> = TreeMap::new();
1499         insert_seq_n(100, &mut m, b);
1500     }
1501
1502     #[bench]
1503     pub fn insert_seq_10_000(b: &mut Bencher) {
1504         let mut m : TreeMap<uint,uint> = TreeMap::new();
1505         insert_seq_n(10_000, &mut m, b);
1506     }
1507
1508     // Find rand
1509     #[bench]
1510     pub fn find_rand_100(b: &mut Bencher) {
1511         let mut m : TreeMap<uint,uint> = TreeMap::new();
1512         find_rand_n(100, &mut m, b);
1513     }
1514
1515     #[bench]
1516     pub fn find_rand_10_000(b: &mut Bencher) {
1517         let mut m : TreeMap<uint,uint> = TreeMap::new();
1518         find_rand_n(10_000, &mut m, b);
1519     }
1520
1521     // Find seq
1522     #[bench]
1523     pub fn find_seq_100(b: &mut Bencher) {
1524         let mut m : TreeMap<uint,uint> = TreeMap::new();
1525         find_seq_n(100, &mut m, b);
1526     }
1527
1528     #[bench]
1529     pub fn find_seq_10_000(b: &mut Bencher) {
1530         let mut m : TreeMap<uint,uint> = TreeMap::new();
1531         find_seq_n(10_000, &mut m, b);
1532     }
1533 }
1534
1535 #[cfg(test)]
1536 mod test_set {
1537     use std::prelude::*;
1538
1539     use {Set, MutableSet, Mutable, MutableMap};
1540     use super::{TreeMap, TreeSet};
1541
1542     #[test]
1543     fn test_clear() {
1544         let mut s = TreeSet::new();
1545         s.clear();
1546         assert!(s.insert(5));
1547         assert!(s.insert(12));
1548         assert!(s.insert(19));
1549         s.clear();
1550         assert!(!s.contains(&5));
1551         assert!(!s.contains(&12));
1552         assert!(!s.contains(&19));
1553         assert!(s.is_empty());
1554     }
1555
1556     #[test]
1557     fn test_disjoint() {
1558         let mut xs = TreeSet::new();
1559         let mut ys = TreeSet::new();
1560         assert!(xs.is_disjoint(&ys));
1561         assert!(ys.is_disjoint(&xs));
1562         assert!(xs.insert(5));
1563         assert!(ys.insert(11));
1564         assert!(xs.is_disjoint(&ys));
1565         assert!(ys.is_disjoint(&xs));
1566         assert!(xs.insert(7));
1567         assert!(xs.insert(19));
1568         assert!(xs.insert(4));
1569         assert!(ys.insert(2));
1570         assert!(ys.insert(-11));
1571         assert!(xs.is_disjoint(&ys));
1572         assert!(ys.is_disjoint(&xs));
1573         assert!(ys.insert(7));
1574         assert!(!xs.is_disjoint(&ys));
1575         assert!(!ys.is_disjoint(&xs));
1576     }
1577
1578     #[test]
1579     fn test_subset_and_superset() {
1580         let mut a = TreeSet::new();
1581         assert!(a.insert(0));
1582         assert!(a.insert(5));
1583         assert!(a.insert(11));
1584         assert!(a.insert(7));
1585
1586         let mut b = TreeSet::new();
1587         assert!(b.insert(0));
1588         assert!(b.insert(7));
1589         assert!(b.insert(19));
1590         assert!(b.insert(250));
1591         assert!(b.insert(11));
1592         assert!(b.insert(200));
1593
1594         assert!(!a.is_subset(&b));
1595         assert!(!a.is_superset(&b));
1596         assert!(!b.is_subset(&a));
1597         assert!(!b.is_superset(&a));
1598
1599         assert!(b.insert(5));
1600
1601         assert!(a.is_subset(&b));
1602         assert!(!a.is_superset(&b));
1603         assert!(!b.is_subset(&a));
1604         assert!(b.is_superset(&a));
1605     }
1606
1607     #[test]
1608     fn test_iterator() {
1609         let mut m = TreeSet::new();
1610
1611         assert!(m.insert(3));
1612         assert!(m.insert(0));
1613         assert!(m.insert(4));
1614         assert!(m.insert(2));
1615         assert!(m.insert(1));
1616
1617         let mut n = 0;
1618         for x in m.iter() {
1619             assert_eq!(*x, n);
1620             n += 1
1621         }
1622     }
1623
1624     #[test]
1625     fn test_rev_iter() {
1626         let mut m = TreeSet::new();
1627
1628         assert!(m.insert(3));
1629         assert!(m.insert(0));
1630         assert!(m.insert(4));
1631         assert!(m.insert(2));
1632         assert!(m.insert(1));
1633
1634         let mut n = 4;
1635         for x in m.rev_iter() {
1636             assert_eq!(*x, n);
1637             n -= 1;
1638         }
1639     }
1640
1641     #[test]
1642     fn test_move_iter() {
1643         let s: TreeSet<int> = range(0, 5).collect();
1644
1645         let mut n = 0;
1646         for x in s.move_iter() {
1647             assert_eq!(x, n);
1648             n += 1;
1649         }
1650     }
1651
1652     #[test]
1653     fn test_move_iter_size_hint() {
1654         let s: TreeSet<int> = vec!(0, 1).move_iter().collect();
1655
1656         let mut it = s.move_iter();
1657
1658         assert_eq!(it.size_hint(), (2, Some(2)));
1659         assert!(it.next() != None);
1660
1661         assert_eq!(it.size_hint(), (1, Some(1)));
1662         assert!(it.next() != None);
1663
1664         assert_eq!(it.size_hint(), (0, Some(0)));
1665         assert_eq!(it.next(), None);
1666     }
1667
1668     #[test]
1669     fn test_clone_eq() {
1670       let mut m = TreeSet::new();
1671
1672       m.insert(1);
1673       m.insert(2);
1674
1675       assert!(m.clone() == m);
1676     }
1677
1678     fn check(a: &[int],
1679              b: &[int],
1680              expected: &[int],
1681              f: |&TreeSet<int>, &TreeSet<int>, f: |&int| -> bool| -> bool) {
1682         let mut set_a = TreeSet::new();
1683         let mut set_b = TreeSet::new();
1684
1685         for x in a.iter() { assert!(set_a.insert(*x)) }
1686         for y in b.iter() { assert!(set_b.insert(*y)) }
1687
1688         let mut i = 0;
1689         f(&set_a, &set_b, |x| {
1690             assert_eq!(*x, expected[i]);
1691             i += 1;
1692             true
1693         });
1694         assert_eq!(i, expected.len());
1695     }
1696
1697     #[test]
1698     fn test_intersection() {
1699         fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
1700             check(a, b, expected, |x, y, f| x.intersection(y).advance(f))
1701         }
1702
1703         check_intersection([], [], []);
1704         check_intersection([1, 2, 3], [], []);
1705         check_intersection([], [1, 2, 3], []);
1706         check_intersection([2], [1, 2, 3], [2]);
1707         check_intersection([1, 2, 3], [2], [2]);
1708         check_intersection([11, 1, 3, 77, 103, 5, -5],
1709                            [2, 11, 77, -9, -42, 5, 3],
1710                            [3, 5, 11, 77]);
1711     }
1712
1713     #[test]
1714     fn test_difference() {
1715         fn check_difference(a: &[int], b: &[int], expected: &[int]) {
1716             check(a, b, expected, |x, y, f| x.difference(y).advance(f))
1717         }
1718
1719         check_difference([], [], []);
1720         check_difference([1, 12], [], [1, 12]);
1721         check_difference([], [1, 2, 3, 9], []);
1722         check_difference([1, 3, 5, 9, 11],
1723                          [3, 9],
1724                          [1, 5, 11]);
1725         check_difference([-5, 11, 22, 33, 40, 42],
1726                          [-12, -5, 14, 23, 34, 38, 39, 50],
1727                          [11, 22, 33, 40, 42]);
1728     }
1729
1730     #[test]
1731     fn test_symmetric_difference() {
1732         fn check_symmetric_difference(a: &[int], b: &[int],
1733                                       expected: &[int]) {
1734             check(a, b, expected, |x, y, f| x.symmetric_difference(y).advance(f))
1735         }
1736
1737         check_symmetric_difference([], [], []);
1738         check_symmetric_difference([1, 2, 3], [2], [1, 3]);
1739         check_symmetric_difference([2], [1, 2, 3], [1, 3]);
1740         check_symmetric_difference([1, 3, 5, 9, 11],
1741                                    [-2, 3, 9, 14, 22],
1742                                    [-2, 1, 5, 11, 14, 22]);
1743     }
1744
1745     #[test]
1746     fn test_union() {
1747         fn check_union(a: &[int], b: &[int],
1748                                       expected: &[int]) {
1749             check(a, b, expected, |x, y, f| x.union(y).advance(f))
1750         }
1751
1752         check_union([], [], []);
1753         check_union([1, 2, 3], [2], [1, 2, 3]);
1754         check_union([2], [1, 2, 3], [1, 2, 3]);
1755         check_union([1, 3, 5, 9, 11, 16, 19, 24],
1756                     [-2, 1, 5, 9, 13, 19],
1757                     [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
1758     }
1759
1760     #[test]
1761     fn test_zip() {
1762         let mut x = TreeSet::new();
1763         x.insert(5u);
1764         x.insert(12u);
1765         x.insert(11u);
1766
1767         let mut y = TreeSet::new();
1768         y.insert("foo");
1769         y.insert("bar");
1770
1771         let x = x;
1772         let y = y;
1773         let mut z = x.iter().zip(y.iter());
1774
1775         // FIXME: #5801: this needs a type hint to compile...
1776         let result: Option<(&uint, & &'static str)> = z.next();
1777         assert_eq!(result.unwrap(), (&5u, &("bar")));
1778
1779         let result: Option<(&uint, & &'static str)> = z.next();
1780         assert_eq!(result.unwrap(), (&11u, &("foo")));
1781
1782         let result: Option<(&uint, & &'static str)> = z.next();
1783         assert!(result.is_none());
1784     }
1785
1786     #[test]
1787     fn test_swap() {
1788         let mut m = TreeMap::new();
1789         assert_eq!(m.swap(1, 2), None);
1790         assert_eq!(m.swap(1, 3), Some(2));
1791         assert_eq!(m.swap(1, 4), Some(3));
1792     }
1793
1794     #[test]
1795     fn test_pop() {
1796         let mut m = TreeMap::new();
1797         m.insert(1, 2);
1798         assert_eq!(m.pop(&1), Some(2));
1799         assert_eq!(m.pop(&1), None);
1800     }
1801
1802     #[test]
1803     fn test_from_iter() {
1804         let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
1805
1806         let set: TreeSet<int> = xs.iter().map(|&x| x).collect();
1807
1808         for x in xs.iter() {
1809             assert!(set.contains(x));
1810         }
1811     }
1812
1813     #[test]
1814     fn test_show() {
1815         let mut set: TreeSet<int> = TreeSet::new();
1816         let empty: TreeSet<int> = TreeSet::new();
1817
1818         set.insert(1);
1819         set.insert(2);
1820
1821         let set_str = format!("{}", set);
1822
1823         assert!(set_str == "{1, 2}".to_string());
1824         assert_eq!(format!("{}", empty), "{}".to_string());
1825     }
1826 }