memory: sync at switch

Author: Gorash

packages/core/src/Memory/Memory.ts

@@ -85,9 +85,7 @@ export interface MemoryVersionable {
     getSlice: () => object;
     getSliceValue: (ID: ProxyUniqID) => MemoryCompiled;
     isFrozen: () => boolean;
-    isDirty: (ID: ProxyUniqID) => boolean;
     markDirty: (ID: ProxyUniqID) => void;
-    markAsLoaded: (ID: ProxyUniqID) => boolean;
     addSliceProxyParent: (ID: ProxyUniqID, parentID: ProxyUniqID, attributeName: string) => boolean;
     deleteSliceProxyParent: (
         ID: ProxyUniqID,
@@ -140,7 +138,6 @@ export class Memory {
     _sliceKey: sliceKey; // identifier or current memory slice
     _references: Record<sliceKey, MemoryReference> = {}; // Record<children, parent>
     _currentReference: MemoryReference; // Record<children, parent>
-    _invalideCache: Record<number, boolean> = {}; // paths which have been set but not read again yet (after the set)
     _proxies: Record<number, object> = {};
     _rootProxies: Record<number, boolean> = {};
     _memoryVersionable: MemoryVersionable;
@@ -157,16 +154,10 @@ export class Memory {
             getSlice: (): Record<number, MemoryType> => this._currentReference.slice,
             getSliceValue: (ID: ProxyUniqID): MemoryCompiled => this._getValue(this._sliceKey, ID),
             isFrozen: this.isFrozen.bind(this),
-            // Is currently dirty (we may have switched from a slice to a very
-            // different one, thus setting "dirty" on a lot of objects along the
-            // way, all the ones that were modified at one point)
-            // Is your proxy unsynchronized
-            isDirty: (ID: ProxyUniqID): boolean => this._invalideCache[ID as number],
             // Mark as "modified" in this slice
             markDirty: (ID: ProxyUniqID): boolean =>
                 (this._currentReference.invalideCache[ID as number] = true),
             // I am the proxy, I tell you I synchornized the value
-            markAsLoaded: (ID: ProxyUniqID): boolean => (this._invalideCache[ID as number] = false),
             deleteSliceProxyParent: this._deleteSliceProxyParent.bind(this),
             addSliceProxyParent: this._addSliceProxyParent.bind(this),
             linkToMemory: this._linkToMemory.bind(this),
@@ -215,14 +206,27 @@ export class Memory {
     }
     getChangedVersionables(sliceKey: sliceKey = this._sliceKey): Map<AllowedObject, string[][]> {
         const pathChanges = new Map<AllowedObject, string[][]>();
-        const invalideCache = this._references[sliceKey].invalideCache;
-        for (const id in invalideCache) {
+        const slice = this._references[sliceKey].slice;
+        for (const id in slice) {
+            const item = slice[id];
             const proxy = this._proxies[id] as LoopObject | LoopArray | LoopSet;
             this._getRootVersionables(this._sliceKey, proxy).forEach(pathToRoot => {
+                let paths: string[][];
+                if (
+                    (item instanceof MemoryTypeObject || item instanceof MemoryTypeArray) &&
+                    Object.keys(item.props).length
+                ) {
+                    paths = [];
+                    for (const key in item.props) {
+                        paths.push(pathToRoot.path.concat([key]));
+                    }
+                } else {
+                    paths = [pathToRoot.path];
+                }
                 if (pathChanges.get(pathToRoot.proxy)) {
-                    pathChanges.get(pathToRoot.proxy).push(pathToRoot.path);
+                    pathChanges.get(pathToRoot.proxy).push(...paths);
                 } else {
-                    pathChanges.set(pathToRoot.proxy, [pathToRoot.path]);
+                    pathChanges.set(pathToRoot.proxy, paths);
                 }
             });
         }
@@ -242,7 +246,7 @@ export class Memory {
         if (!params.itsme(proxy)) {
             return NotVersionableErrorMessage();
         }
-        if (params.memory !== this._memoryVersionable) {
+        if (!params.memory || params.memory !== this._memoryVersionable) {
             params.willBeRootDiff = true;
             this._linkToMemory(proxy);
         }
@@ -304,15 +308,24 @@ export class Memory {
             refs.shift();
         }
 
+        const invalideCache = new Set<number>();
         while (refs.length) {
             const ref = refs.pop();
             Object.keys(ref.invalideCache).forEach(key => {
                 // It was invalid before, it is still invalid now since it wasn't yet read
-                this._invalideCache[key] = true;
+                invalideCache.add(+key);
             });
         }
+
         this._currentReference = this._references[sliceKey];
         this._sliceKey = sliceKey;
+
+        for (const key of invalideCache) {
+            const proxy = this._proxies[key];
+            const params = proxy[memoryProxyPramsKey] as VersionableParams;
+            params.sync();
+        }
+
         return this;
     }
     snapshot(fromSliceKey: sliceKey, unitSliceKey: sliceKey, newSliceKey: sliceKey): void {
@@ -416,9 +429,9 @@ export class Memory {
                 continue;
             }
             this._getProxyParentedPath(sliceKey, nodeID).forEach(path => {
-                const nodeID = path.split(parentedPathSeparator, 1)[0];
-                const partPath = path.slice(nodeID.length + 1);
-                pathList.push([+nodeID, [partPath].concat(pathToNode)]);
+                const parentNodeID = path.split(parentedPathSeparator, 1)[0];
+                const partPath = path.slice(parentNodeID.length + 1);
+                pathList.push([+parentNodeID, [partPath].concat(pathToNode)]);
             });
         }
         return roots;

packages/core/src/Memory/VersionableArray.ts

@@ -15,6 +15,7 @@ import {
 } from './const';
 import {
     proxifyObject,
+    GettersSetters,
     ProxyObjectHandler,
     proxyObjectHandler,
     keyType,
@@ -34,19 +35,15 @@ interface ArrayParams extends VersionableParams {
     map: Map<AllowedMemory, uniqID>;
     syncSlice?: Record<number, MemoryType>;
     previousSliceValues?: uniqIDMemoryTypeValues;
+    proto: GettersSetters;
 }
 
 const proxyArrayHandler = {
-    get(proxyObject: AllowedMemory[], prop: keyType, proxy: object): AllowedMemory {
-        const params = proxyObject[memoryProxyPramsKey];
-        const array = params.object;
-        if (typeof prop === 'symbol') {
-            return proxyObjectHandler.get(array, prop, proxy);
-        }
-        if (!isNaN(prop as number)) {
-            params.sync();
+    get(array: AllowedMemory[], prop: keyType, proxy: object): AllowedMemory {
+        if (typeof prop === 'symbol' || !isNaN(prop as number)) {
             return array[prop];
         }
+        const params = array[memoryProxyPramsKey];
         if (!params.memory) {
             return proxyObjectHandler.get(array, prop, proxy);
         }
@@ -91,7 +88,6 @@ const proxyArrayHandler = {
         }
 
         value = checkIfProxy(value);
-        params.sync();
         const oldValue = array[prop];
 
         if (oldValue === value || (value === removedItem && !(prop in array))) {
@@ -246,7 +242,6 @@ export function proxifyArray<T extends AllowedMemory>(array: T[]): T[] {
 }
 
 function unshift(params: ArrayParams, ...items: AllowedMemory[]): number {
-    params.sync();
     for (let k = 0, len = items.length; k < len; k++) {
         const item = items[k];
         params.object.unshift(Undefined);
@@ -256,15 +251,13 @@ function unshift(params: ArrayParams, ...items: AllowedMemory[]): number {
     return params.object.length;
 }
 function shift(params: ArrayParams): AllowedMemory {
-    params.sync();
     const value = params.object[0];
     this['0'] = removedItem;
     params.object.shift();
     params.uniqIDs.shift();
     return value;
 }
 function pop(params: ArrayParams): AllowedMemory {
-    params.sync();
     const lastIndex = params.object.length - 1;
     const value = params.object[lastIndex];
     this.length = lastIndex;
@@ -276,7 +269,6 @@ function splice(
     nb: number,
     ...items: AllowedMemory[]
 ): AllowedMemory[] {
-    params.sync();
     const array = params.object;
     const uniqIDs = params.uniqIDs;
     const len = array.length;
@@ -308,7 +300,6 @@ function forEach(
     params: ArrayParams,
     callback: (value: AllowedMemory, index: number, array: AllowedMemory[]) => void,
 ): void {
-    params.sync();
     const array = params.object;
     for (let index = 0, len = array.length; index < len; index++) {
         callback(array[index], index, this);
@@ -319,7 +310,6 @@ function map(
     callback: (value: AllowedMemory, index: number, array: AllowedMemory[]) => AllowedMemory,
 ): AllowedMemory[] {
     const result = [];
-    params.sync();
     const array = params.object;
     for (let index = 0, len = array.length; index < len; index++) {
         result.push(callback(array[index], index, this));
@@ -331,7 +321,6 @@ function filter(
     callback: (value: AllowedMemory, index: number, array: AllowedMemory[]) => boolean,
 ): AllowedMemory[] {
     const result = [];
-    params.sync();
     const array = params.object;
     for (let index = 0, len = array.length; index < len; index++) {
         const value = array[index];
@@ -342,7 +331,6 @@ function filter(
     return result;
 }
 function indexOf(params: ArrayParams, item: AllowedMemory): number {
-    params.sync();
     const uniqID = params.map.get(item);
     if (uniqID === undefined) {
         return -1;
@@ -369,12 +357,11 @@ function indexOf(params: ArrayParams, item: AllowedMemory): number {
     return index;
 }
 function proxifySyncArray(): { compiled: uniqIDMemoryTypeValues; sequences: uniqID[] } {
+    // Synchronization function
+    // Most methods of the "proxy" will call this synchronization function, even
+    // if it is not yet linked to a memory !
     const params = this as ArrayParams;
     const memory = params.memory;
-    if (!memory.isDirty(params.ID)) {
-        return;
-    }
-    memory.markAsLoaded(params.ID);
     // empties the array
     params.uniqIDs.length = 0;
     params.object.length = 0;