2013-01-31 17:56:12 -06:00
|
|
|
// 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).
|
|
|
|
*/
|
|
|
|
|
|
|
|
use core::container::{Container, Mutable, Map, Set};
|
2013-02-07 19:20:39 -06:00
|
|
|
use core::iter::{BaseIter, ReverseIter};
|
2013-01-31 17:56:12 -06:00
|
|
|
use core::option::{Some, None};
|
|
|
|
use core::prelude::*;
|
|
|
|
|
2013-01-31 18:07:08 -06:00
|
|
|
pub struct SmallIntMap<T> {
|
|
|
|
priv v: ~[Option<T>],
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
2013-03-25 15:21:04 -05:00
|
|
|
impl<'self, V> BaseIter<(uint, &'self V)> for SmallIntMap<V> {
|
2013-02-07 18:13:24 -06:00
|
|
|
/// Visit all key-value pairs in order
|
2013-03-21 23:34:30 -05:00
|
|
|
fn each(&self, it: &fn(&(uint, &'self V)) -> bool) {
|
2013-02-07 18:13:24 -06:00
|
|
|
for uint::range(0, self.v.len()) |i| {
|
|
|
|
match self.v[i] {
|
|
|
|
Some(ref elt) => if !it(&(i, elt)) { break },
|
|
|
|
None => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-21 23:34:30 -05:00
|
|
|
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
|
2013-02-07 18:13:24 -06:00
|
|
|
}
|
|
|
|
|
2013-03-25 15:21:04 -05:00
|
|
|
impl<'self, V> ReverseIter<(uint, &'self V)> for SmallIntMap<V> {
|
2013-02-07 19:20:39 -06:00
|
|
|
/// Visit all key-value pairs in reverse order
|
2013-03-21 23:34:30 -05:00
|
|
|
fn each_reverse(&self, it: &fn(&(uint, &'self V)) -> bool) {
|
2013-02-07 19:20:39 -06:00
|
|
|
for uint::range_rev(self.v.len(), 0) |i| {
|
|
|
|
match self.v[i - 1] {
|
|
|
|
Some(ref elt) => if !it(&(i - 1, elt)) { break },
|
|
|
|
None => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl<V> Container for SmallIntMap<V> {
|
2013-01-31 17:56:12 -06:00
|
|
|
/// Return the number of elements in the map
|
2013-03-21 23:34:30 -05:00
|
|
|
fn len(&const self) -> uint {
|
2013-01-31 18:07:08 -06:00
|
|
|
let mut sz = 0;
|
2013-03-16 13:11:31 -05:00
|
|
|
for uint::range(0, vec::uniq_len(&const self.v)) |i| {
|
|
|
|
match self.v[i] {
|
|
|
|
Some(_) => sz += 1,
|
|
|
|
None => {}
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
sz
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return true if the map contains no elements
|
2013-03-21 23:34:30 -05:00
|
|
|
fn is_empty(&const self) -> bool { self.len() == 0 }
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl<V> Mutable for SmallIntMap<V> {
|
2013-01-31 18:07:08 -06:00
|
|
|
/// Clear the map, removing all key-value pairs.
|
|
|
|
fn clear(&mut self) { self.v.clear() }
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
2013-02-14 13:47:00 -06:00
|
|
|
impl<V> Map<uint, V> for SmallIntMap<V> {
|
2013-01-31 18:07:08 -06:00
|
|
|
/// Return true if the map contains a value for the specified key
|
2013-03-21 23:34:30 -05:00
|
|
|
fn contains_key(&self, key: &uint) -> bool {
|
2013-01-31 18:07:08 -06:00
|
|
|
self.find(key).is_some()
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
2013-01-31 18:07:08 -06:00
|
|
|
|
2013-02-07 18:13:24 -06:00
|
|
|
/// Visit all keys in order
|
2013-03-21 23:34:30 -05:00
|
|
|
fn each_key(&self, blk: &fn(key: &uint) -> bool) {
|
2013-02-07 18:13:24 -06:00
|
|
|
self.each(|&(k, _)| blk(&k))
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
2013-01-31 18:07:08 -06:00
|
|
|
|
2013-02-07 18:13:24 -06:00
|
|
|
/// Visit all values in order
|
2013-03-21 23:34:30 -05:00
|
|
|
fn each_value(&self, blk: &fn(value: &V) -> bool) {
|
2013-02-07 18:13:24 -06:00
|
|
|
self.each(|&(_, v)| blk(v))
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
2013-03-24 19:35:23 -05:00
|
|
|
/// Iterate over the map and mutate the contained values
|
2013-03-13 16:07:23 -05:00
|
|
|
fn mutate_values(&mut self, it: &fn(&uint, &'self mut V) -> bool) {
|
|
|
|
for uint::range(0, self.v.len()) |i| {
|
|
|
|
match self.v[i] {
|
|
|
|
Some(ref mut elt) => if !it(&i, elt) { break },
|
|
|
|
None => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-24 19:35:23 -05:00
|
|
|
/// Return a reference to the value corresponding to the key
|
2013-03-21 23:34:30 -05:00
|
|
|
fn find(&self, key: &uint) -> Option<&'self V> {
|
2013-01-31 18:07:08 -06:00
|
|
|
if *key < self.v.len() {
|
|
|
|
match self.v[*key] {
|
|
|
|
Some(ref value) => Some(value),
|
|
|
|
None => None
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
None
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-24 19:40:17 -05:00
|
|
|
/// Return a mutable reference to the value corresponding to the key
|
|
|
|
fn find_mut(&mut self, key: &uint) -> Option<&'self mut V> {
|
|
|
|
if *key < self.v.len() {
|
|
|
|
match self.v[*key] {
|
|
|
|
Some(ref mut value) => Some(value),
|
|
|
|
None => None
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-31 18:07:08 -06:00
|
|
|
/// 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 {
|
|
|
|
vec::grow_fn(&mut self.v, key - len + 1, |_| None);
|
|
|
|
}
|
|
|
|
self.v[key] = Some(value);
|
|
|
|
!exists
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 18:07:08 -06:00
|
|
|
/// 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 {
|
|
|
|
if *key >= self.v.len() {
|
|
|
|
return false;
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
2013-01-31 18:07:08 -06:00
|
|
|
let removed = self.v[*key].is_some();
|
|
|
|
self.v[*key] = None;
|
|
|
|
removed
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
2013-01-31 18:07:08 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
pub impl<V> SmallIntMap<V> {
|
|
|
|
/// Create an empty SmallIntMap
|
2013-03-21 23:34:30 -05:00
|
|
|
fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} }
|
2013-01-31 18:07:08 -06:00
|
|
|
|
2013-03-21 23:34:30 -05:00
|
|
|
fn get(&self, key: &uint) -> &'self V {
|
2013-01-31 18:07:08 -06:00
|
|
|
self.find(key).expect("key not present")
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
pub impl<V:Copy> SmallIntMap<V> {
|
2013-01-31 18:07:08 -06:00
|
|
|
fn update_with_key(&mut self, key: uint, val: V,
|
2013-03-07 16:38:38 -06:00
|
|
|
ff: &fn(uint, V, V) -> V) -> bool {
|
2013-02-09 00:21:45 -06:00
|
|
|
let new_val = match self.find(&key) {
|
|
|
|
None => val,
|
|
|
|
Some(orig) => ff(key, *orig, val)
|
|
|
|
};
|
|
|
|
self.insert(key, new_val)
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
2013-01-31 18:07:08 -06:00
|
|
|
|
2013-03-07 16:38:38 -06:00
|
|
|
fn update(&mut self, key: uint, newval: V, ff: &fn(V, V) -> V) -> bool {
|
2013-01-31 18:07:08 -06:00
|
|
|
self.update_with_key(key, newval, |_k, v, v1| ff(v,v1))
|
|
|
|
}
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2013-01-31 18:07:08 -06:00
|
|
|
use super::SmallIntMap;
|
2013-03-24 19:35:23 -05:00
|
|
|
use core::prelude::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_find_mut() {
|
|
|
|
let mut m = SmallIntMap::new();
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(m.insert(1, 12));
|
|
|
|
assert!(m.insert(2, 8));
|
|
|
|
assert!(m.insert(5, 14));
|
2013-03-24 19:35:23 -05:00
|
|
|
let new = 100;
|
|
|
|
match m.find_mut(&5) {
|
|
|
|
None => fail!(), Some(x) => *x = new
|
|
|
|
}
|
|
|
|
assert_eq!(m.find(&5), Some(&new));
|
|
|
|
}
|
2013-01-31 17:56:12 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_len() {
|
2013-01-31 18:07:08 -06:00
|
|
|
let mut map = SmallIntMap::new();
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(map.len() == 0);
|
|
|
|
assert!(map.is_empty());
|
|
|
|
assert!(map.insert(5, 20));
|
|
|
|
assert!(map.len() == 1);
|
|
|
|
assert!(!map.is_empty());
|
|
|
|
assert!(map.insert(11, 12));
|
|
|
|
assert!(map.len() == 2);
|
|
|
|
assert!(!map.is_empty());
|
|
|
|
assert!(map.insert(14, 22));
|
|
|
|
assert!(map.len() == 3);
|
|
|
|
assert!(!map.is_empty());
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_clear() {
|
2013-01-31 18:07:08 -06:00
|
|
|
let mut map = SmallIntMap::new();
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(map.insert(5, 20));
|
|
|
|
assert!(map.insert(11, 12));
|
|
|
|
assert!(map.insert(14, 22));
|
2013-01-31 17:56:12 -06:00
|
|
|
map.clear();
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(map.is_empty());
|
|
|
|
assert!(map.find(&5).is_none());
|
|
|
|
assert!(map.find(&11).is_none());
|
|
|
|
assert!(map.find(&14).is_none());
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_insert_with_key() {
|
2013-01-31 18:07:08 -06:00
|
|
|
let mut map = SmallIntMap::new();
|
2013-01-31 17:56:12 -06:00
|
|
|
|
|
|
|
// 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
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(map.find(&3).get() == &10);
|
|
|
|
assert!(map.find(&5).get() == &3);
|
|
|
|
assert!(map.find(&9).get() == &1);
|
2013-01-31 17:56:12 -06:00
|
|
|
|
|
|
|
// sadly, no sevens were counted
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(map.find(&7).is_none());
|
2013-01-31 17:56:12 -06:00
|
|
|
}
|
|
|
|
}
|