120 lines
3.2 KiB
Plaintext
120 lines
3.2 KiB
Plaintext
import vec
|
|
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: vec::vec<T>
|
|
var values: vec::vec<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(): vec::vec<char> {
|
|
return serialize::serialize(keys) + serialize::serialize(values)
|
|
}
|
|
fun unserialize(it: ref vec::vec<char>, pos: int): int {
|
|
pos = keys.unserialize(it, pos)
|
|
pos = values.unserialize(it, pos)
|
|
return pos
|
|
}
|
|
fun size(): int {
|
|
return keys.size
|
|
}
|
|
// 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<V>(value: ref V): 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<V>(value: ref V): 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])
|
|
}
|
|
fun for_each(func: fun(ref T, ref U):void) {
|
|
for (var i = 0; i < keys.size; i++;)
|
|
func(keys[i], values[i])
|
|
}
|
|
}
|
|
|