using a LiteralContext to save the literalized objects in the state checkpoint

Author: sbazerque

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

@@ -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, HashedSetLiteralized } from 'data/model/immutable/HashedSet';
+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, Context } from 'data/model';
+import { ClassRegistry, Context, LiteralContext } from 'data/model';
 import { BaseCollection, Collection, CollectionConfig, CollectionOp } from './Collection';
 import { Identity } from 'data/identity';
 
@@ -208,18 +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: Object.fromEntries(this._elements.entries()),
-            _currentAddOpRefs: Object.fromEntries([...this._currentAddOpRefs.entries()].map(([key, value]) => [key, value.literalize()]))
+            _objectElements: context.toLiteralContext(),
+            _literalElements: literalElements,
+            _currentAddOpRefs: Object.fromEntries([...this._currentAddOpRefs.entries()].map(([key, value]) => [key, value.literalize().value]))
         };
     }
 
     importMutableState(state: {
-        _elements: {[key: string]: T},
-        _currentAddOpRefs: {[key: string]: {value: HashedSetLiteralized }}
+        _objectElements: LiteralContext,
+        _literalElements: {[key: string]: any},
+        _currentAddOpRefs: {[key: string]: any}
     }): void {
-        this._elements = new Map(Object.entries(state._elements));
-        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs).map(([key, value]) => [key, HashedSet.deliteralize(value, new Context())]));
+
+        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,7 +4,7 @@ import { Context } from '../literals/Context';
 
 import { Dependency } from '../literals/LiteralUtils';
 
-export type HashedSetLiteralized = {
+type HashedSetLiteral = {
     value: { _type: string, _hashes: string[], _elements: any[] },
     dependencies: Map<Hash, Dependency>,
 }
@@ -89,7 +89,7 @@ class HashedSet<T> {
         return result;
     }
 
-    literalize(path='', context?: Context) : HashedSetLiteralized  {
+    literalize(path='', context?: Context) : HashedSetLiteral  {
 
         let dependencies = new Map<Hash, Dependency>();
 
@@ -167,4 +167,5 @@ class HashedSet<T> {
 
 }
 
-export { HashedSet };
+export { HashedSet };
+export type { HashedSetLiteral };