Some speed improvements

stdlib/map.krak

@@ -1,4 +1,5 @@
 import vector
+import mem
 import io
 import serialize
 import util
@@ -7,7 +8,7 @@ fun map<T,U>(): map<T,U> {
     var toRet.construct(): map<T,U>
     return toRet
 }
-fun map<T,U>(key:T, value:U): map<T,U> {
+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
@@ -26,9 +27,9 @@ obj map<T,U> (Object, Serializable) {
         keys.copy_construct(&old->keys)
         values.copy_construct(&old->values)
     }
-    fun operator=(rhs: map<T,U>) {
-        destruct()
-        copy_construct(&rhs)
+    fun operator=(rhs: ref map<T,U>) {
+        keys = rhs.keys
+        values = rhs.values
     }
     fun destruct() {
         keys.destruct()
@@ -38,9 +39,6 @@ obj map<T,U> (Object, Serializable) {
         return serialize::serialize(keys) + serialize::serialize(values)
     }
     fun unserialize(it: ref vector::vector<char>, pos: int): int {
-        /*construct()*/
-        /*util::unpack(keys, pos) = serialize::unserialize<vector::vector<T>>(it, pos)*/
-        /*util::unpack(values, pos) = serialize::unserialize<vector::vector<U>>(it, pos)*/
         pos = keys.unserialize(it, pos)
         pos = values.unserialize(it, pos)
         return pos
@@ -50,10 +48,10 @@ obj map<T,U> (Object, Serializable) {
     fun operator==<V>(other: ref map<T,V>): bool {
         return keys == other.keys && values == other.values
     }
-    fun operator[]=(key: T, value: U) {
+    fun operator[]=(key: ref T, value: ref U) {
         set(key,value)
     }
-    fun set(key: T, value: U) {
+    fun set(key: ref T, value: ref U) {
         var keyIdx = keys.find(key)
         if (keyIdx >= 0) {
             values.set(keyIdx, value)
@@ -62,32 +60,37 @@ obj map<T,U> (Object, Serializable) {
         keys.add(key)
         values.add(value)
     }
-    fun contains_key(key: T): bool {
+    fun contains_key(key: ref T): bool {
         return keys.contains(key)
     }
-    fun contains_value(value: U): bool {
+    fun contains_value(value: ref U): bool {
         return values.contains(value)
     }
-    fun get(key: T): ref U {
-        /*return values.get(keys.find(key))*/
+    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_with_default(key: T, default_val: ref U): ref U {
+    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: U): ref T {
+    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: T) {
+    fun remove(key: ref T) {
         var idx = keys.find(key)
         if (idx < 0)
             util::error("trying to remove nonexistant key-value!")
@@ -98,7 +101,7 @@ obj map<T,U> (Object, Serializable) {
         keys.clear()
         values.clear()
     }
-    fun operator[](key: T): ref U {
+    fun operator[](key: ref T): ref U {
         return get(key)
     }
     fun for_each(func: fun(T, U):void) {