Skip to content

Commit

Permalink
impl-ify map
Browse files Browse the repository at this point in the history
  • Loading branch information
@nikomatsakis
nikomatsakis committed May 22, 2012
1 parent 073f90c commit 83ee4ac
Showing 1 changed file with 134 additions and 146 deletions.
280 changes: 134 additions & 146 deletions src/libstd/map.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,6 +69,8 @@ iface map<K: copy, V: copy> {
// FIXME: package this up and export it as a datatype usable for
// external code that doesn't want to pay the cost of a box. (#2344)
mod chained {
export t, mk, hashmap;

type entry<K, V> = {
hash: uint,
key: K,
Expand All @@ -94,186 +96,172 @@ mod chained {
found_after(@entry<K,V>, @entry<K,V>)
}

fn search_rem<K: copy, V: copy>(
tbl: t<K,V>, k: K, h: uint, idx: uint,
e_root: @entry<K,V>) -> search_result<K,V> {
let mut e0 = e_root;
let mut comp = 1u; // for logging
loop {
alt e0.next {
impl private_methods<K: copy, V: copy> for t<K, V> {
fn search_rem(k: K, h: uint, idx: uint,
e_root: @entry<K,V>) -> search_result<K,V> {
let mut e0 = e_root;
let mut comp = 1u; // for logging
loop {
alt e0.next {
absent {
#debug("search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx);
ret not_found;
}
present(e1) {
comp += 1u;
let e1_key = e1.key; // Satisfy alias checker.
if e1.hash == h && self.eqer(e1_key, k) {
#debug("search_tbl: present, comp %u, \
hash %u, idx %u",
comp, h, idx);
ret found_after(e0, e1);
} else {
e0 = e1;
}
}
}
};
}

fn search_tbl(k: K, h: uint) -> search_result<K,V> {
let idx = h % vec::len(self.chains);
alt self.chains[idx] {
absent {
#debug("search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx);
0u, h, idx);
ret not_found;
}
present(e1) {
comp += 1u;
let e1_key = e1.key; // Satisfy alias checker.
if e1.hash == h && tbl.eqer(e1_key, k) {
present(e) {
// FIXME: This copy of the key is not good for perf
if e.hash == h && self.eqer(copy e.key, k) {
#debug("search_tbl: present, comp %u, hash %u, idx %u",
comp, h, idx);
ret found_after(e0, e1);
1u, h, idx);
ret found_first(idx, e);
} else {
e0 = e1;
ret self.search_rem(k, h, idx, e);
}
}
}
};
}

fn search_tbl<K: copy, V: copy>(
tbl: t<K,V>, k: K, h: uint) -> search_result<K,V> {
let idx = h % vec::len(tbl.chains);
alt tbl.chains[idx] {
absent {
#debug("search_tbl: absent, comp %u, hash %u, idx %u",
0u, h, idx);
ret not_found;
}
present(e) {
// FIXME: This copy of the key is not good for perf
if e.hash == h && tbl.eqer(copy e.key, k) {
#debug("search_tbl: present, comp %u, hash %u, idx %u",
1u, h, idx);
ret found_first(idx, e);
} else {
ret search_rem(tbl, k, h, idx, e);
}
}
}
}

fn insert<K: copy, V: copy>(tbl: t<K,V>, k: K, v: V) -> bool {
let hash = tbl.hasher(k);
alt search_tbl(tbl, k, hash) {
not_found {
tbl.count += 1u;
let idx = hash % vec::len(tbl.chains);
let old_chain = tbl.chains[idx];
tbl.chains[idx] = present(@{
hash: hash,
key: k,
mut value: v,
mut next: old_chain});
ret true;
}
found_first(_, entry) {
entry.value = v;
ret false;
}
found_after(_, entry) {
entry.value = v;
ret false
}
}
}

fn get<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option<V> {
alt search_tbl(tbl, k, tbl.hasher(k)) {
not_found {
ret core::option::none;
}

found_first(_, entry) {
ret core::option::some(entry.value);
}

found_after(_, entry) {
ret core::option::some(entry.value);
}
}
}

fn remove<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option<V> {
alt search_tbl(tbl, k, tbl.hasher(k)) {
not_found {
ret core::option::none;
}

found_first(idx, entry) {
tbl.count -= 1u;
tbl.chains[idx] = entry.next;
ret core::option::some(entry.value);
}

found_after(eprev, entry) {
tbl.count -= 1u;
eprev.next = entry.next;
ret core::option::some(entry.value);
}
fn rehash() {
let n_old_chains = vec::len(self.chains);
let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u);
let new_chains = chains(n_new_chains);
for self.each_entry {|entry|
let idx = entry.hash % n_new_chains;
entry.next = new_chains[idx];
new_chains[idx] = present(entry);
}
self.chains = new_chains;
}
}

fn chains<K: copy, V: copy>(nchains: uint) -> [mut chain<K,V>] {
ret vec::to_mut(vec::from_elem(nchains, absent));
}

fn each_entry<K: copy, V: copy>(tbl: t<K, V>,
blk: fn(@entry<K,V>) -> bool) {
let mut i = 0u, n = vec::len(tbl.chains);
while i < n {
let mut chain = tbl.chains[i];
loop {
chain = alt chain {
absent { break; }
present(entry) {
let next = entry.next;
if !blk(entry) { ret; }
next
}
fn each_entry(blk: fn(@entry<K,V>) -> bool) {
let mut i = 0u, n = vec::len(self.chains);
while i < n {
let mut chain = self.chains[i];
loop {
chain = alt chain {
absent { break; }
present(entry) {
let next = entry.next;
if !blk(entry) { ret; }
next
}
}
}
i += 1u;
}
i += 1u;
}
}

fn rehash<K: copy, V: copy>(tbl: t<K,V>) {
let n_old_chains = vec::len(tbl.chains);
let n_new_chains: uint = uint::next_power_of_two(n_old_chains + 1u);
let new_chains = chains(n_new_chains);
for each_entry(tbl) {|entry|
let idx = entry.hash % n_new_chains;
entry.next = new_chains[idx];
new_chains[idx] = present(entry);
}
tbl.chains = new_chains;
}

fn each<K: copy, V: copy>(tbl: t<K,V>, blk: fn(K,V) -> bool) {
for each_entry(tbl) {|entry|
if !blk(copy entry.key, copy entry.value) { break; }
}
}

impl hashmap<K: copy, V: copy> of map<K, V> for t<K, V> {
fn size() -> uint { self.count }

fn contains_key(k: K) -> bool {
let hash = self.hasher(k);
alt self.search_tbl(k, hash) {
not_found {false}
found_first(*) | found_after(*) {true}
}
}

fn insert(k: K, v: V) -> bool {
let grew = insert(self, k, v);
if grew {
let hash = self.hasher(k);
alt self.search_tbl(k, hash) {
not_found {
self.count += 1u;
let idx = hash % vec::len(self.chains);
let old_chain = self.chains[idx];
self.chains[idx] = present(@{
hash: hash,
key: k,
mut value: v,
mut next: old_chain});

// consider rehashing if more 3/4 full
let nchains = vec::len(self.chains);
let load = {num: (self.count + 1u) as int,
den: nchains as int};
// Structural consts would be nice. This is a const 3/4
// load factor that we compare against.
if !util::rational_leq(load, {num:3, den:4}) { rehash(self); }
if !util::rational_leq(load, {num:3, den:4}) {
self.rehash();
}

ret true;
}
found_first(_, entry) {
entry.value = v;
ret false;
}
found_after(_, entry) {
entry.value = v;
ret false
}
}
grew
}

fn contains_key(k: K) -> bool { option::is_some(get(self, k)) }
fn find(k: K) -> option<V> {
alt self.search_tbl(k, self.hasher(k)) {
not_found {none}
found_first(_, entry) {some(entry.value)}
found_after(_, entry) {some(entry.value)}
}
}

fn get(k: K) -> V { option::get(get(self, k)) }
fn get(k: K) -> V {
option::get(self.find(k))
}

fn find(k: K) -> option<V> { get(self, k) }
fn remove(k: K) -> option<V> {
alt self.search_tbl(k, self.hasher(k)) {
not_found {none}
found_first(idx, entry) {
self.count -= 1u;
self.chains[idx] = entry.next;
some(entry.value)
}
found_after(eprev, entry) {
self.count -= 1u;
eprev.next = entry.next;
some(entry.value)
}
}
}

fn remove(k: K) -> option<V> { remove(self, k) }
fn each(blk: fn(K,V) -> bool) {
for self.each_entry { |entry|
if !blk(copy entry.key, copy entry.value) { break; }
}
}

fn each(blk: fn(K, V) -> bool) { each(self, blk); }
fn each_key(blk: fn(K) -> bool) { self.each { |k, _v| blk(k)} }

fn each_key(blk: fn(K) -> bool) { each(self) { |k, _v| blk(k)} }
fn each_value(blk: fn(V) -> bool) { self.each { |_k, v| blk(v)} }
}

fn each_value(blk: fn(V) -> bool) { each(self) { |_k, v| blk(v)} }
fn chains<K,V>(nchains: uint) -> [mut chain<K,V>] {
ret vec::to_mut(vec::from_elem(nchains, absent));
}

fn mk<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>) -> t<K,V> {
Expand Down

0 comments on commit 83ee4ac

Please sign in to comment.