json-as 0.5.3 → 0.5.4

package/README.md

@@ -68,9 +68,9 @@ const parsed = JSON.parse<Player>(stringified);
 
 ## Performance
 
-**Serialize Object (Vec2):** ~7.29m ops/s
+**Serialize Object (Vec2):** ~7.20m ops/s
 
-**Deserialize Object (Vec2):** ~1.36m ops/s
+**Deserialize Object (Vec2):** ~2.2m ops/s
 
 **Serialize Array (int[4]):** ~1.4m ops/s
 

package/assembly/dynamic/dynamic.ts

@@ -0,0 +1,3 @@
+class Dynamic {
+    
+}

package/assembly/index.ts

@@ -1 +1 @@
-export { JSON } from "./json";
+export { JSON } from "./src/json";

package/assembly/{chars.ts → src/chars.ts}

@@ -1,3 +1,4 @@
+// Characters
 export const commaCode = ",".charCodeAt(0);
 export const quoteCode = '"'.charCodeAt(0);
 export const backSlashCode = "\\".charCodeAt(0);
@@ -16,3 +17,11 @@ export const aCode = "a".charCodeAt(0);
 export const lCode = "l".charCodeAt(0);
 export const sCode = "s".charCodeAt(0);
 export const nCode = "n".charCodeAt(0);
+// Strings
+export const trueWord = "true";
+export const falseWord = "false";
+export const nullWord = "null";
+export const leftBracketWord = "[";
+export const emptyArrayWord = "[]";
+export const commaWord = ",";
+export const rightBracketWord = "]";

package/assembly/src/json.ts

