muschema/array.js

Schemas for mudb

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require("./util");
var MuArray = (function () {
    function MuArray(valueSchema, id) {
        this.identity = [];
        this.muType = 'array';
        this.pool = [];
        this.identity = id || [];
        this.muData = valueSchema;
        this.json = {
            type: 'array',
            valueType: this.muData.json,
            identity: JSON.stringify(this.identity),
        };
    }
    MuArray.prototype.alloc = function () {
        return this.pool.pop() || [];
    };
    MuArray.prototype.free = function (arr) {
        var valueSchema = this.muData;
        for (var i = 0; i < arr.length; ++i) {
            valueSchema.free(arr[i]);
        }
        arr.length = 0;
        this.pool.push(arr);
    };
    MuArray.prototype.equal = function (x, y) {
        if (!Array.isArray(x) || !Array.isArray(y)) {
            return false;
        }
        if (x.length !== y.length) {
            return false;
        }
        for (var i = x.length - 1; i >= 0; --i) {
            if (!this.muData.equal(x[i], y[i])) {
                return false;
            }
        }
        return true;
    };
    MuArray.prototype.clone = function (arr) {
        var result = this.alloc();
        result.length = arr.length;
        var valueSchema = this.muData;
        for (var i = 0; i < arr.length; ++i) {
            result[i] = valueSchema.clone(arr[i]);
        }
        return result;
    };
    MuArray.prototype.copy = function (source, target) {
        if (source === target) {
            return;
        }
        var sourceLength = source.length;
        var targetLength = target.length;
        for (var i = sourceLength; i < targetLength; ++i) {
            this.muData.free(target[i]);
        }
        target.length = sourceLength;
        if (util_1.isMuPrimitive(this.muData.muType)) {
            for (var i = 0; i < sourceLength; ++i) {
                target[i] = source[i];
            }
            return;
        }
        for (var i = targetLength; i < target.length; ++i) {
            target[i] = this.muData.clone(source[i]);
        }
        for (var i = 0; i < Math.min(sourceLength, targetLength); ++i) {
            this.muData.copy(source[i], target[i]);
        }
    };
    MuArray.prototype.diff = function (base, target, stream) {
        var prefixOffset = stream.offset;
        var targetLength = target.length;
        var numTrackers = Math.ceil(targetLength / 8);
        stream.grow(4 + numTrackers);
        stream.writeUint32(targetLength);
        var trackerOffset = stream.offset;
        stream.offset = trackerOffset + numTrackers;
        var tracker = 0;
        var numPatch = 0;
        var baseLength = base.length;
        var valueSchema = this.muData;
        for (var i = 0; i < Math.min(baseLength, targetLength); ++i) {
            if (valueSchema.diff(base[i], target[i], stream)) {
                tracker |= 1 << (i & 7);
                ++numPatch;
            }
            if ((i & 7) === 7) {
                stream.writeUint8At(trackerOffset++, tracker);
                tracker = 0;
            }
        }
        for (var i = baseLength; i < targetLength; ++i) {
            if (valueSchema.diff(valueSchema.identity, target[i], stream)) {
                tracker |= 1 << (i & 7);
                ++numPatch;
            }
            if ((i & 7) === 7) {
                stream.writeUint8At(trackerOffset++, tracker);
                tracker = 0;
            }
        }
        if (targetLength & 7) {
            stream.writeUint8At(trackerOffset, tracker);
        }
        if (numPatch > 0 || baseLength !== targetLength) {
            return true;
        }
        stream.offset = prefixOffset;
        return false;
    };
    MuArray.prototype.patch = function (base, stream) {
        var result = this.clone(base);
        var targetLength = stream.readUint32();
        result.length = targetLength;
        var trackerOffset = stream.offset;
        var numTrackers = Math.ceil(targetLength / 8);
        stream.offset = trackerOffset + numTrackers;
        var tracker = 0;
        var baseLength = base.length;
        var valueSchema = this.muData;
        for (var i = 0; i < Math.min(baseLength, targetLength); ++i) {
            var mod8 = i & 7;
            if (!mod8) {
                tracker = stream.readUint8At(trackerOffset++);
            }
            if ((1 << mod8) & tracker) {
                result[i] = valueSchema.patch(base[i], stream);
            }
        }
        for (var i = baseLength; i < targetLength; ++i) {
            var mod8 = i & 7;
            if (!mod8) {
                tracker = stream.readUint8At(trackerOffset++);
            }
            if ((1 << mod8) & tracker) {
                result[i] = valueSchema.patch(valueSchema.identity, stream);
            }
            else {
                result[i] = valueSchema.clone(valueSchema.identity);
            }
        }
        return result;
    };
    return MuArray;
}());
exports.MuArray = MuArray;
//# sourceMappingURL=array.js.map