WIP checkpoint export/import

Author: micahscopes

src/data/collections/mutable/MutableArray.ts

@@ -215,6 +215,27 @@ class MutableArray<T> extends BaseCollection<T> implements Collection<T> {
         this._hashes   = [];
         this._ordinals = [];
     }
+    
+    exportMutableState() {
+        return {
+            _elementsPerOrdinal: this._elementsPerOrdinal.toLiteral(),
+            _ordinalsPerElement: this._ordinalsPerElement.toLiteral(),
+            _elements: Object.fromEntries(this._elements.entries()),
+            _currentInsertOpRefs: this._currentInsertOpRefs.toLiteral(),
+            _currentInsertOpOrds: Object.fromEntries(this._currentInsertOpOrds),
+        }
+    }
+    
+    importMutableState(state: any) {
+        this._elementsPerOrdinal = ArrayMap.fromLiteral<Ordinal, Hash>(state._elementsPerOrdinal);
+        this._ordinalsPerElement = ArrayMap.fromLiteral<Hash, Ordinal>(state._ordinalsPerElement);
+        this._elements = new Map(Object.entries(state._elements));
+        this._currentInsertOpRefs = DedupMultiMap.fromLiteral<Hash, HashReference<InsertOp<T>>>(state._currentInsertOpRefs);
+        this._currentInsertOpOrds = new Map(Object.entries(state._currentInsertOpOrds));
+        
+        this._needToRebuild = true;
+        this.rebuild();
+    }
 
     async insertAt(element: T, idx: number, author?: Identity) {
         await this.insertManyAt([element], idx, author);

src/data/collections/mutable/MutableSet.ts

@@ -2,11 +2,11 @@ import { MutableContentEvents } from '../../model/mutable/MutableObject';
 import { HashedObject } from '../../model/immutable/HashedObject';
 import { Hash } from '../../model/hashing/Hashing';
 import { MutationOp } from 'data/model/mutable/MutationOp';
-import { HashedSet } from 'data/model/immutable/HashedSet';
+import { HashedSet, HashedSetLiteralized } from 'data/model/immutable/HashedSet';
 import { HashReference } from 'data/model/immutable/HashReference';
 import { Logger, LogLevel } from 'util/logging';
 import { MultiMap } from 'util/multimap';
-import { ClassRegistry } from 'data/model';
+import { ClassRegistry, Context } from 'data/model';
 import { BaseCollection, Collection, CollectionConfig, CollectionOp } from './Collection';
 import { Identity } from 'data/identity';
 
@@ -209,14 +209,17 @@ class MutableSet<T> extends BaseCollection<T> implements Collection<T> {
 
     exportMutableState() {
         return {
-            _elements: this._elements,
-            _currentAddOpRefs: this._currentAddOpRefs
+            _elements: Object.fromEntries(this._elements.entries()),
+            _currentAddOpRefs: Object.fromEntries([...this._currentAddOpRefs.entries()].map(([key, value]) => [key, value.literalize()]))
         };
     }
 
-    importMutableState(state: any): void {
+    importMutableState(state: {
+        _elements: {[key: string]: T},
+        _currentAddOpRefs: {[key: string]: {value: HashedSetLiteralized }}
+    }): void {
         this._elements = new Map(Object.entries(state._elements));
-        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs));
+        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs).map(([key, value]) => [key, HashedSet.deliteralize(value, new Context())]));
     }
 
     async validate(references: Map<Hash, HashedObject>) {

src/data/model/immutable/HashedSet.ts

@@ -4,6 +4,11 @@ import { Context } from '../literals/Context';
 
 import { Dependency } from '../literals/LiteralUtils';
 
+export type HashedSetLiteralized = {
+    value: { _type: string, _hashes: string[], _elements: any[] },
+    dependencies: Map<Hash, Dependency>,
+}
+
 class HashedSet<T> {
 
     hashedElements : Map<Hash, T>;
@@ -84,7 +89,7 @@ class HashedSet<T> {
         return result;
     }
 
-    literalize(path='', context?: Context) : { value: any, dependencies : Map<Hash, Dependency> }  {
+    literalize(path='', context?: Context) : HashedSetLiteralized  {
 
         let dependencies = new Map<Hash, Dependency>();
 
@@ -98,7 +103,7 @@ class HashedSet<T> {
         let elements = child.value;
         HashedObject.collectChildDeps(dependencies, path, child.dependencies, true);
 
-        let value = {_type: 'hashed_set', _hashes: hashes, _elements: elements};
+        let value = {_type: 'hashed_set', _hashes: hashes, _elements: elements as any[]};
 
         return { value: value, dependencies: dependencies};
     }

src/data/model/mutable/MutableObject.ts

@@ -32,8 +32,8 @@ type MutableObjectConfig = {supportsUndo?: boolean, supportsCheckpoints?: boolea
 
 type StateCheckpoint = {
     mutableObject: Hash,
-    terminalOpHashes: Array<Hash>, 
-    allAppliedOps: Array<Hash>, 
+    terminalOpHashes: Array<Hash>,
+    allAppliedOps: Array<Hash>,
     activeCascInvsPerOp: Array<[Hash, Array<Hash>]>, 
     exportedState: any
 };

src/util/arraymap.ts

@@ -83,6 +83,38 @@ class ArrayMap<K, V> {
     entries() {
         return this.inner.entries();
     }
+    
+    toLiteral() {
+        const result : {
+            sorted: boolean,
+            inner: {[key: keyof any]: V[]},
+            size: number
+        } = {
+            sorted: this.sorted,
+            inner: {},
+            size: this.size
+        };
+        for (const [key, value] of this.inner) {
+            if (typeof key !== "string" && typeof key !== "number" && typeof key !== "symbol") {
+                throw new Error("This ArrayMap's key type isn't supported for literalization");
+            }
+            result.inner[key as keyof any] = value;
+        }
+        return result;
+    }
+    
+    static fromLiteral<K extends keyof any | string | number | symbol, V>(literal: {
+        sorted: boolean,
+        inner: {[key: keyof any]: V[]},
+        size: number
+    }) {
+        const result = new ArrayMap<K, V>(literal.sorted);
+        result.size = literal.size;
+        for (const key in literal.inner) {
+            result.inner.set(key as K, literal.inner[key]);
+        }
+        return result; 
+    }
 }
 
 export { ArrayMap };

src/util/dedupmultimap.ts

@@ -64,6 +64,32 @@ class DedupMultiMap<K, V> {
     keys() {
         return this.inner.keys();
     }
+
+    toLiteral() {
+        const result : {
+            inner: {[key: keyof any]: V[]},
+        } = {
+            inner: {},
+        };
+        for (const [key, value] of this.inner.entries()) {
+            if (typeof key !== "string" && typeof key !== "number" && typeof key !== "symbol") {
+                throw new Error("ArrayMap key type isn't supported for literalization");
+            }
+            result.inner[key as keyof any | number | string | symbol] = Array.from(value.values());
+        }
+        return result;
+    }
+    
+    static fromLiteral<K extends keyof any | string | number | symbol, V>(literal: {
+        inner: {[key: keyof any]: V[]},
+    }) {
+        const result = new DedupMultiMap<K, V>();
+        for (const key in literal.inner) {
+            const iter = literal.inner[key][Symbol.iterator]();
+            result.inner.set(key as K, new HashedSet(iter));
+        }
+        return result; 
+    }
 }
 
 export { DedupMultiMap };

test/data/checkpoints.test.ts

@@ -0,0 +1,38 @@
+// import the mutable types
+import { MutableReference } from 'data/collections/mutable/MutableReference';
+import { MutableSet } from 'data/collections/mutable/MutableSet';
+import { MutableArray } from 'data/collections/mutable/MutableArray';
+// import { GrowOnlySet } from 'index';
+
+describe('[CHK] Checkpoints', () => {
+    it('[CHK01] Exporting and importing MutableReference', () => {
+        const ref = new MutableReference();
+        ref.setValue(1);
+        expect(ref.getValue()).toBe(1);
+        const refState = ref.exportMutableState();
+        ref.setValue(2);
+        ref.importMutableState(refState);
+        expect(ref.getValue()).toBe(1);
+    });
+
+    it('[CHK02] Exporting and importing MutableSet', () => {
+        const set = new MutableSet<number>();
+        set.add(1);
+        expect([...set.values()]).toStrictEqual([1]);
+        const setState = set.exportMutableState();
+        set.add(2);
+        set.importMutableState(setState);
+        expect([...set.values()]).toStrictEqual([1]);
+    });
+
+    it('[CHK03] Exporting and importing MutableArray', () => {
+        const arr = new MutableArray<number>();
+        arr.push(1);
+        expect([...arr.values()]).toStrictEqual([1]);
+        const arrState = arr.exportMutableState();
+        arr.push(2);
+        arr.importMutableState(arrState);
+        expect([...arr.values()]).toStrictEqual([1]);
+    });
+    
+})