@@ -0,0 +1,455 @@
+import { StringSink } from "as-string-sink/assembly";
+import { isSpace } from "util/string";
+import {
+    backSlashCode,
+    commaCode,
+    commaWord,
+    eCode,
+    fCode,
+    leftBraceCode,
+    leftBracketCode,
+    leftBracketWord,
+    nCode,
+    nullWord,
+    quoteCode,
+    rCode,
+    rightBraceCode,
+    rightBracketCode,
+    rightBracketWord,
+    tCode,
+    trueWord,
+    uCode,
+    emptyArrayWord
+} from "./chars";
+import { unsafeCharCodeAt } from "./util";
+
+/**
+ * JSON Encoder/Decoder for AssemblyScript
+ */
+export class JSON {
+    /**
+     * Stringifies valid JSON data.
+     * ```js
+     * JSON.stringify<T>(data)
+     * ```
+     * @param data T
+     * @returns string
+     */
+    static stringify<T>(data: T): string {
+        // String
+        if (isString<T>()) {
+            return '"' + (<string>data).replaceAll('"', '\\"') + '"';
+        }
+        // Boolean
+        else if (isBoolean<T>()) {
+            return data ? "true" : "false";
+        }
+        // Nullable
+        else if (isNullable<T>() && data == null) {
+            return "null";
+        }
+        // Integers/Floats
+        // @ts-ignore
+        else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
+            // @ts-ignore
+            return data.toString();
+        }
+        // Class-Based serialization
+        // @ts-ignore
+        else if (isDefined(data.__JSON_Serialize)) {
+            // @ts-ignore
+            //if (isNullable<T>()) return "null";
+            // @ts-ignore
+            return data.__JSON_Serialize();
+        }
+        // ArrayLike
+        else if (isArrayLike<T>()) {
+            let result = new StringSink(leftBracketWord);
+            // @ts-ignore
+            if (data.length == 0) return emptyArrayWord;
+            // @ts-ignore
+            for (let i = 0; i < data.length - 1; i++) {
+                // @ts-ignore
+                result.write(JSON.stringify(unchecked(data[i])));
+                result.write(commaWord);
+            }
+            // @ts-ignore
+            result.write(JSON.stringify(unchecked(data[data.length - 1])));
+            result.write(rightBracketWord);
+            return result.toString();
+        } else {
+            throw new Error(`Could not serialize data of type ${nameof<T>()}. Invalid data provided.`);
+        }
+    }
+    /**
+     * Parses valid JSON strings into their original format.
+     * ```js
+     * JSON.parse<T>(data)
+     * ```
+     * @param data string
+     * @returns T
+     */
+    static parse<T>(data: string): T {
+        let type!: T;
+        if (isString<T>()) {
+            // @ts-ignore
+            return parseString(data);
+        } else if (isBoolean<T>()) {
+            // @ts-ignore
+            return parseBoolean<T>(data);
+        } else if (isFloat<T>() || isInteger<T>()) {
+            return parseNumber<T>(data);
+        } else if (isArrayLike<T>()) {
+            // @ts-ignore
+            return parseArray<T>(data.trimStart());
+            // @ts-ignore
+        } else if (isNullable<T>() && data == "null") {
+            // @ts-ignore
+            return null;
+            // @ts-ignore
+        } else if (isDefined(type.__JSON_Set_Key)) {
+            return parseObject<T>(data.trimStart());
+        } else {
+            // @ts-ignore
+            throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Invalide data provided.`);
+        }
+    }
+    private static parseObjectValue<T>(data: string): T {
+        let type!: T;
+        if (isString<T>()) {
+            // @ts-ignore
+            return data.replaceAll('\\"', '"');
+        } else if (isBoolean<T>()) {
+            // @ts-ignore
+            return parseBoolean<T>(data);
+        } else if (isFloat<T>() || isInteger<T>()) {
+            return parseNumber<T>(data);
+        } else if (isArrayLike<T>()) {
+            // @ts-ignore
+            return parseArray<T>(data);
+            // @ts-ignore
+        } else if (isNullable<T>() && data == "null") {
+            // @ts-ignore
+            return null;
+            // @ts-ignore
+        } else if (isDefined(type.__JSON_Set_Key)) {
+            // @ts-ignore
+            //if (isNullable<T>()) return null;
+            return parseObject<T>(data);
+        } else {
+            // @ts-ignore
+            //return null;
+            throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Invalide data provided.`)
+        }
+    }
+}
+
+// @ts-ignore
+@inline
+    function parseString(data: string): string {
+    return data.slice(1, data.length - 1).replaceAll('\\"', '"');
+}
+
+// @ts-ignore
+@inline
+    function parseBoolean<T extends boolean>(data: string): T {
+    if (data.length > 3 && data.startsWith("true")) return <T>true;
+    else if (data.length > 4 && data.startsWith("false")) return <T>false;
+    else throw new Error(`JSON: Cannot parse "${data}" as boolean`);
+}
+
+// @ts-ignore
+@inline
+    function parseNumber<T>(data: string): T {
+    let type: T;
+    // @ts-ignore
+    if (type instanceof f64) return F64.parseFloat(data);
+    // @ts-ignore
+    else if (type instanceof f32) return F32.parseFloat(data);
+    // @ts-ignore
+    else if (type instanceof u64) return U64.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u32) return U32.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u8) return U8.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u16) return U16.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i64) return I64.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i32) return I32.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i16) return I16.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i8) return I8.parseInt(data);
+    else
+        throw new Error(
+            `JSON: Cannot parse invalid data into a number. Either "${data}" is not a valid number, or <${nameof<T>()}> is an invald number type.`
+        );
+}
+
+// @ts-ignore
+@inline
+export function parseObject<T>(data: string): T {
+    let schema: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
+    let key = "";
+    let isKey = false;
+    let depth = 1;
+    let char = 0;
+    let outerLoopIndex = 1;
+    for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+        char = unsafeCharCodeAt(data, outerLoopIndex);
+        if (char === leftBracketCode) {
+            for (
+                let arrayValueIndex = outerLoopIndex;
+                arrayValueIndex < data.length - 1;
+                arrayValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, arrayValueIndex);
+                if (char === leftBracketCode) {
+                    depth = depth << 1;
+                } else if (char === rightBracketCode) {
+                    depth = depth >> 1;
+                    if (depth === 1) {
+                        ++arrayValueIndex;
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, arrayValueIndex));
+                        outerLoopIndex = arrayValueIndex;
+                        isKey = false;
+                        break;
+                    }
+                }
+            }
+        } else if (char === leftBraceCode) {
+            for (
+                let objectValueIndex = outerLoopIndex;
+                objectValueIndex < data.length - 1;
+                objectValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, objectValueIndex);
+                if (char === leftBraceCode) {
+                    depth = depth << 1;
+                } else if (char === rightBraceCode) {
+                    depth = depth >> 1;
+                    if (depth === 1) {
+                        ++objectValueIndex;
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, objectValueIndex));
+                        outerLoopIndex = objectValueIndex;
+                        isKey = false;
+                        break;
+                    }
+                }
+            }
+        } else if (char === quoteCode) {
+            for (
+                let stringValueIndex = ++outerLoopIndex;
+                stringValueIndex < data.length - 1;
+                stringValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, stringValueIndex);
+                if (
+                    char === quoteCode &&
+                    unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
+                ) {
+                    if (isKey === false) {
+                        key = data.slice(outerLoopIndex, stringValueIndex);
+                        isKey = true;
+                    } else {
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, stringValueIndex));
+                        isKey = false;
+                    }
+                    outerLoopIndex = ++stringValueIndex;
+                    break;
+                }
+            }
+        } else if (char == nCode) {
+            schema.__JSON_Set_Key(key, nullWord);
+            isKey = false;
+        } else if (
+            char === tCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            schema.__JSON_Set_Key(key, trueWord);
+            isKey = false;
+        } else if (
+            char === fCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "a".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "l".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "s".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            schema.__JSON_Set_Key(key, "false");
+            isKey = false;
+        } else if ((char >= 48 && char <= 57) || char === 45) {
+            let numberValueIndex = ++outerLoopIndex;
+            for (; numberValueIndex < data.length; numberValueIndex++) {
+                char = unsafeCharCodeAt(data, numberValueIndex);
+                if (char === commaCode || char === rightBraceCode || isSpace(char)) {
+                    schema.__JSON_Set_Key(key, data.slice(outerLoopIndex - 1, numberValueIndex));
+                    outerLoopIndex = numberValueIndex;
+                    isKey = false;
+                    break;
+                }
+            }
+        }
+    }
+    return schema;
+}
+
+// @ts-ignore
+@inline
+    // @ts-ignore
+    export function parseArray<T extends unknown[]>(data: string): T {
+    let type!: valueof<T>;
+    if (type instanceof String) {
+        return <T>parseStringArray(data);
+    } else if (isBoolean<valueof<T>>()) {
+        // @ts-ignore
+        return parseBooleanArray<T>(data);
+    } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+        // @ts-ignore
+        return parseNumberArray<T>(data);
+    } else if (isArrayLike<valueof<T>>()) {
+        // @ts-ignore
+        return parseArrayArray<T>(data);
+        // @ts-ignore
+    } else if (isDefined(type.__JSON_Set_Key)) {
+        // @ts-ignore
+        return parseObjectArray<T>(data);
+    }
+}
+
+// @ts-ignore
+@inline
+    export function parseStringArray(data: string): string[] {
+    const result: string[] = [];
+    let lastPos = 0;
+    let instr = false;
+    for (let i = 1; i < data.length - 1; i++) {
+        if (unsafeCharCodeAt(data, i) === quoteCode) {
+            if (instr === false) {
+                instr = true;
+                lastPos = i;
+            } else if (unsafeCharCodeAt(data, i - 1) !== backSlashCode) {
+                instr = false;
+                result.push(data.slice(lastPos + 1, i).replaceAll('\\"', '"'));
+            }
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseBooleanArray<T extends boolean[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 1;
+    let char = 0;
+    for (let i = 1; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        /*// if char == "t" && i+3 == "e"
+            if (char === tCode && data.charCodeAt(i + 3) === eCode) {
+              //i += 3;
+              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+2)));
+              //i++;
+            } else if (char === fCode && data.charCodeAt(i + 4) === eCode) {
+              //i += 4;
+              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+3)));
+              //i++;
+            }*/
+        if (char === tCode || char === fCode) {
+            lastPos = i;
+        } else if (char === eCode) {
+            i++;
+            result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i)));
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseNumberArray<T extends number[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let char = 0;
+    let i = 1;
+    for (; i < data.length - 1; i++) {
+        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(parseNumber<valueof<T>>(data.slice(lastPos, i)));
+            lastPos = 0;
+        }
+    }
+    for (; i > lastPos - 1; i--) {
+        char = unsafeCharCodeAt(data, i);
+        if (char !== rightBracketCode) {
+            result.push(parseNumber<valueof<T>>(data.slice(lastPos, i + 1)));
+            break;
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseArrayArray<T extends unknown[][]>(data: string): T {
+    const result = instantiate<T>();
+    let char = 0;
+    let lastPos = 0;
+    let depth = 1;
+    let i = 1;
+    // Find start of bracket
+    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
+    //i++;
+    for (; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        if (char === leftBracketCode) {
+            if (depth === 1) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth = depth << 1;
+        } else if (char === rightBracketCode) {
+            depth = depth >> 1;
+            if (depth === 1) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseObjectArray<T extends unknown[][]>(data: string): T {
+    const result = instantiate<T>();
+    let char = 0;
+    let lastPos = 1;
+    let depth = 1;
+    let i = 1;
+    // Find start of bracket
+    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) { }
+    //i++;
+    for (; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        if (char === leftBraceCode) {
+            if (depth === 1) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth = depth << 1;
+        } else if (char === rightBraceCode) {
+            depth = depth >> 1;
+            if (depth === 1) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}

package/index.ts

@@ -1 +1 @@
-export { JSON } from "./assembly/json";
+export { JSON } from "./assembly/src/json";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -29,7 +29,8 @@
     "typescript": "^4.7.2"
   },
   "dependencies": {
-    "as-string-sink": "^0.5.0"
+    "as-string-sink": "^0.5.0",
+    "as-variant": "^0.4.0"
   },
   "repository": {
     "type": "git",

package/transform/lib/index.js

@@ -6,9 +6,10 @@ class AsJSONTransform extends ClassDecorator {
         super(...arguments);
         this.sources = [];
         this.encodeStmts = [];
-        this.decodeStmts = [];
-        this.checkDecodeStmts = [];
+        //public decodeStmts: string[] = [];
+        this.setDataStmts = [];
     }
+    //public checkDecodeStmts: string[] = [];
     visitMethodDeclaration() { }
     visitFieldDeclaration(node) {
         const lineText = toString(node);
@@ -22,9 +23,19 @@ class AsJSONTransform extends ClassDecorator {
         // @ts-ignore
         this.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
         // @ts-ignore
-        this.decodeStmts.push(`${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`);
+        //this.decodeStmts.push(
+        //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
+        //);
         // @ts-ignore
-        this.checkDecodeStmts.push(' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n');
+        this.setDataStmts.push(`if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.${name} = JSON.parseObjectValue<${type}>(value);
+        return;
+      }
+      `);
+        // @ts-ignore
+        //this.checkDecodeStmts.push(
+        //  ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+        //);
     }
     visitClassDeclaration(node) {
         if (!node.members) {
@@ -38,7 +49,6 @@ class AsJSONTransform extends ClassDecorator {
             const stmt = this.encodeStmts[this.encodeStmts.length - 1];
             this.encodeStmts[this.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
             serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return \`{${this.encodeStmts.join("")}}\`;
       }
@@ -46,31 +56,50 @@ class AsJSONTransform extends ClassDecorator {
         }
         else {
             serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
-        const deserializeFunc = `
-    @inline
-    __JSON_Deserialize<T>(values: Map<string, string>): T {
-        ${process.argv.includes("--debugJSON") ? this.checkDecodeStmts.join("else") : ""}
-        return {
-          ${
-        // @ts-ignore
-        this.decodeStmts.join("")}
+        /*const deserializeFunc = `
+        __JSON_Deserialize<T>(values: Map<string, string>): T {
+            ${
+              process.argv.includes("--debugJSON")
+                ? this.checkDecodeStmts.join("else")
+                : ""
+            }
+            return {
+              ${
+                // @ts-ignore
+                this.decodeStmts.join("")
+              }
+            }
         }
-    }
+        `;*/
+        const setKeyFunc = `
+      __JSON_Set_Key(key: string, value: string): void {
+        ${
+        // @ts-ignore
+        this.setDataStmts.join("")}
+        throw new Error("Cannot find key: " + key);
+      }
     `;
+        //console.log(setKeyFunc, deserializeFunc, serializeFunc)
         this.encodeStmts = [];
-        this.decodeStmts = [];
+        //this.decodeStmts = [];
+        this.setDataStmts = [];
+        //this.checkDecodeStmts = [];
         const serializedProperty = SimpleParser.parseClassMember(serializedProp, node);
         node.members.push(serializedProperty);
         const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
         node.members.push(serializeMethod);
-        const deserializeMethod = SimpleParser.parseClassMember(deserializeFunc, node);
-        node.members.push(deserializeMethod);
+        //const deserializeMethod = SimpleParser.parseClassMember(
+        //  deserializeFunc,
+        //  node
+        //);
+        //node.members.push(deserializeMethod);
+        const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
+        node.members.push(setDataMethod);
     }
     get name() {
         return "json";

package/transform/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@json-as/transform",
-    "version": "0.5.3",
+    "version": "0.5.4",
     "description": "JSON encoder/decoder for AssemblyScript",
     "main": "./lib/index.js",
     "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -14,8 +14,9 @@ class AsJSONTransform extends ClassDecorator {
   public currentClass!: ClassDeclaration;
   public sources: Source[] = [];
   public encodeStmts: string[] = [];
-  public decodeStmts: string[] = [];
-  public checkDecodeStmts: string[] = [];
+  //public decodeStmts: string[] = [];
+  public setDataStmts: string[] = [];
+  //public checkDecodeStmts: string[] = [];
 
   visitMethodDeclaration(): void {}
   visitFieldDeclaration(node: FieldDeclaration): void {
@@ -33,14 +34,23 @@ class AsJSONTransform extends ClassDecorator {
     );
 
     // @ts-ignore
-    this.decodeStmts.push(
-      `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
-    );
+    //this.decodeStmts.push(
+   //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
+    //);
 
     // @ts-ignore
-    this.checkDecodeStmts.push(
-      ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+    this.setDataStmts.push(
+      `if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.${name} = JSON.parseObjectValue<${type}>(value);
+        return;
+      }
+      `
     );
+
+    // @ts-ignore
+    //this.checkDecodeStmts.push(
+    //  ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+    //);
   }
   visitClassDeclaration(node: ClassDeclaration): void {
     if (!node.members) {
@@ -62,21 +72,18 @@ class AsJSONTransform extends ClassDecorator {
         stmt.length - 1
       );
       serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return \`{${this.encodeStmts.join("")}}\`;
       }
       `;
     } else {
       serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
     }
-    const deserializeFunc = `
-    @inline
+    /*const deserializeFunc = `
     __JSON_Deserialize<T>(values: Map<string, string>): T {
         ${
           process.argv.includes("--debugJSON")
@@ -90,9 +97,21 @@ class AsJSONTransform extends ClassDecorator {
           }
         }
     }
-    `;
+    `;*/
+    const setKeyFunc = `
+      __JSON_Set_Key(key: string, value: string): void {
+        ${
+        // @ts-ignore
+        this.setDataStmts.join("")
+        }
+        throw new Error("Cannot find key: " + key);
+      }
+    `
+    //console.log(setKeyFunc, deserializeFunc, serializeFunc)
     this.encodeStmts = [];
-    this.decodeStmts = [];
+    //this.decodeStmts = [];
+    this.setDataStmts = [];
+    //this.checkDecodeStmts = [];
     const serializedProperty = SimpleParser.parseClassMember(
       serializedProp,
       node
@@ -102,11 +121,16 @@ class AsJSONTransform extends ClassDecorator {
     const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
     node.members.push(serializeMethod);
 
-    const deserializeMethod = SimpleParser.parseClassMember(
-      deserializeFunc,
+    //const deserializeMethod = SimpleParser.parseClassMember(
+    //  deserializeFunc,
+    //  node
+    //);
+    //node.members.push(deserializeMethod);
+    const setDataMethod = SimpleParser.parseClassMember(
+      setKeyFunc,
       node
     );
-    node.members.push(deserializeMethod);
+    node.members.push(setDataMethod);
   }
   get name(): string {
     return "json";