Merge pull request #44 from hyperhyperspace/checkpoints

WIP checkpoint export/import for mutable types

Author: sbazerque

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/MutableReference.ts

@@ -3,7 +3,7 @@ import { MutationOp } from '../../model/mutable/MutationOp';
 import { HashedObject } from '../../model/immutable/HashedObject';
 import { Timestamps } from 'util/timestamps';
 import { Hash } from '../../model/hashing';
-import { ClassRegistry } from '../../model';
+import { ClassRegistry, Context, LiteralContext } from '../../model';
 import { MultiMap } from 'util/multimap';
 import { Identity } from 'data/identity';
 import { BaseCollection, CollectionConfig, CollectionOp } from './Collection';
@@ -103,17 +103,35 @@ class MutableReference<T> extends BaseCollection<T> {
     }
 
     exportMutableState() {
+
+        let objectValue  : (LiteralContext|undefined);
+        let literalValue : any;
+
+        if (this._value instanceof HashedObject) {
+            const context = new Context();
+            this._value.toContext(context);
+            objectValue = context.toLiteralContext();
+        } else {
+            literalValue = this._value;
+        }
+
         return {
             _sequence: this._sequence,
             _timestamp: this._timestamp,
-            _value: this._value
+            _objectValue: objectValue,
+            _literalValue: literalValue
         };
     }
 
     importMutableState(state: any) {
         this._sequence = state._sequence;
         this._timestamp = state._timestamp;
-        this._value = state._value;
+
+        if (state._objectValue !== undefined) {
+            this._value = HashedObject.fromLiteralContext(state._objectValue) as any as T;
+        } else {
+            this._value = state._literalValue;
+        }
     }
 
     async validate(references: Map<Hash, HashedObject>) {
@@ -147,7 +165,6 @@ class RefUpdateOp<T> extends CollectionOp<T> {
     timestamp?: string;
     value?: T;
 
-
     constructor(targetObject?: MutableReference<T>, value?: T, sequence?: number, author?: Identity) {
         super(targetObject);
 

src/data/collections/mutable/MutableSet.ts

@@ -6,7 +6,7 @@ import { HashedSet } 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, LiteralContext } from 'data/model';
 import { BaseCollection, Collection, CollectionConfig, CollectionOp } from './Collection';
 import { Identity } from 'data/identity';
 
@@ -208,15 +208,46 @@ class MutableSet<T> extends BaseCollection<T> implements Collection<T> {
     }
 
     exportMutableState() {
+
+        const literalElements = {} as any;
+        const context = new Context();
+
+        for (const [hash, elmt] of this._elements.entries()) {
+            if (elmt instanceof HashedObject) {
+                elmt.toContext(context);
+            } else {
+                literalElements[hash] = elmt;
+            }
+        }
+
         return {
-            _elements: this._elements,
-            _currentAddOpRefs: this._currentAddOpRefs
+            _objectElements: context.toLiteralContext(),
+            _literalElements: literalElements,
+            _currentAddOpRefs: Object.fromEntries([...this._currentAddOpRefs.entries()].map(([key, value]) => [key, value.literalize().value]))
         };
     }
 
-    importMutableState(state: any): void {
-        this._elements = new Map(Object.entries(state._elements));
-        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs));
+    importMutableState(state: {
+        _objectElements: LiteralContext,
+        _literalElements: {[key: string]: any},
+        _currentAddOpRefs: {[key: string]: any}
+    }): void {
+
+        this._elements = new Map();
+
+        const context = new Context();
+        context.fromLiteralContext(state._objectElements);
+
+        for (const hash of context.rootHashes) {
+            this._elements.set(hash, HashedObject.fromContext(context, hash) as any as T);
+        }
+
+        for (const [hash, literal] of Object.entries(state._literalElements)) {
+            this._elements.set(hash, literal);
+        }
+
+        const emptyContext = new Context();
+        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs).map(([key, value]) => [key, HashedSet.deliteralize(value, emptyContext)]));
     }
 
     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';
 
+type HashedSetLiteral = {
+    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) : HashedSetLiteral  {
 
         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};
     }
@@ -162,4 +167,5 @@ class HashedSet<T> {
 
 }
 
-export { HashedSet };
+export { HashedSet };
+export type { HashedSetLiteral };

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]);
+    });
+    
+})