kraken/stdlib/map.krak

import vector
import mem
import io
import serialize
import util

fun map<T,U>(): map<T,U> {
    var toRet.construct(): map<T,U>
    return toRet
}
fun map<T,U>(key: ref T, value: ref U): map<T,U> {
    var toRet.construct(): map<T,U>
    toRet.set(key, value)
    return toRet
}

obj map<T,U> (Object, Serializable) {
    var keys: vector::vector<T>
    var values: vector::vector<U>

    fun construct(): *map<T,U> {
        keys.construct()
        values.construct()
        return this
    }
    fun copy_construct(old: *map<T,U>) {
        keys.copy_construct(&old->keys)
        values.copy_construct(&old->values)
    }
    fun operator=(rhs: ref map<T,U>) {
        keys = rhs.keys
        values = rhs.values
    }
    fun destruct() {
        keys.destruct()
        values.destruct()
    }
    fun serialize(): vector::vector<char> {
        return serialize::serialize(keys) + serialize::serialize(values)
    }
    fun unserialize(it: ref vector::vector<char>, pos: int): int {
        pos = keys.unserialize(it, pos)
        pos = values.unserialize(it, pos)
        return pos
    }
    // the old unnecessary template to prevent generation
    // if not used trick (in this case, changing out U with V)
    fun operator==<V>(other: ref map<T,V>): bool {
        return keys == other.keys && values == other.values
    }
    fun operator[]=(key: ref T, value: ref U) {
        set(key,value)
    }
    fun set(key: ref T, value: ref U) {
        var keyIdx = keys.find(key)
        if (keyIdx >= 0) {
            values.set(keyIdx, value)
            return;
        }
        keys.add(key)
        values.add(value)
    }
    fun contains_key(key: ref T): bool {
        return keys.contains(key)
    }
    fun contains_value(value: ref U): bool {
        return values.contains(value)
    }
    fun get(key: ref T): ref U {
        var key_loc = keys.find(key)
        if (key_loc == -1)
            util::error("trying to access nonexistant key-value!")
        return values.get(key_loc)
    }
    fun get_ptr_or_null(key: ref T): *U {
        var key_loc = keys.find(key)
        if (key_loc == -1)
            return mem::null<U>()
        return &values.get(key_loc)
    }
    fun get_with_default(key: ref T, default_val: ref U): ref U {
        if (contains_key(key))
            return get(key)
        return default_val
    }
    fun reverse_get(value: ref U): ref T {
        /*return values.get(keys.find(key))*/
        var value_loc = values.find(value)
        if (value_loc == -1)
            util::error("trying to access nonexistant value-key!")
        return keys.get(value_loc)
    }
    fun remove(key: ref T) {
        var idx = keys.find(key)
        if (idx < 0)
            util::error("trying to remove nonexistant key-value!")
        keys.remove(idx)
        values.remove(idx)
    }
    fun clear() {
        keys.clear()
        values.clear()
    }
    fun operator[](key: ref T): ref U {
        return get(key)
    }
    fun for_each(func: fun(T, U):void) {
        for (var i = 0; i < keys.size; i++;)
            func(keys[i], values[i])
    }
}