@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/util/account/single-attribute-buffer-management/{buffer-orchestrator.js → buffer-orchestrator.ts}

@@ -1,212 +1,238 @@
-const EXTRA_SIZE = 10;
-export class BufferOrchestrator {
-    _capacity;
-    offsetMap;
-    tombstoneOffsets;
-    _length;
-    constructor({ capacity = 10 } = {}) {
-        this._capacity = capacity;
-        this.offsetMap = new Map();
-        this.tombstoneOffsets = [];
-        this._length = 0;
-    }
-    resetWithCapacity(bufferManagersMap, capacity = null) {
-        this._capacity = capacity !== null ? capacity : this._capacity;
-        for (const [, { bufferManager }] of bufferManagersMap) {
-            bufferManager.resetWithCapacity(this._capacity);
-        }
-        this.offsetMap.clear();
-        this.tombstoneOffsets = [];
-        this._length = 0;
-    }
-    // want to add stack load to this method
-    // if offsetMap.has(item.key) === false get next offset, add the item to stack
-    // create a single big float32array and fill it with the items
-    // bufferManager.insertBulk([bigFloat32Array], [offsets[0]])
-    insertBulk(items, bufferManagersMap, bufferKeys = null) {
-        this.ensureSpace(items.length, bufferManagersMap);
-        const { offsetMap } = this;
-        let offsetStart = null;
-        const offsets = [];
-        const blockLoad = [];
-        for (const item of items) {
-            let o = offsetMap.get(item.key);
-            if (o === undefined && this.tombstoneOffsets.length > 0) {
-                // If there is a tombstone, use it
-                o = this.tombstoneOffsets.pop();
-                offsetMap.set(item.key, o);
-            }
-            if (o !== undefined) {
-                // Already exist or there is a random empty space in earlear part of memory.
-                // insert for single slots 
-                if (bufferKeys) {
-                    for (const key of bufferKeys) {
-                        const bufferManagerComp = bufferManagersMap.get(key);
-                        if (bufferManagerComp === undefined)
-                            throw new Error("insertBulk bufferKey does not exist");
-                        const { bufferManager, adaptor } = bufferManagerComp;
-                        bufferManager.insertBulk([adaptor(item)], [o]);
-                    }
-                }
-                else {
-                    for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
-                        bufferManager.insertBulk([adaptor(item)], [o]);
-                    }
-                }
-            }
-            else {
-                // offset comes from increment function
-                // this part stacks data to be load a a single big block.
-                const offset = this.nextOffset();
-                if (offset === undefined) {
-                    throw new Error("The Size Should Be Increased!!");
-                }
-                offsets.push(offset);
-                offsetMap.set(item.key, offset);
-                blockLoad.push(item);
-                if (offsetStart === null) {
-                    offsetStart = offset;
-                }
-            }
-        }
-        if (offsetStart === null)
-            return;
-        for (let i = 0; i < offsets.length - 1; i++) {
-            if (offsets[i] - offsets[i + 1] !== -1) {
-                // TODO: DELETE THIS
-                throw new Error("consecutive is not consecutive");
-            }
-        }
-        if (bufferKeys) {
-            for (const key of bufferKeys) {
-                const bufferManagerComp = bufferManagersMap.get(key);
-                if (bufferManagerComp === undefined)
-                    throw new Error("insertBulk bufferKey does not exist");
-                const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
-            }
-        }
-        else {
-            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
-            }
-        }
-    }
-    // does not assign offset to the new items.
-    updateBulk(items, bufferManagersMap, bufferKeys = null) {
-        const { offsetMap } = this;
-        const offsets = [];
-        for (const item of items) {
-            const offset = offsetMap.get(item.key);
-            if (offset !== undefined) {
-                offsets.push(offset);
-            }
-            else {
-                throw new Error(`updateBulk item Key does not exist, cannot update: ${item.key}`);
-            }
-        }
-        if (bufferKeys) {
-            for (const key of bufferKeys) {
-                const bufferManagerComp = bufferManagersMap.get(key);
-                if (bufferManagerComp === undefined)
-                    throw new Error("updateBulk bufferKey does not exist");
-                const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBulk(items.map(adaptor), offsets);
-            }
-        }
-        else {
-            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBulk(items.map(adaptor), offsets);
-            }
-        }
-    }
-    deleteBulk(keys, bufferManagersMap) {
-        const offsets = [];
-        for (const key of keys) {
-            const offset = this.getOffset(key);
-            if (offset !== undefined) {
-                offsets.push(offset);
-                this.offsetMap.delete(key);
-                this.tombstoneOffsets.push(offset);
-            }
-        }
-        for (const [, { bufferManager }] of bufferManagersMap) {
-            bufferManager.deleteBulk(offsets);
-        }
-    }
-    getOffset(key) {
-        return this.offsetMap.get(key);
-    }
-    nextTombstone() {
-        if (this.tombstoneOffsets.length > 0) {
-            const offset = this.tombstoneOffsets.pop();
-            return offset;
-        }
-        return undefined;
-    }
-    nextOffset() {
-        if (this._length < this._capacity) {
-            return this._length++;
-        }
-        return undefined;
-    }
-    ensureSpace(itemsLength, bufferManagersMap) {
-        if (itemsLength <= this.emptySpace)
-            return;
-        const newCapacity = this.length + itemsLength;
-        for (const [, { bufferManager }] of bufferManagersMap) {
-            bufferManager.extendBuffer(this.length, newCapacity);
-        }
-        this._capacity = newCapacity;
-    }
-    defrag(bufferManagers, bufferKeys) {
-        const offsetMap = this.offsetMap;
-        const newCapacity = offsetMap.size + EXTRA_SIZE;
-        if (bufferKeys) {
-            for (const key of bufferKeys) {
-                const offset = offsetMap.get(key);
-                if (offset !== undefined) {
-                    for (const [, { bufferManager }] of bufferManagers) {
-                        bufferManager.defrag([offset], this.length, newCapacity);
-                    }
-                }
-            }
-        }
-        else {
-            for (const [, { bufferManager }] of bufferManagers) {
-                bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
-            }
-        }
-        this._defrag();
-        this._length = offsetMap.size;
-        this._capacity = newCapacity;
-        this.tombstoneOffsets = [];
-    }
-    /**
-     * Flushes metadata and sets length to 0 without actualize change on buffers
-     * This method created for cases in which data is loaded on each frame
-     */
-    flush({ capacity = 10 } = {}) {
-        this._length = 0;
-        this._capacity = capacity;
-        this.tombstoneOffsets = [];
-        this.offsetMap.clear();
-    }
-    _defrag() {
-        const newOffsetMap = new Map();
-        let newOffset = 0;
-        for (const [key,] of this.offsetMap) {
-            newOffsetMap.set(key, newOffset++);
-        }
-        this.offsetMap = newOffsetMap;
-    }
-    get length() {
-        return this._length;
-    }
-    get emptySpace() {
-        return this._capacity - this.offsetMap.size;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-}
+import { BufferOrchestrator as BufferOrchestratorI, BufferManagersMap } from "./types";
+
+const EXTRA_SIZE = 10;
+
+export class BufferOrchestrator implements BufferOrchestratorI {
+    _capacity: number;
+    offsetMap: Map<string, number>;
+    tombstoneOffsets: number[];
+    _length: number;
+
+    constructor({ capacity = 10 } = {}) {
+        this._capacity = capacity;
+        this.offsetMap = new Map();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+
+
+    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null = null) {
+        this._capacity = capacity !== null ? capacity : this._capacity;
+        for (const [, { bufferManager }] of bufferManagersMap) {
+            bufferManager.resetWithCapacity(this._capacity);
+        }
+        this.offsetMap.clear();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+
+
+    // want to add stack load to this method
+    // if offsetMap.has(item.key) === false get next offset, add the item to stack
+    // create a single big float32array and fill it with the items
+    // bufferManager.insertBulk([bigFloat32Array], [offsets[0]])
+    insertBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+        this.ensureSpace(items.length, bufferManagersMap);
+        const { offsetMap } = this;
+        let offsetStart = null;
+        const offsets = []
+        const blockLoad = []
+        for (const item of items) {
+
+            let o = offsetMap.get(item.key);
+            if (o === undefined && this.tombstoneOffsets.length > 0) {
+                // If there is a tombstone, use it
+                o = this.tombstoneOffsets.pop() as number;
+                offsetMap.set(item.key, o);
+            }
+            if (o !== undefined) {
+                // Already exist or there is a random empty space in earlear part of memory.
+                // insert for single slots 
+                if (bufferKeys) {
+                    for (const key of bufferKeys) {
+                        const bufferManagerComp = bufferManagersMap.get(key);
+                        if (bufferManagerComp === undefined) throw new Error("insertBulk bufferKey does not exist");
+                        const { bufferManager, adaptor } = bufferManagerComp;
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                } else {
+                    for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+            } else {
+                // offset comes from increment function
+                // this part stacks data to be load a a single big block.
+                const offset = this.nextOffset();
+                if (offset === undefined) {
+                    throw new Error("The Size Should Be Increased!!")
+                }
+                offsets.push(offset);
+                offsetMap.set(item.key, offset as number);
+                blockLoad.push(item);
+                if (offsetStart === null) {
+                    offsetStart = offset as number;
+                }
+            }
+        }
+        if (offsetStart === null) return;
+
+        for (let i = 0; i < offsets.length - 1; i++) {
+            if (offsets[i] - offsets[i + 1] !== -1) {
+                // TODO: DELETE THIS
+                throw new Error("consecutive is not consecutive")
+            }
+        }
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined) throw new Error("insertBulk bufferKey does not exist");
+                const { bufferManager, adaptor } = bufferManagerComp;
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor);
+            }
+        } else {
+            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor);
+            }
+        }
+    }
+
+
+
+
+    // does not assign offset to the new items.
+    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+        const { offsetMap } = this;
+        const offsets = [];
+        for (const item of items) {
+            const offset = offsetMap.get(item.key);
+            if (offset !== undefined) {
+                offsets.push(offset);
+            } else {
+                throw new Error(`updateBulk item Key does not exist, cannot update: ${item.key}`);
+            }
+        }
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined) throw new Error("updateBulk bufferKey does not exist");
+                const { bufferManager, adaptor } = bufferManagerComp;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        } else {
+            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+
+    }
+
+
+    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap) {
+        const offsets = [];
+        for (const key of keys) {
+            const offset = this.getOffset(key);
+            if (offset !== undefined) {
+                offsets.push(offset);
+                this.offsetMap.delete(key);
+                this.tombstoneOffsets.push(offset);
+            }
+        }
+        for (const [, { bufferManager }] of bufferManagersMap) {
+            bufferManager.deleteBulk(offsets);
+        }
+    }
+
+
+    getOffset(key: string) {
+        return this.offsetMap.get(key);
+    }
+
+
+    nextTombstone(): number | undefined {
+        if (this.tombstoneOffsets.length > 0) {
+            const offset = this.tombstoneOffsets.pop() as number;
+            return offset;
+        }
+        return undefined
+    }
+
+
+
+    nextOffset(): number | undefined {
+        if (this._length < this._capacity) {
+            return this._length++;
+        }
+        return undefined;
+    }
+
+
+    ensureSpace(itemsLength: number, bufferManagersMap: BufferManagersMap) {
+        if (itemsLength <= this.emptySpace) return;
+        const newCapacity = this.length + itemsLength;
+        for (const [, { bufferManager }] of bufferManagersMap) {
+            bufferManager.extendBuffer(this.length, newCapacity);
+        }
+        this._capacity = newCapacity;
+    }
+
+
+    defrag(bufferManagers: BufferManagersMap, bufferKeys: string[]) { // TODO defrag and leave some empty space
+        const offsetMap = this.offsetMap;
+        const newCapacity = offsetMap.size + EXTRA_SIZE;
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const offset = offsetMap.get(key);
+                if (offset !== undefined) {
+                    for (const [, { bufferManager }] of bufferManagers) {
+                        bufferManager.defrag([offset], this.length, newCapacity);
+                    }
+                }
+            }
+        } else {
+            for (const [, { bufferManager }] of bufferManagers) {
+                bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
+            }
+        }
+        this._defrag();
+        this._length = offsetMap.size;
+        this._capacity = newCapacity;
+        this.tombstoneOffsets = [];
+    }
+
+
+    /**
+     * Flushes metadata and sets length to 0 without actualize change on buffers
+     * This method created for cases in which data is loaded on each frame
+     */
+    flush({ capacity = 10 } = {}) {
+        this._length = 0;
+        this._capacity = capacity;
+        this.tombstoneOffsets = []
+        this.offsetMap.clear();
+    }
+
+    _defrag() {
+        const newOffsetMap = new Map();
+        let newOffset = 0;
+        for (const [key,] of this.offsetMap) {
+            newOffsetMap.set(key, newOffset++);
+        }
+        this.offsetMap = newOffsetMap
+    }
+
+    get length() {
+        return this._length;
+    }
+
+    get emptySpace() {
+        return this._capacity - this.offsetMap.size;
+    }
+
+    get capacity() {
+        return this._capacity;
+    }
+}
+
+
+