529 lines
16 KiB
Rust
529 lines
16 KiB
Rust
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
/*!
|
|
* A simple map based on a vector for small integer keys. Space requirements
|
|
* are O(highest integer key).
|
|
*/
|
|
|
|
#[allow(missing_doc)];
|
|
|
|
use std::iterator::{Iterator, Enumerate, FilterMap, Invert};
|
|
use std::util::replace;
|
|
use std::vec::{VecIterator, VecMutIterator};
|
|
use std::vec;
|
|
|
|
#[allow(missing_doc)]
|
|
pub struct SmallIntMap<T> {
|
|
priv v: ~[Option<T>],
|
|
}
|
|
|
|
impl<V> Container for SmallIntMap<V> {
|
|
/// Return the number of elements in the map
|
|
fn len(&self) -> uint {
|
|
self.v.iter().count(|elt| elt.is_some())
|
|
}
|
|
|
|
/// Return true if there are no elements in the map
|
|
fn is_empty(&self) -> bool {
|
|
self.v.iter().all(|elt| elt.is_none())
|
|
}
|
|
}
|
|
|
|
impl<V> Mutable for SmallIntMap<V> {
|
|
/// Clear the map, removing all key-value pairs.
|
|
fn clear(&mut self) { self.v.clear() }
|
|
}
|
|
|
|
impl<V> Map<uint, V> for SmallIntMap<V> {
|
|
/// Return a reference to the value corresponding to the key
|
|
fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
|
|
if *key < self.v.len() {
|
|
match self.v[*key] {
|
|
Some(ref value) => Some(value),
|
|
None => None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<V> MutableMap<uint, V> for SmallIntMap<V> {
|
|
/// Return a mutable reference to the value corresponding to the key
|
|
fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut V> {
|
|
if *key < self.v.len() {
|
|
match self.v[*key] {
|
|
Some(ref mut value) => Some(value),
|
|
None => None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Insert a key-value pair into the map. An existing value for a
|
|
/// key is replaced by the new value. Return true if the key did
|
|
/// not already exist in the map.
|
|
fn insert(&mut self, key: uint, value: V) -> bool {
|
|
let exists = self.contains_key(&key);
|
|
let len = self.v.len();
|
|
if len <= key {
|
|
self.v.grow_fn(key - len + 1, |_| None);
|
|
}
|
|
self.v[key] = Some(value);
|
|
!exists
|
|
}
|
|
|
|
/// Remove a key-value pair from the map. Return true if the key
|
|
/// was present in the map, otherwise false.
|
|
fn remove(&mut self, key: &uint) -> bool {
|
|
self.pop(key).is_some()
|
|
}
|
|
|
|
/// Insert a key-value pair from the map. If the key already had a value
|
|
/// present in the map, that value is returned. Otherwise None is returned.
|
|
fn swap(&mut self, key: uint, value: V) -> Option<V> {
|
|
match self.find_mut(&key) {
|
|
Some(loc) => { return Some(replace(loc, value)); }
|
|
None => ()
|
|
}
|
|
self.insert(key, value);
|
|
return None;
|
|
}
|
|
|
|
/// Removes a key from the map, returning the value at the key if the key
|
|
/// was previously in the map.
|
|
fn pop(&mut self, key: &uint) -> Option<V> {
|
|
if *key >= self.v.len() {
|
|
return None;
|
|
}
|
|
self.v[*key].take()
|
|
}
|
|
}
|
|
|
|
impl<V> SmallIntMap<V> {
|
|
/// Create an empty SmallIntMap
|
|
pub fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} }
|
|
|
|
pub fn get<'a>(&'a self, key: &uint) -> &'a V {
|
|
self.find(key).expect("key not present")
|
|
}
|
|
|
|
/// An iterator visiting all key-value pairs in ascending order by the keys.
|
|
/// Iterator element type is (uint, &'r V)
|
|
pub fn iter<'r>(&'r self) -> SmallIntMapIterator<'r, V> {
|
|
SmallIntMapIterator {
|
|
front: 0,
|
|
back: self.v.len(),
|
|
iter: self.v.iter()
|
|
}
|
|
}
|
|
|
|
/// An iterator visiting all key-value pairs in ascending order by the keys,
|
|
/// with mutable references to the values
|
|
/// Iterator element type is (uint, &'r mut V)
|
|
pub fn mut_iter<'r>(&'r mut self) -> SmallIntMapMutIterator<'r, V> {
|
|
SmallIntMapMutIterator {
|
|
front: 0,
|
|
back: self.v.len(),
|
|
iter: self.v.mut_iter()
|
|
}
|
|
}
|
|
|
|
/// An iterator visiting all key-value pairs in descending order by the keys.
|
|
/// Iterator element type is (uint, &'r V)
|
|
pub fn rev_iter<'r>(&'r self) -> SmallIntMapRevIterator<'r, V> {
|
|
self.iter().invert()
|
|
}
|
|
|
|
/// An iterator visiting all key-value pairs in descending order by the keys,
|
|
/// with mutable references to the values
|
|
/// Iterator element type is (uint, &'r mut V)
|
|
pub fn mut_rev_iter<'r>(&'r mut self) -> SmallIntMapMutRevIterator <'r, V> {
|
|
self.mut_iter().invert()
|
|
}
|
|
|
|
/// Empties the hash map, moving all values into the specified closure
|
|
pub fn move_iter(&mut self)
|
|
-> FilterMap<(uint, Option<V>), (uint, V),
|
|
Enumerate<vec::MoveIterator<Option<V>>>>
|
|
{
|
|
let values = replace(&mut self.v, ~[]);
|
|
values.move_iter().enumerate().filter_map(|(i, v)| {
|
|
v.map_move(|v| (i, v))
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<V:Clone> SmallIntMap<V> {
|
|
pub fn update_with_key(&mut self, key: uint, val: V,
|
|
ff: &fn(uint, V, V) -> V) -> bool {
|
|
let new_val = match self.find(&key) {
|
|
None => val,
|
|
Some(orig) => ff(key, (*orig).clone(), val)
|
|
};
|
|
self.insert(key, new_val)
|
|
}
|
|
|
|
pub fn update(&mut self, key: uint, newval: V, ff: &fn(V, V) -> V)
|
|
-> bool {
|
|
self.update_with_key(key, newval, |_k, v, v1| ff(v,v1))
|
|
}
|
|
}
|
|
|
|
|
|
macro_rules! iterator {
|
|
(impl $name:ident -> $elem:ty, $getter:ident) => {
|
|
impl<'self, T> Iterator<$elem> for $name<'self, T> {
|
|
#[inline]
|
|
fn next(&mut self) -> Option<$elem> {
|
|
while self.front < self.back {
|
|
match self.iter.next() {
|
|
Some(elem) => {
|
|
if elem.is_some() {
|
|
let index = self.front;
|
|
self.front += 1;
|
|
return Some((index, elem. $getter ()));
|
|
}
|
|
}
|
|
_ => ()
|
|
}
|
|
self.front += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> (uint, Option<uint>) {
|
|
(0, Some(self.back - self.front))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! double_ended_iterator {
|
|
(impl $name:ident -> $elem:ty, $getter:ident) => {
|
|
impl<'self, T> DoubleEndedIterator<$elem> for $name<'self, T> {
|
|
#[inline]
|
|
fn next_back(&mut self) -> Option<$elem> {
|
|
while self.front < self.back {
|
|
match self.iter.next_back() {
|
|
Some(elem) => {
|
|
if elem.is_some() {
|
|
self.back -= 1;
|
|
return Some((self.back, elem. $getter ()));
|
|
}
|
|
}
|
|
_ => ()
|
|
}
|
|
self.back -= 1;
|
|
}
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct SmallIntMapIterator<'self, T> {
|
|
priv front: uint,
|
|
priv back: uint,
|
|
priv iter: VecIterator<'self, Option<T>>
|
|
}
|
|
|
|
iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref)
|
|
double_ended_iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref)
|
|
pub type SmallIntMapRevIterator<'self, T> = Invert<SmallIntMapIterator<'self, T>>;
|
|
|
|
pub struct SmallIntMapMutIterator<'self, T> {
|
|
priv front: uint,
|
|
priv back: uint,
|
|
priv iter: VecMutIterator<'self, Option<T>>
|
|
}
|
|
|
|
iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref)
|
|
double_ended_iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref)
|
|
pub type SmallIntMapMutRevIterator<'self, T> = Invert<SmallIntMapMutIterator<'self, T>>;
|
|
|
|
#[cfg(test)]
|
|
mod test_map {
|
|
|
|
use super::SmallIntMap;
|
|
|
|
#[test]
|
|
fn test_find_mut() {
|
|
let mut m = SmallIntMap::new();
|
|
assert!(m.insert(1, 12));
|
|
assert!(m.insert(2, 8));
|
|
assert!(m.insert(5, 14));
|
|
let new = 100;
|
|
match m.find_mut(&5) {
|
|
None => fail!(), Some(x) => *x = new
|
|
}
|
|
assert_eq!(m.find(&5), Some(&new));
|
|
}
|
|
|
|
#[test]
|
|
fn test_len() {
|
|
let mut map = SmallIntMap::new();
|
|
assert_eq!(map.len(), 0);
|
|
assert!(map.is_empty());
|
|
assert!(map.insert(5, 20));
|
|
assert_eq!(map.len(), 1);
|
|
assert!(!map.is_empty());
|
|
assert!(map.insert(11, 12));
|
|
assert_eq!(map.len(), 2);
|
|
assert!(!map.is_empty());
|
|
assert!(map.insert(14, 22));
|
|
assert_eq!(map.len(), 3);
|
|
assert!(!map.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_clear() {
|
|
let mut map = SmallIntMap::new();
|
|
assert!(map.insert(5, 20));
|
|
assert!(map.insert(11, 12));
|
|
assert!(map.insert(14, 22));
|
|
map.clear();
|
|
assert!(map.is_empty());
|
|
assert!(map.find(&5).is_none());
|
|
assert!(map.find(&11).is_none());
|
|
assert!(map.find(&14).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_insert_with_key() {
|
|
let mut map = SmallIntMap::new();
|
|
|
|
// given a new key, initialize it with this new count, given
|
|
// given an existing key, add more to its count
|
|
fn addMoreToCount(_k: uint, v0: uint, v1: uint) -> uint {
|
|
v0 + v1
|
|
}
|
|
|
|
fn addMoreToCount_simple(v0: uint, v1: uint) -> uint {
|
|
v0 + v1
|
|
}
|
|
|
|
// count integers
|
|
map.update(3, 1, addMoreToCount_simple);
|
|
map.update_with_key(9, 1, addMoreToCount);
|
|
map.update(3, 7, addMoreToCount_simple);
|
|
map.update_with_key(5, 3, addMoreToCount);
|
|
map.update_with_key(3, 2, addMoreToCount);
|
|
|
|
// check the total counts
|
|
assert_eq!(map.find(&3).unwrap(), &10);
|
|
assert_eq!(map.find(&5).unwrap(), &3);
|
|
assert_eq!(map.find(&9).unwrap(), &1);
|
|
|
|
// sadly, no sevens were counted
|
|
assert!(map.find(&7).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_swap() {
|
|
let mut m = SmallIntMap::new();
|
|
assert_eq!(m.swap(1, 2), None);
|
|
assert_eq!(m.swap(1, 3), Some(2));
|
|
assert_eq!(m.swap(1, 4), Some(3));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pop() {
|
|
let mut m = SmallIntMap::new();
|
|
m.insert(1, 2);
|
|
assert_eq!(m.pop(&1), Some(2));
|
|
assert_eq!(m.pop(&1), None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_iterator() {
|
|
let mut m = SmallIntMap::new();
|
|
|
|
assert!(m.insert(0, 1));
|
|
assert!(m.insert(1, 2));
|
|
assert!(m.insert(3, 5));
|
|
assert!(m.insert(6, 10));
|
|
assert!(m.insert(10, 11));
|
|
|
|
let mut it = m.iter();
|
|
assert_eq!(it.size_hint(), (0, Some(11)));
|
|
assert_eq!(it.next().unwrap(), (0, &1));
|
|
assert_eq!(it.size_hint(), (0, Some(10)));
|
|
assert_eq!(it.next().unwrap(), (1, &2));
|
|
assert_eq!(it.size_hint(), (0, Some(9)));
|
|
assert_eq!(it.next().unwrap(), (3, &5));
|
|
assert_eq!(it.size_hint(), (0, Some(7)));
|
|
assert_eq!(it.next().unwrap(), (6, &10));
|
|
assert_eq!(it.size_hint(), (0, Some(4)));
|
|
assert_eq!(it.next().unwrap(), (10, &11));
|
|
assert_eq!(it.size_hint(), (0, Some(0)));
|
|
assert!(it.next().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_iterator_size_hints() {
|
|
let mut m = SmallIntMap::new();
|
|
|
|
assert!(m.insert(0, 1));
|
|
assert!(m.insert(1, 2));
|
|
assert!(m.insert(3, 5));
|
|
assert!(m.insert(6, 10));
|
|
assert!(m.insert(10, 11));
|
|
|
|
assert_eq!(m.iter().size_hint(), (0, Some(11)));
|
|
assert_eq!(m.rev_iter().size_hint(), (0, Some(11)));
|
|
assert_eq!(m.mut_iter().size_hint(), (0, Some(11)));
|
|
assert_eq!(m.mut_rev_iter().size_hint(), (0, Some(11)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_mut_iterator() {
|
|
let mut m = SmallIntMap::new();
|
|
|
|
assert!(m.insert(0, 1));
|
|
assert!(m.insert(1, 2));
|
|
assert!(m.insert(3, 5));
|
|
assert!(m.insert(6, 10));
|
|
assert!(m.insert(10, 11));
|
|
|
|
for (k, v) in m.mut_iter() {
|
|
*v += k as int;
|
|
}
|
|
|
|
let mut it = m.iter();
|
|
assert_eq!(it.next().unwrap(), (0, &1));
|
|
assert_eq!(it.next().unwrap(), (1, &3));
|
|
assert_eq!(it.next().unwrap(), (3, &8));
|
|
assert_eq!(it.next().unwrap(), (6, &16));
|
|
assert_eq!(it.next().unwrap(), (10, &21));
|
|
assert!(it.next().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_rev_iterator() {
|
|
let mut m = SmallIntMap::new();
|
|
|
|
assert!(m.insert(0, 1));
|
|
assert!(m.insert(1, 2));
|
|
assert!(m.insert(3, 5));
|
|
assert!(m.insert(6, 10));
|
|
assert!(m.insert(10, 11));
|
|
|
|
let mut it = m.rev_iter();
|
|
assert_eq!(it.next().unwrap(), (10, &11));
|
|
assert_eq!(it.next().unwrap(), (6, &10));
|
|
assert_eq!(it.next().unwrap(), (3, &5));
|
|
assert_eq!(it.next().unwrap(), (1, &2));
|
|
assert_eq!(it.next().unwrap(), (0, &1));
|
|
assert!(it.next().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_mut_rev_iterator() {
|
|
let mut m = SmallIntMap::new();
|
|
|
|
assert!(m.insert(0, 1));
|
|
assert!(m.insert(1, 2));
|
|
assert!(m.insert(3, 5));
|
|
assert!(m.insert(6, 10));
|
|
assert!(m.insert(10, 11));
|
|
|
|
for (k, v) in m.mut_rev_iter() {
|
|
*v += k as int;
|
|
}
|
|
|
|
let mut it = m.iter();
|
|
assert_eq!(it.next().unwrap(), (0, &1));
|
|
assert_eq!(it.next().unwrap(), (1, &3));
|
|
assert_eq!(it.next().unwrap(), (3, &8));
|
|
assert_eq!(it.next().unwrap(), (6, &16));
|
|
assert_eq!(it.next().unwrap(), (10, &21));
|
|
assert!(it.next().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_move_iter() {
|
|
let mut m = SmallIntMap::new();
|
|
m.insert(1, ~2);
|
|
let mut called = false;
|
|
for (k, v) in m.move_iter() {
|
|
assert!(!called);
|
|
called = true;
|
|
assert_eq!(k, 1);
|
|
assert_eq!(v, ~2);
|
|
}
|
|
assert!(called);
|
|
m.insert(2, ~1);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod bench {
|
|
|
|
use super::*;
|
|
use test::BenchHarness;
|
|
use container::bench::*;
|
|
|
|
// Find seq
|
|
#[bench]
|
|
pub fn insert_rand_100(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
insert_rand_n(100, &mut m, bh);
|
|
}
|
|
|
|
#[bench]
|
|
pub fn insert_rand_10_000(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
insert_rand_n(10_000, &mut m, bh);
|
|
}
|
|
|
|
// Insert seq
|
|
#[bench]
|
|
pub fn insert_seq_100(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
insert_seq_n(100, &mut m, bh);
|
|
}
|
|
|
|
#[bench]
|
|
pub fn insert_seq_10_000(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
insert_seq_n(10_000, &mut m, bh);
|
|
}
|
|
|
|
// Find rand
|
|
#[bench]
|
|
pub fn find_rand_100(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
find_rand_n(100, &mut m, bh);
|
|
}
|
|
|
|
#[bench]
|
|
pub fn find_rand_10_000(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
find_rand_n(10_000, &mut m, bh);
|
|
}
|
|
|
|
// Find seq
|
|
#[bench]
|
|
pub fn find_seq_100(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
find_seq_n(100, &mut m, bh);
|
|
}
|
|
|
|
#[bench]
|
|
pub fn find_seq_10_000(bh: &mut BenchHarness) {
|
|
let mut m : SmallIntMap<uint> = SmallIntMap::new();
|
|
find_seq_n(10_000, &mut m, bh);
|
|
}
|
|
}
|