binaryarray/dist/lib/binaryarray.js

the binary array

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var assert = require("assert");
var util_1 = require("./util");
var bitsize_util_1 = require("./bitsize_util");
var BinaryArray = /** @class */ (function () {
    function BinaryArray(maxnum) {
        this.maxnum = maxnum;
        this.storage = util_1.createArray(bitsize_util_1.getArraySize(maxnum), 0);
    }
    BinaryArray.prototype.findBitPosition = function (no) {
        assert(this.maxnum > no, 'on:over flagmax');
        var idx = bitsize_util_1.getArrayIndex(no);
        assert(idx >= 0 && idx < this.storage.length, 'on:over idx range');
        var pos = bitsize_util_1.getFlagPos(no);
        var flag = 1 << pos;
        return [idx, flag];
    };
    BinaryArray.prototype.bitOn = function (no) {
        var _a = this.findBitPosition(no), idx = _a[0], flag = _a[1];
        this.storage[idx] |= flag;
        return this;
    };
    BinaryArray.prototype.bitOff = function (no) {
        var _a = this.findBitPosition(no), idx = _a[0], flag = _a[1];
        if (this.storage[idx] & flag) {
            this.storage[idx] ^= flag;
        }
        return this;
    };
    BinaryArray.prototype.at = function (no) {
        var _a = this.findBitPosition(no), idx = _a[0], flag = _a[1];
        return this.storage[idx] & flag ? 1 : 0;
    };
    BinaryArray.prototype.toArray = function () {
        var _this = this;
        var results = Array.from(Array(this.maxnum), function (v, idx) { return _this.at(idx); });
        return results;
    };
    BinaryArray.prototype.serialize = function (spec) {
        assert(spec instanceof Object, 'spec is must be Object');
        var flaglist = this.toArray();
        return Object.keys(spec)
            .filter(function (k) { return flaglist[spec[k]]; });
    };
    BinaryArray.prototype.toJSON = function () {
        return JSON.stringify(this.toArray());
    };
    BinaryArray.prototype.isRange = function (no) {
        if (!(this.maxnum > no)) {
            return false;
        }
        var idx = bitsize_util_1.getArrayIndex(no);
        if (!(idx >= 0 && idx < this.storage.length)) {
            return false;
        }
        return true;
    };
    BinaryArray.prototype.rangeOf = function (no_list) {
        var _this = this;
        var xs = (no_list instanceof Array) ? no_list : [no_list];
        return xs.reduce(function (r, no) {
            r[no] = _this.at(no);
            return r;
        }, {});
    };
    BinaryArray.prototype.check = function (on_list, off_list) {
        if (off_list === void 0) { off_list = []; }
        var on = this.rangeOf(on_list);
        var off = this.rangeOf(off_list);
        var x = Object.keys(on).reduce(function (r, v) { return r & on[v]; }, 1);
        var y = Object.keys(off).reduce(function (r, v) { return r & ~off[v]; }, 1);
        return (x & y) ? true : false;
    };
    BinaryArray.prototype.toHexString = function () {
        var str = '';
        var n = this.storage.length;
        for (var i = n - 1; i >= 0; --i) {
            str = str + util_1.numberToHexString(this.storage[i], 8);
        }
        return str;
    };
    BinaryArray.prototype.clone = function () {
        return BinaryArray.loadFromArray(this.toArray());
    };
    BinaryArray.loadFromHexString = function (maxnum, str) {
        var ba = new BinaryArray(maxnum);
        var s = 8;
        var b = str.length - s;
        var e = str.length - 0;
        var n = str.length / s;
        for (var i = 0; i < n; ++i) {
            ba.storage[i] = parseInt(str.substring(b, e), 16);
            b -= s;
            e -= s;
        }
        return ba;
    };
    BinaryArray.loadFromArray = function (flaglist) {
        var ba = new BinaryArray(flaglist.length);
        flaglist.map(function (v, i) { return [i, v]; })
            .filter(function (tuple) { return tuple[1]; })
            .forEach(function (tuple) {
            ba.bitOn(tuple[0]);
        });
        return ba;
    };
    BinaryArray.deserialize = function (list, spec, max) {
        var ba = new BinaryArray(max);
        list.forEach(function (v) { ba.bitOn(spec[v]); });
        return ba;
    };
    return BinaryArray;
}());
exports.BinaryArray = BinaryArray;