@woosh/meep-engine 2.84.8 → 2.84.10

package/src/core/collection/table/RowFirstTable.js

@@ -8,493 +8,489 @@ import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/array_copy.js";
 
-/**
- *
- * @param {RowFirstTableSpec} spec
- * @constructor
- */
-function RowFirstTable(spec) {
-    assert.defined(spec, 'spec');
-    assert.notNull(spec, 'spec');
-    assert.equal(spec.isRowFirstTableSpec, true, 'spec.isRowFirstTableSpec !== true');
-
+export class RowFirstTable {
     /**
      *
-     * @type {RowFirstTableSpec}
+     * @param {RowFirstTableSpec} spec
+     * @constructor
      */
-    this.spec = spec;
+    constructor(spec) {
+        assert.defined(spec, 'spec');
+        assert.notNull(spec, 'spec');
+        assert.equal(spec.isRowFirstTableSpec, true, 'spec.isRowFirstTableSpec !== true');
+
+        /**
+         *
+         * @type {RowFirstTableSpec}
+         */
+        this.spec = spec;
+
+        /**
+         * @readonly
+         * @type {Array.<BinaryDataType>}
+         */
+        this.types = spec.types;
+
+        /**
+         *
+         * @type {ArrayBuffer}
+         */
+        this.data = new ArrayBuffer(0);
+
+        /**
+         *
+         * @type {number}
+         */
+        this.bytesPerRecord = spec.bytesPerRecord;
+
+        /**
+         * number of records
+         * @type {number}
+         */
+        this.length = 0;
+
+        /**
+         * capacity in number of records
+         * @type {number}
+         */
+        this.capacity = 0;
+
+        /**
+         *
+         * @type {DataView}
+         */
+        this.dataView = null;
+
+        this.on = {
+            added: new Signal()
+        };
+
+        this.initialize();
+    }
 
     /**
-     * @readonly
-     * @type {Array.<BinaryDataType>}
+     * @private
      */
-    this.types = spec.types;
+    initialize() {
+        const spec = this.spec;
+
+        this.types = spec.types;
+        this.bytesPerRecord = spec.bytesPerRecord;
+
+        /**
+         *
+         * @type {function(DataView, number, number[]): void}
+         */
+        this.readRowMethod = spec.readRowMethod;
+
+        /**
+         *
+         * @type {function(DataView, number, number[]): void}
+         */
+        this.writeRowMethod = spec.writeRowMethod;
+    }
 
     /**
      *
-     * @type {ArrayBuffer}
+     * @returns {number}
      */
-    this.data = new ArrayBuffer(0);
+    hash() {
+        // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
 
-    /**
-     *
-     * @type {number}
-     */
-    this.bytesPerRecord = spec.bytesPerRecord;
+        const byteLength = this.data.byteLength;
 
-    /**
-     * number of records
-     * @type {number}
-     */
-    this.length = 0;
+        const tap_count = 31;
 
-    /**
-     * capacity in number of records
-     * @type {number}
-     */
-    this.capacity = 0;
+        const step_size = max2(
+            Math.floor(byteLength / (tap_count * 4)),
+            1
+        );
 
-    /**
-     *
-     * @type {DataView}
-     */
-    this.dataView = null;
+        const step_count = Math.floor(byteLength / step_size);
 
-    this.on = {
-        added: new Signal()
-    };
+        const dataView = this.dataView;
 
-    this.initialize();
-}
+        let result = byteLength;
 
-/**
- * @private
- */
-RowFirstTable.prototype.initialize = function () {
-    const spec = this.spec;
+        for (let i = 0; i < step_count; i++) {
+            const address = i * step_size * 4;
 
-    this.types = spec.types;
-    this.bytesPerRecord = spec.bytesPerRecord;
+            result = ((result << 5) - result) + dataView.getUint32(address);
+            result |= 0; // Convert to 32bit integer
+        }
 
-    /**
-     *
-     * @type {function(DataView, number, number[]): void}
-     */
-    this.readRowMethod = spec.readRowMethod;
+        return result;
+    }
 
     /**
      *
-     * @type {function(DataView, number, number[]): void}
+     * @param {int} rowCount
      */
-    this.writeRowMethod = spec.writeRowMethod;
-};
-
-/**
- *
- * @returns {number}
- */
-RowFirstTable.prototype.hash = function () {
-    // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
-
-    const byteLength = this.data.byteLength;
-
-    const tap_count = 31;
-
-    const step_size = max2(
-        Math.floor(byteLength / (tap_count * 4)),
-        1
-    );
-
-    const step_count = Math.floor(byteLength / step_size);
-
-    const dataView = this.dataView;
-
-    let result = byteLength;
+    setCapacity(rowCount) {
+        const oldData = this.data;
+
+        const bytesPerRecord = this.bytesPerRecord;
+        const byteSize = rowCount * bytesPerRecord;
+        try {
+            this.data = new ArrayBuffer(byteSize);
+        } catch (e) {
+            throw new Error("failed to create a new array buffer of size: " + byteSize);
+        }
 
-    for (let i = 0; i < step_count; i++) {
-        const address = i * step_size * 4;
+        //check the size of new array
+        if (this.data.byteLength !== byteSize) {
+            throw new Error("Generated array was truncated unexpectedly from " + byteSize + " to " + this.data.byteLength);
+        }
 
-        result = ((result << 5) - result) + dataView.getUint32(address);
-        result |= 0; // Convert to 32bit integer
-    }
+        const newArray = new Uint8Array(this.data);
+        const oldArray = new Uint8Array(oldData);
+
+        const sourceCopyLength = this.length * bytesPerRecord;
+        try {
+            newArray.set(oldArray.subarray(0, sourceCopyLength), 0);
+        } catch (e) {
+            if (e instanceof RangeError) {
+                throw new Error("Failed to copy contents of original due to to size violation. OldSize: " + sourceCopyLength + ", NewSize: " + this.data.byteLength);
+            } else {
+                throw e;
+            }
+        }
 
-    return result;
-};
+        this.capacity = rowCount;
 
-/**
- *
- * @param {int} rowCount
- */
-RowFirstTable.prototype.setCapacity = function (rowCount) {
-    const oldData = this.data;
-
-    const bytesPerRecord = this.bytesPerRecord;
-    const byteSize = rowCount * bytesPerRecord;
-    try {
-        this.data = new ArrayBuffer(byteSize);
-    } catch (e) {
-        throw new Error("failed to create a new array buffer of size: " + byteSize);
+        this.dataView = new DataView(this.data, 0);
     }
 
-    //check the size of new array
-    if (this.data.byteLength !== byteSize) {
-        throw new Error("Generated array was truncated unexpectedly from " + byteSize + " to " + this.data.byteLength);
+    /**
+     * Drop excess capacity, setting capacity exactly to the current length
+     */
+    trim() {
+        this.setCapacity(this.length);
     }
 
-    const newArray = new Uint8Array(this.data);
-    const oldArray = new Uint8Array(oldData);
-
-    const sourceCopyLength = this.length * bytesPerRecord;
-    try {
-        newArray.set(oldArray.subarray(0, sourceCopyLength), 0);
-    } catch (e) {
-        if (e instanceof RangeError) {
-            throw new Error("Failed to copy contents of original due to to size violation. OldSize: " + sourceCopyLength + ", NewSize: " + this.data.byteLength);
-        } else {
-            throw e;
+    /**
+     *
+     * @param {number} rowCount
+     */
+    resize(rowCount) {
+        if (this.capacity < rowCount) {
+            //grow
+            const growFactor = 1.5;
+            const newSize = Math.ceil(rowCount * growFactor);
+            this.setCapacity(newSize);
+        } else if (this.capacity * 0.5 > rowCount) {
+            //shrink
+            this.setCapacity(rowCount);
         }
     }
 
-    this.capacity = rowCount;
+    /**
+     *
+     * @param {number} rowIndex
+     * @param {number} columnIndex
+     * @param {number} value
+     */
+    writeCellValue(rowIndex, columnIndex, value) {
+        const bytesPerRecord = this.bytesPerRecord;
 
-    this.dataView = new DataView(this.data, 0);
-};
+        const rowAddress = rowIndex * bytesPerRecord;
 
-/**
- * Drop excess capacity, setting capacity exactly to the current length
- */
-RowFirstTable.prototype.trim = function () {
-    this.setCapacity(this.length);
-};
+        const spec = this.spec;
 
-/**
- *
- * @param {number} rowCount
- */
-RowFirstTable.prototype.resize = function (rowCount) {
-    if (this.capacity < rowCount) {
-        //grow
-        const growFactor = 1.5;
-        const newSize = Math.ceil(rowCount * growFactor);
-        this.setCapacity(newSize);
-    } else if (this.capacity * 0.5 > rowCount) {
-        //shrink
-        this.setCapacity(rowCount);
-    }
-};
+        const cellWriters = spec.cellWriters;
 
-/**
- *
- * @param {number} rowIndex
- * @param {number} columnIndex
- * @param {number} value
- */
-RowFirstTable.prototype.writeCellValue = function (rowIndex, columnIndex, value) {
-    const bytesPerRecord = this.bytesPerRecord;
+        const cellWriter = cellWriters[columnIndex];
 
-    const rowAddress = rowIndex * bytesPerRecord;
+        cellWriter(this.dataView, rowAddress, value);
+    }
 
-    const spec = this.spec;
+    /**
+     * read a single cell value from the table
+     * @param {number} rowIndex
+     * @param {number} columnIndex
+     * @returns {number}
+     */
+    readCellValue(rowIndex, columnIndex) {
+        const bytesPerRecord = this.bytesPerRecord;
 
-    const cellWriters = spec.cellWriters;
+        const rowAddress = rowIndex * bytesPerRecord;
 
-    const cellWriter = cellWriters[columnIndex];
+        const spec = this.spec;
 
-    cellWriter(this.dataView, rowAddress, value);
-};
+        const cellReaders = spec.cellReaders;
 
-/**
- * read a single cell value from the table
- * @param {number} rowIndex
- * @param {number} columnIndex
- * @returns {number}
- */
-RowFirstTable.prototype.readCellValue = function (rowIndex, columnIndex) {
-    const bytesPerRecord = this.bytesPerRecord;
+        const cellReader = cellReaders[columnIndex];
 
-    const rowAddress = rowIndex * bytesPerRecord;
+        return cellReader(this.dataView, rowAddress);
+    }
 
-    const spec = this.spec;
+    /**
+     * Remove rows from the table
+     * @param {number} index starting row
+     * @param {number} rowCount number of rows to be removed
+     */
+    removeRows(index, rowCount) {
 
-    const cellReaders = spec.cellReaders;
+        //validate presence to requested rows
+        assert.lessThanOrEqual(index + rowCount, this.length, 'underflow');
 
-    const cellReader = cellReaders[columnIndex];
+        const data = this.data;
 
-    return cellReader(this.dataView, rowAddress);
-};
+        const array = new Uint8Array(data);
 
-/**
- * Remove rows from the table
- * @param {number} index starting row
- * @param {number} rowCount number of rows to be removed
- */
-RowFirstTable.prototype.removeRows = function (index, rowCount) {
+        const bytesPerRecord = this.bytesPerRecord;
 
-    //validate presence to requested rows
-    assert.lessThanOrEqual(index + rowCount, this.length, 'underflow');
+        //shift tail of the table forward
+        const target = index * bytesPerRecord;
+        const start = target + rowCount * bytesPerRecord;
+        const end = this.length * bytesPerRecord;
 
-    const data = this.data;
+        array.copyWithin(target, start, end);
 
-    const array = new Uint8Array(data);
+        //adjust new length
+        this.length -= rowCount;
 
-    const bytesPerRecord = this.bytesPerRecord;
-
-    //shift tail of the table forward
-    const target = index * bytesPerRecord;
-    const start = target + rowCount * bytesPerRecord;
-    const end = this.length * bytesPerRecord;
+        //resize table
+        this.resize(this.length);
+    }
 
-    array.copyWithin(target, start, end);
+    /**
+     * Insert a number of blank rows at the given offset
+     * NOTE: doesn't send onAdded signal
+     * @param {number} index
+     * @param {number} rowCount
+     */
+    insertRows(index, rowCount) {
+        const future_length = this.length + rowCount;
 
-    //adjust new length
-    this.length -= rowCount;
+        this.resize(future_length);
 
-    //resize table
-    this.resize(this.length);
-};
+        const data = this.data;
 
-/**
- * Insert a number of blank rows at the given offset
- * NOTE: doesn't send onAdded signal
- * @param {number} index
- * @param {number} rowCount
- */
-RowFirstTable.prototype.insertRows = function (index, rowCount) {
-    const future_length = this.length + rowCount;
+        const bytesPerRecord = this.bytesPerRecord;
 
-    this.resize(future_length);
+        const array = new Uint8Array(data);
 
-    const data = this.data;
+        //shift tail of the table forward
+        const target = (index + rowCount) * bytesPerRecord;
+        const end = future_length * bytesPerRecord;
+        const start = index * bytesPerRecord;
 
-    const bytesPerRecord = this.bytesPerRecord;
+        array.copyWithin(target, start, end);
 
-    const array = new Uint8Array(data);
+        this.length = future_length;
+    }
 
-    //shift tail of the table forward
-    const target = (index + rowCount) * bytesPerRecord;
-    const end = future_length * bytesPerRecord;
-    const start = index * bytesPerRecord;
+    /**
+     *
+     * @param {Array.<Number>} values
+     */
+    addRow(values) {
 
-    array.copyWithin(target, start, end);
+        const newRowCount = this.length + 1;
 
-    this.length = future_length;
-};
+        this.resize(newRowCount);
 
-/**
- *
- * @param {Array.<Number>} values
- */
-RowFirstTable.prototype.addRow = function (values) {
+        const rowIndex = this.length;
 
-    const newRowCount = this.length + 1;
+        this.length = newRowCount;
 
-    this.resize(newRowCount);
 
-    const rowIndex = this.length;
+        this.writeRowMethod(this.dataView, this.bytesPerRecord * rowIndex, values);
 
-    this.length = newRowCount;
+        this.on.added.send2(rowIndex, values);
+    }
 
+    /**
+     *
+     * @param {int} count number of rows to be added
+     * @param {function} valueSupplier supplier of row values, called with row index and an empty row to be filled
+     */
+    addRows(count, valueSupplier) {
+        const newRowCount = this.length + count;
 
-    this.writeRowMethod(this.dataView, this.bytesPerRecord * rowIndex, values);
+        this.resize(newRowCount);
 
-    this.on.added.send2(rowIndex, values);
-};
+        let i = this.length;
+        this.length = newRowCount;
 
-/**
- *
- * @param {int} count number of rows to be added
- * @param {function} valueSupplier supplier of row values, called with row index and an empty row to be filled
- */
-RowFirstTable.prototype.addRows = function (count, valueSupplier) {
-    const newRowCount = this.length + count;
+        const row = new Array(this.getNumColumns());
 
-    this.resize(newRowCount);
+        const bytesPerRecord = this.bytesPerRecord;
+        const dataView = this.dataView;
+        const writeRowMethod = this.writeRowMethod;
 
-    let i = this.length;
-    this.length = newRowCount;
+        const onAdded = this.on.added;
 
-    const row = new Array(this.getNumColumns());
+        function addOneSignaling(index) {
+            addOneSilent(index);
+            onAdded.send2(index, row);
+        }
 
-    const bytesPerRecord = this.bytesPerRecord;
-    const dataView = this.dataView;
-    const writeRowMethod = this.writeRowMethod;
+        function addOneSilent(i) {
+            valueSupplier(i, row);
+            writeRowMethod(dataView, bytesPerRecord * i, row);
+        }
 
-    const onAdded = this.on.added;
+        //depending on whether signal is being listened, pick signaling or silent generator
+        const addOne = onAdded.hasHandlers() ? addOneSignaling : addOneSilent;
 
-    function addOneSignaling(index) {
-        addOneSilent(index);
-        onAdded.send2(index, row);
-    }
+        for (; i < newRowCount; i++) {
+            addOne(i);
+        }
 
-    function addOneSilent(i) {
-        valueSupplier(i, row);
-        writeRowMethod(dataView, bytesPerRecord * i, row);
     }
 
-    //depending on whether signal is being listened, pick signaling or silent generator
-    const addOne = onAdded.hasHandlers() ? addOneSignaling : addOneSilent;
+    /**
+     * Copy data from another table. Specs must match.
+     * NOTE: does not send onAdded signal
+     * @param {RowFirstTable} other
+     */
+    copy(other) {
+        // check that the spec is equivalent
+        if (!this.spec.equals(other.spec)) {
+            throw new Error('Different table specs');
+        }
 
-    for (; i < newRowCount; i++) {
-        addOne(i);
-    }
+        const record_count = other.length;
 
-};
+        this.resize(record_count);
 
-/**
- * Copy data from another table. Specs must match.
- * NOTE: does not send onAdded signal
- * @param {RowFirstTable} other
- */
-RowFirstTable.prototype.copy = function (other) {
-    // check that the spec is equivalent
-    if (!this.spec.equals(other.spec)) {
-        throw new Error('Different table specs');
-    }
+        this.length = other.length;
 
-    const record_count = other.length;
+        const target = new Uint8Array(this.data);
+        const source = new Uint8Array(other.data);
 
-    this.resize(record_count);
+        // copy data
+        const data_byte_count = other.bytesPerRecord * record_count;
+        target.set(source.slice(0, data_byte_count));
 
-    this.length = other.length;
+        // TODO consider if we should invoke onAdded signal
+    }
 
-    const target = new Uint8Array(this.data);
-    const source = new Uint8Array(other.data);
+    /**
+     * @param {RowFirstTable} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!this.spec.equals(other.spec)) {
+            return false;
+        }
 
-    // copy data
-    const data_byte_count = other.bytesPerRecord * record_count;
-    target.set(source.slice(0, data_byte_count));
+        const this_length = this.length;
 
-    // TODO consider if we should invoke onAdded signal
-};
+        if (this_length !== other.length) {
+            return false;
+        }
 
+        const total_bytes = this_length * this.bytesPerRecord;
 
-/**
- * @param {RowFirstTable} other
- * @returns {boolean}
- */
-RowFirstTable.prototype.equals = function (other) {
-    if (!this.spec.equals(other.spec)) {
-        return false;
-    }
+        for (let i = 0; i < total_bytes; i++) {
+            const a = this.dataView.getUint8(i);
+            const b = other.dataView.getUint8(i);
 
-    const this_length = this.length;
+            if (a !== b) {
+                return false;
+            }
+        }
 
-    if (this_length !== other.length) {
-        return false;
+        return true;
     }
 
-    const total_bytes = this_length * this.bytesPerRecord;
-
-    for (let i = 0; i < total_bytes; i++) {
-        const a = this.dataView.getUint8(i);
-        const b = other.dataView.getUint8(i);
-
-        if (a !== b) {
-            return false;
-        }
+    /**
+     *
+     * @param {int} index
+     * @param {Array} result where row values are to be stored
+     */
+    getRow(index, result) {
+        this.readRowMethod(this.dataView, this.bytesPerRecord * index, result);
     }
 
-    return true;
-};
-
-/**
- *
- * @param {int} index
- * @param {Array} result where row values are to be stored
- */
-RowFirstTable.prototype.getRow = function (index, result) {
-    this.readRowMethod(this.dataView, this.bytesPerRecord * index, result);
-};
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} record
+     */
+    setRow(index, record) {
+        this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
+    }
 
-/**
- *
- * @param {number} index
- * @param {number[]} record
- */
-RowFirstTable.prototype.setRow = function (index, record) {
-    this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
-}
+    /**
+     * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
+     */
+    reverse_rows() {
+        const bpr = this.bytesPerRecord;
+        const copy_buffer = new Uint8Array(bpr);
 
-/**
- * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
- */
-RowFirstTable.prototype.reverse_rows = function () {
-    const bpr = this.bytesPerRecord;
-    const copy_buffer = new Uint8Array(bpr);
+        const buffer = this.data;
+        const wrapper = new Uint8Array(buffer);
 
-    const buffer = this.data;
-    const wrapper = new Uint8Array(buffer);
+        const length = this.length;
 
-    const length = this.length;
+        if (length <= 1) {
+            // need at least 2 rows for reversal to make any change
+            return;
+        }
 
-    if (length <= 1) {
-        // need at least 2 rows for reversal to make any change
-        return;
-    }
+        const last_row_index = length - 1;
 
-    const last_row_index = length - 1;
 
+        const traversal_limit = last_row_index >>> 1;
+        for (let i = 0; i <= traversal_limit; i++) {
+            const address = i * bpr;
+            array_copy(wrapper, address, copy_buffer, 0, bpr);
 
-    const traversal_limit = last_row_index >>> 1;
-    for (let i = 0; i <= traversal_limit; i++) {
-        const address = i * bpr;
-        array_copy(wrapper, address, copy_buffer, 0, bpr);
+            const swap_index = last_row_index - i;
+            const swap_address = swap_index * bpr;
 
-        const swap_index = last_row_index - i;
-        const swap_address = swap_index * bpr;
+            wrapper.copyWithin(address, swap_address, swap_address + bpr)
+            wrapper.set(copy_buffer, swap_address);
+        }
+    }
 
-        wrapper.copyWithin(address, swap_address, swap_address + bpr)
-        wrapper.set(copy_buffer, swap_address);
+    /**
+     * clear out all the data and free memory
+     */
+    clear() {
+        //clear out data
+        this.length = 0;
+        this.setCapacity(0);
     }
-};
 
-/**
- * clear out all the data and free memory
- */
-RowFirstTable.prototype.clear = function () {
-    //clear out data
-    this.length = 0;
-    this.setCapacity(0);
-};
+    /**
+     *
+     * @returns {Number}
+     */
+    getNumColumns() {
+        return this.types.length;
+    }
 
+    /**
+     *
+     * @returns {number[][]}
+     */
+    toRowArray() {
 
-/**
- *
- * @returns {Number}
- */
-RowFirstTable.prototype.getNumColumns = function () {
-    return this.types.length;
-};
+        const result = [];
 
-/**
- *
- * @returns {number[][]}
- */
-RowFirstTable.prototype.toRowArray = function () {
+        for (let i = 0; i < this.length; i++) {
+            const row = [];
 
-    const result = [];
+            this.getRow(i, row);
 
-    for (let i = 0; i < this.length; i++) {
-        const row = [];
+            result.push(row);
+        }
 
-        this.getRow(i, row);
+        return result;
 
-        result.push(row);
     }
 
-    return result;
-
-};
-
-/**
- * Print the table to console
- */
-RowFirstTable.prototype.printToConsole = function () {
-    const rows = this.toRowArray();
-
-    console.table(rows);
-};
+    /**
+     * Print the table to console
+     */
+    printToConsole() {
+        const rows = this.toRowArray();
 
-export {
-    RowFirstTable
-};
+        console.table(rows);
+    }
+}