arrays

assembly/deserialize/array/array.ts

@@ -1,13 +1,47 @@
-import { fCode, tCode } from "../../src/chars";
-import { unsafeCharCodeAt } from "../../src/util";
+import { JSON } from "../..";
+import { fCode, leftBracketCode, rightBracketCode, tCode } from "../../src/chars";
+import { getArrayDepth, unsafeCharCodeAt } from "../../src/util";
+import { deserializeBooleanArray } from "./boolean";
+import { deserializeNumberArray } from "./number";
+import { deserializeStringArray } from "./string";
 
 /**
  * Deserialize a string to type array
  * @param data data to parse
  * @returns boolean
  */
 // @ts-ignore: Decorator
-@inline export function deserializeArray<T extends any[]>(data: string, start: i32 = 0, end = data.length): T {
-    if (start - end < 3) return instantiate<T>();
-
+@inline export function deserializeArray<T extends any[]>(data: string, start: i32 = 0, end: i32 = data.length): T {
+    console.log("data: " + data.slice(start, end))
+    if (isArray<T>() && end - start < 3) return instantiate<T>();
+    /*if (isString<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeStringArray(data);
+    } else if (isBoolean<valueof<T>>()) {
+        return deserializeBooleanArray<T>(data);
+    } else if (isInteger<valueof<T>>() || isFloat<valueof<T>>()) {
+        return deserializeNumberArray<T>(data);
+    } else if (idof<T>() === idof<JSON.Value[]>()) {*/
+    let result = instantiate<T>();
+    let lastPos: i32 = 0;
+    let depth: i32 = 0;
+    for (let i = start + 1; i < end - 1; i++) {
+        const char = unsafeCharCodeAt(data, i);
+        if (char === leftBracketCode) {
+            if (depth === 0) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth++;
+        } else if (char === rightBracketCode) {
+            depth--;
+            if (depth === 0) {
+                i++;
+                if (isArray<T>()) result.push(deserializeArray<valueof<T>>(data, lastPos, i));
+            }
+        }
+    }
+    //}
+
+    return instantiate<T>()
 }

assembly/deserialize/array/boolean.ts

@@ -3,7 +3,7 @@ import { unsafeCharCodeAt } from "../../src/util";
 import { deserializeBoolean } from "../boolean";
 
 // @ts-ignore: Decorator
-@inline export function deserializeooleanArray<T extends bool[]>(data: string): T {
+@inline export function deserializeBooleanArray<T extends bool[]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 1;
     for (let i = 1; i < data.length - 1; i++) {

assembly/deserialize/array/number.ts

@@ -0,0 +1,28 @@
+import { isSpace } from "util/string";
+import { commaCode, rightBracketCode } from "../../src/chars";
+import { unsafeCharCodeAt } from "../../src/util";
+import { deserializeNumber } from "../number";
+
+// @ts-ignore: Decorator
+@inline export function deserializeNumberArray<T extends number[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let i = 1;
+    for (; i < data.length - 1; i++) {
+        const char = unsafeCharCodeAt(data, i);
+        if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
+            lastPos = i;
+        } else if ((isSpace(char) || char == commaCode) && lastPos > 0) {
+            result.push(deserializeNumber<valueof<T>>(data, lastPos, i));
+            lastPos = 0;
+        }
+    }
+    for (; i > lastPos - 1; i--) {
+        const char = unsafeCharCodeAt(data, i);
+        if (char !== rightBracketCode) {
+            result.push(deserializeNumber<valueof<T>>(data, lastPos, i + 1));
+            break;
+        }
+    }
+    return result;
+}

assembly/deserialize/array/string.ts

@@ -7,7 +7,7 @@ import { deserializeString } from "../string";
     const result: string[] = [];
     let lastPos = 0;
     let instr = false;
-    let escaping = false;v 
+    let escaping = false;
     for (let i = 1; i < data.length - 1; i++) {
         const char = unsafeCharCodeAt(data, i);
         if (char === backSlashCode && !escaping) {

assembly/deserialize/number.ts

@@ -6,12 +6,12 @@ import { snip_fast } from "../src/util";
   end = end || data.length - 1;
   if (isInteger<T>()) {
     // @ts-ignore
-    return snip_fast<T>(data);
+    return snip_fast<T>(data.slice(start, end));
   }
   // @ts-ignore
   const type: T = 0;
   // @ts-ignore
-  if (type instanceof f64) return f64.parse(data);
+  if (type instanceof f64) return f64.parse(data.slice(start, end));
   // @ts-ignore
-  else if (type instanceof f32) return f32.parse(data);
+  else if (type instanceof f32) return f32.parse(data.slice(start, end));
 }

assembly/deserialize/string.ts

@@ -25,7 +25,7 @@ import { Sink } from "../src/sink";
   const firstChar = unsafeCharCodeAt(data, start);
   const lastChar = unsafeCharCodeAt(data, end);
   if (firstChar !== quoteCode || lastChar !== quoteCode) {
-    return abort(`Expected string to start and end with ", but got ${data.slice(0, 100)} instead!`);
+    throw new Error(`Expected string to start and end with ", but got ${data.slice(0, 100)} instead!`);
   }
   let last = start + 1;
   for (let i = last; i < end; i++) {
@@ -83,7 +83,7 @@ import { Sink } from "../src/sink";
         break;
       }
       default: {
-        return abort(`Cannot parse "${data.slice(0, 100)}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
+        throw new Error(`Cannot parse "${data.slice(0, 100)}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
       }
     }
   }

assembly/serialize/class.ts

@@ -0,0 +1,12 @@
+import { Sink } from "../src/sink";
+
+// @ts-ignore: Decorator
+@inline export function serializeClass<T>(data: T, out: Sink | null = null): Sink {
+    if (data) {
+        if (out) return out.write("true")!;
+        return Sink.fromStringLiteral("true");
+    } else {
+        if (out) return out.write("false")!;
+        return Sink.fromStringLiteral("false");
+    }
+}

assembly/test.ts

@@ -1,8 +1,12 @@
 import { JSON } from ".";
+import { deserializeArray } from "./deserialize/array/array";
+import { deserializeBooleanArray } from "./deserialize/array/boolean";
+import { deserializeNumberArray } from "./deserialize/array/number";
+import { deserializeStringArray } from "./deserialize/array/string";
 import { utoa32 } from "./serialize/integer";
 import { Sink } from "./src/sink";
 import { describe, expect } from "as-test/assembly";
-
+/*
 describe("Serialize String", () => {
     expect(JSON.serialize("hello world").toString()).toBe("\"hello world\"");
 });
@@ -123,4 +127,21 @@ map.set("z", JSON.Value.from<f64>(-5.6));
 
 describe("Serialize Maps", () => {
     expect(JSON.serialize(map).toString()).toBe("{\"x\":3.4,\"y\":1.2,\"z\":-5.6}");
+});
+*/
+
+describe("Deserialize String[]", () => {
+    expect(JSON.serialize(deserializeStringArray("[\"hello\",\"world\"]")).toString()).toBe("[\"hello\",\"world\"]");
+});
+
+describe("Deserialize Number[]", () => {
+    expect(JSON.serialize(deserializeNumberArray<i32[]>("[123,456]")).toString()).toBe("[123,456]");
+});
+
+describe("Deserialize Boolean[]", () => {
+    expect(JSON.serialize(deserializeBooleanArray<bool[]>("[true, false]")).toString()).toBe("[true,false]");
+});
+
+describe("Deserialize [][]", () => {
+    deserializeArray<JSON.Value[]>("[[[]],[[[]]]]")
 });