Serilization basics working

stdlib/serialize.krak

@@ -1,6 +1,11 @@
 import vector
 import conversions
 import mem
+import util
+
+fun serialize<T(Serializable)>(it: T): vector::vector<char> {
+    return it.serialize()
+}
 
 fun serialize<T>(it: T): vector::vector<char> {
     var char_data = conversions::cast_ptr<*T,*char>(&it)
@@ -10,8 +15,17 @@ fun serialize<T>(it: T): vector::vector<char> {
     return toRet
 }
 
-fun unserialize<T>(it: vector::vector<char>):T {
-    return *conversions::cast_ptr<*char,*T>(it.getBackingMemory())
+// dead simple wrapper for ease of use
+fun unserialize<T>(it: vector::vector<char>): T {
+    return unserialize<T>(it, 0).first
+}
+fun unserialize<T>(it: vector::vector<char>, pos: int): util::pair<T,int> {
+    return util::make_pair(*conversions::cast_ptr<*char,*T>(it.getBackingMemory()+pos), pos + mem::sizeof<T>())
+}
+fun unserialize<T(Serializable)>(it: vector::vector<char>, pos: int): util::pair<T,int> {
+    var toRet: T
+    pos = toRet.unserialize(it, pos)
+    return util::make_pair(toRet, pos)
 }
 
 

stdlib/util.krak

@@ -18,6 +18,23 @@ fun make_pair<T,U>(first: T, second: U): pair<T,U> {
     return it
 }
 
+// little ugly, but it works
+fun unpack<T,U>(first: ref T, second: ref U): unpack_dummy<T,U> {
+    var toRet: unpack_dummy<T,U>
+    toRet.first = &first
+    toRet.second = &second
+    return toRet
+}
+obj unpack_dummy<T,U> {
+    var first: *T
+    var second: *U
+    fun operator=(p: ref pair<T,U>) {
+        *first = p.first
+        *second = p.second
+    }
+}
+
+
 obj pair<T,U> (Object) {
     var first: T
     var second: U

stdlib/vector.krak

@@ -1,6 +1,8 @@
 import mem:*;
 import util:*;
 import io:*;
+import serialize:*;
+import util:*;
 
 fun vector<T>():vector<T> {
     var out.construct():vector<T>
@@ -13,7 +15,7 @@ fun vector<T>(in:T):vector<T> {
     return out
 }
 
-obj vector<T> (Object) {
+obj vector<T> (Object, Serializable) {
     var data: *T;
     var size: int;
     var available: int;
@@ -38,6 +40,23 @@ obj vector<T> (Object) {
             maybe_copy_construct(&data[i], &old->data[i]);
             //addEnd(old->get(i))
     }
+    fun serialize(): vector<char> {
+        var toRet = serialize(size)
+        for (var i = 0; i < size; i++;)
+            toRet += serialize(data[i])
+        return toRet
+    }
+    fun unserialize(it: vector<char>, pos: int): int {
+        unpack(size, pos) = unserialize<int>(it, pos)
+        data = new<T>(size)
+        available = size
+        for (var i = 0; i < size; i++;) {
+            var curr = unserialize<T>(it, pos)
+            pos = curr.second
+            maybe_copy_construct(&data[i], &curr.first);
+        }
+        return pos
+    }
 
     fun destruct(): void {
         if (data)