Actually, the message format is LLSD notation not python (d'oh)

2023-11-10 14:25:34 +00:00
parent 72d4eff2d8
commit 3c69b8f05e
26 changed files with 792 additions and 682 deletions
--- a/lib/classes/llsd/LLSDMap.ts
+++ b/lib/classes/llsd/LLSDMap.ts
@@ -0,0 +1,115 @@
+import { LLSDObject } from './LLSDObject';
+import { LLSDTokenGenerator } from './LLSDTokenGenerator';
+import { LLSDTokenType } from './LLSDTokenType';
+import { LLSDNotationParser } from './LLSDNotationParser';
+import { LLSDType } from './LLSDType';
+
+export class LLSDMap extends LLSDObject
+{
+    public data: Map<LLSDType, LLSDType> = new Map<LLSDType, LLSDType>();
+
+    public static parse(gen: LLSDTokenGenerator): LLSDMap
+    {
+        const m = new LLSDMap();
+        let expectsKey = true
+        let key: LLSDType | undefined = undefined;
+        let value: LLSDType | undefined = undefined;
+        while (true)
+        {
+            const token = gen();
+            if (token === undefined)
+            {
+                throw new Error('Unexpected end of input in map');
+            }
+            switch (token.type)
+            {
+                case LLSDTokenType.WHITESPACE:
+                {
+                    continue;
+                }
+                case LLSDTokenType.MAP_END:
+                {
+                    if (expectsKey)
+                    {
+                        throw new Error('Unexpected end of map');
+                    }
+                    if (key !== undefined && value !== undefined)
+                    {
+                        m.data.set(key, value);
+                    }
+                    else if (m.data.size > 0)
+                    {
+                        throw new Error('Expected value before end of map');
+                    }
+                    return m;
+                }
+                case LLSDTokenType.COLON:
+                {
+                    if (!expectsKey)
+                    {
+                        throw new Error('Unexpected symbol: :');
+                    }
+                    if (key === undefined)
+                    {
+                        throw new Error('Empty key not allowed');
+                    }
+                    expectsKey = false;
+                    continue;
+                }
+                case LLSDTokenType.COMMA:
+                {
+                    if (expectsKey)
+                    {
+                        throw new Error('Empty map entry not allowed');
+                    }
+                    if (value === undefined)
+                    {
+                        throw new Error('Empty map value not allowed');
+                    }
+                    if (key !== undefined)
+                    {
+                        m.data.set(key, value);
+                    }
+                    key = undefined;
+                    value = undefined;
+                    expectsKey = true;
+                    continue;
+                }
+            }
+
+            if (expectsKey && key !== undefined)
+            {
+                throw new Error('Colon expected');
+            }
+            else if (value !== undefined)
+            {
+                throw new Error('Comma or end brace expected');
+            }
+
+            const val = LLSDNotationParser.parseValueToken(gen, token);
+            if (expectsKey)
+            {
+                key = val;
+            }
+            else
+            {
+                value = val;
+            }
+        }
+    }
+
+    get length(): number
+    {
+        return Object.keys(this.data).length;
+    }
+
+    public get(key: LLSDType): LLSDType | undefined
+    {
+        return this.data.get(key);
+    }
+
+    public toJSON(): unknown
+    {
+        return Object.fromEntries(this.data);
+    }
+}