Const initial_capacity

uint

Type T

type T<K: Eq IterBytes Hash, V> = @HashMap_<K, V>

Enum SearchResult

Variants

Struct Entry

struct Entry <K, V>{
    hash: uint,
    key: K,
    value: V,
    mut next: Option<@Entry<K, V>>,
}

Struct HashMap_

struct HashMap_ <K: Eq IterBytes Hash, V>{
    mut count: uint,
    mut chains: ~[mut Option<@Entry<K, V>>],
}

Implementation for T<K, V>

Method search_rem

fn search_rem(k: &K, h: uint, idx: uint, e_root: @Entry<K, V>) ->
 SearchResult<K, V>

Method search_tbl

fn search_tbl(k: &K, h: uint) -> SearchResult<K, V>

Method rehash

fn rehash()

Method each_entry

fn each_entry(blk: &fn(@Entry<K, V>) -> bool)

Implementation of Map<K, V> for T<K, V>

Method size

fn size() -> uint

Method contains_key

fn contains_key(k: K) -> bool

Method contains_key_ref

fn contains_key_ref(k: &K) -> bool

Method insert

fn insert(k: K, v: V) -> bool

Method find

fn find(k: K) -> Option<V>

Method update_with_key

fn update_with_key(key: K, newval: V, ff: &fn(K, V, V) -> V) -> bool

Method update

fn update(key: K, newval: V, ff: &fn(V, V) -> V) -> bool

Method get

fn get(k: K) -> V

Method remove

fn remove(k: K) -> bool

Method clear

fn clear()

Method each

fn each(blk: &fn(key: K, value: V) -> bool)

Method each_key

fn each_key(blk: &fn(key: K) -> bool)

Method each_value

fn each_value(blk: &fn(value: V) -> bool)

Method each_ref

fn each_ref(blk: &fn(key: &K, value: &V) -> bool)

Method each_key_ref

fn each_key_ref(blk: &fn(key: &K) -> bool)

Method each_value_ref

fn each_value_ref(blk: &fn(value: &V) -> bool)

Implementation for T<K, V>

Method to_writer

fn to_writer(wr: io::Writer)

Implementation of ToStr for T<K, V>

Method to_str

fn to_str() -> ~str

Implementation of ops::Index<K, V> for T<K, V>

Method index

fn index(k: K) -> V

Function chains

fn chains<K, V>(nchains: uint) -> ~[mut Option<@Entry<K, V>>]

Function mk

fn mk<K: Eq IterBytes Hash, V: Copy>() -> T<K, V>