binaryarray - npm Package Compare versions

Comparing version 0.0.6 to 0.1.0

dist/index.d.ts

+import { BinaryArray } from './lib/binaryarray';
+export = BinaryArray;

dist/index.js

+"use strict";
+var binaryarray_1 = require("./lib/binaryarray");
+module.exports = binaryarray_1.BinaryArray;

dist/lib/binaryarray.d.ts

+export declare class BinaryArray {
+    maxnum: number;
+    storage: Uint32Array;
+    constructor(maxnum: number);
+    bitOn(no: number): BinaryArray;
+    bitOff(no: number): BinaryArray;
+    at(no: number): number;
+    toArray(): Array<number>;
+    serialize(spec: Object): Array<string>;
+    toJSON(): string;
+    isRange(no: number): boolean;
+    rangeOf(xs: any): Object;
+    check(on_list: Array<number>, off_list?: Array<number>): boolean;
+    toHexString(): string;
+    static loadFromHexString(maxnum: number, str: string): BinaryArray;
+    static loadFromArray(xs: Array<number>): BinaryArray;
+    static deserialize(list: Array<string>, spec: Object, max: number): BinaryArray;
+}

dist/lib/binaryarray.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert = require("assert");
+var util = require("./util");
+var BinaryArray = (function () {
+    function BinaryArray(maxnum) {
+        this.maxnum = maxnum;
+        this.storage = util.createArray(util.getArraySize(maxnum), 0);
+    }
+    BinaryArray.prototype.bitOn = function (no) {
+        assert(this.maxnum > no, 'on:over flagmax');
+        var idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'on:over idx range');
+        var pos = util.getFlagPos(no);
+        var flag = 1 << pos;
+        this.storage[idx] |= flag;
+        return this;
+    };
+    BinaryArray.prototype.bitOff = function (no) {
+        assert(this.maxnum > no, 'off:over flagmax');
+        var idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'off:over idx range');
+        var pos = util.getFlagPos(no);
+        var flag = 1 << pos;
+        if (this.storage[idx] & flag) {
+            this.storage[idx] ^= flag;
+        }
+        return this;
+    };
+    BinaryArray.prototype.at = function (no) {
+        assert(this.maxnum > no, 'get:over flagmax');
+        var idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'is:over idx range');
+        var pos = util.getFlagPos(no);
+        var flag = 1 << pos;
+        return this.storage[idx] & flag ? 1 : 0;
+    };
+    BinaryArray.prototype.toArray = function () {
+        var w = [];
+        var max = this.maxnum;
+        for (var i = 0; i < max; ++i) {
+            w.push(this.at(i));
+        }
+        return w;
+    };
+    BinaryArray.prototype.serialize = function (spec) {
+        assert(spec instanceof Object, 'spec is must be Object');
+        var w = this.toArray();
+        return Object.keys(spec)
+            .filter(function (k) { return w[spec[k]]; })
+            .map(function (k) { return k; });
+    };
+    BinaryArray.prototype.toJSON = function () {
+        return JSON.stringify(this.toArray());
+    };
+    BinaryArray.prototype.isRange = function (no) {
+        if (!(this.maxnum > no)) {
+            return false;
+        }
+        var idx = util.getArrayIndex(no);
+        if (!(idx >= 0 && idx < this.storage.length)) {
+            return false;
+        }
+        return true;
+    };
+    BinaryArray.prototype.rangeOf = function (xs) {
+        var _this = this;
+        if (!(xs instanceof Array)) {
+            xs = [xs];
+        }
+        return xs.reduce(function (r, v) {
+            r[v] = _this.at(v);
+            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.NumberToHexString(this.storage[i], 8);
+        }
+        return str;
+    };
+    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 (xs) {
+        var ba = new BinaryArray(xs.length);
+        xs.map(function (v, i) { return [v, i]; })
+            .filter(function (v) { return v[0]; })
+            .forEach(function (v) {
+            ba.bitOn(v[1]);
+        });
+        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;

dist/lib/util.d.ts

+export declare const getArraySize: (flagmax: number) => number;
+export declare const getArrayIndex: (no: number) => number;
+export declare const getFlagPos: (no: number) => number;
+export declare const digitfix: (str: string, b: number) => string;
+export declare const hexconv: (n: number) => string;
+export declare const NumberToHexString: (num: number, digit: number) => string;
+export declare const createArray: (size: number, init_val?: number) => Uint32Array;
+export declare const getSpecMax: (spec: Object) => number;

dist/lib/util.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BITS = 32;
+exports.getArraySize = function (flagmax) {
+    return Math.ceil(flagmax / BITS);
+};
+exports.getArrayIndex = function (no) {
+    return Math.floor(no / BITS);
+};
+exports.getFlagPos = function (no) {
+    return no % BITS;
+};
+exports.digitfix = function (str, b) {
+    if (str.length < b) {
+        var len = b - str.length;
+        for (var i = 0; i < len; ++i) {
+            str = '0' + str;
+        }
+    }
+    return str;
+};
+exports.hexconv = function (n) {
+    switch (n) {
+        case 10: return 'A';
+        case 11: return 'B';
+        case 12: return 'C';
+        case 13: return 'D';
+        case 14: return 'E';
+        case 15: return 'F';
+    }
+    return n.toString();
+};
+exports.NumberToHexString = function (num, digit) {
+    var remainder = 0;
+    var str = '';
+    while (num > 0) {
+        remainder = num % 16;
+        num = (num - remainder) / 16;
+        str = exports.hexconv(remainder) + str;
+    }
+    return exports.digitfix(str, digit);
+};
+exports.createArray = function (size, init_val) {
+    if (init_val === void 0) { init_val = 0; }
+    var w = new Uint32Array(size);
+    for (var i = 0; i < size; ++i) {
+        w[i] = init_val;
+    }
+    return w;
+};
+exports.getSpecMax = function (spec) {
+    return Object.keys(spec).reduce(function (r, k) { return Math.max(r, spec[k]); }, 0) + 1;
+};

dist/test/binaryarray.test.d.ts

+export {};

dist/test/binaryarray.test.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert = require("assert");
+var BinaryArray = require("..");
+var util_1 = require("../lib/util");
+describe('test', function () {
+    it('array length test', function () {
+        [
+            function () {
+                var ba = new BinaryArray(0);
+                assert(ba.maxnum === 0);
+                assert(ba.storage.length === 0);
+            },
+            function () {
+                var ba = new BinaryArray(1);
+                assert(ba.maxnum === 1);
+                assert(ba.storage.length === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                assert(ba.maxnum === 32);
+                assert(ba.storage.length === 1);
+            },
+            function () {
+                var ba = new BinaryArray(33);
+                assert(ba.maxnum === 33);
+                assert(ba.storage.length === 2);
+            },
+            function () {
+                var ba = new BinaryArray(64);
+                assert(ba.maxnum === 64);
+                assert(ba.storage.length === 2);
+            },
+            function () {
+                var ba = new BinaryArray(65);
+                assert(ba.maxnum === 65);
+                assert(ba.storage.length === 3);
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('binary on test', function () {
+        [
+            function () {
+                var ba = new BinaryArray(32);
+                assert(ba.storage[0] === 0x00000000);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.bitOn(0);
+                assert(ba.storage[0] === 0x00000001);
+                assert(ba.at(0) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.bitOn(0);
+                ba.bitOn(1);
+                assert(ba.storage[0] === 0x00000003);
+                assert(ba.at(0) === 1);
+                assert(ba.at(1) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.bitOn(0);
+                ba.bitOn(1);
+                ba.bitOn(2);
+                assert(ba.storage[0] === 0x00000007);
+                assert(ba.at(0) === 1);
+                assert(ba.at(1) === 1);
+                assert(ba.at(2) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.bitOn(31);
+                assert(ba.storage[0] === 0x80000000);
+                assert(ba.at(31) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(33);
+                ba.bitOn(32);
+                assert(ba.storage[0] === 0x00000000);
+                assert(ba.storage[1] === 0x00000001);
+                assert(ba.at(31) === 0);
+                assert(ba.at(32) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.bitOn(0);
+                assert(ba.storage[0] === 0x00000001);
+                ba.bitOn(0);
+                assert(ba.storage[0] === 0x00000001);
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('binary off test', function () {
+        [
+            function () {
+                var ba = new BinaryArray(32);
+                ba.storage[0] = 0xffffffff;
+                ba.bitOff(0);
+                assert(ba.storage[0] === 0xfffffffe);
+                assert(ba.at(0) === 0);
+                assert(ba.at(1) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.storage[0] = 0xffffffff;
+                ba.bitOff(31);
+                assert(ba.storage[0] === 0x7fffffff);
+                assert(ba.at(0) === 1);
+                assert(ba.at(30) === 1);
+                assert(ba.at(31) === 0);
+            },
+            function () {
+                var ba = new BinaryArray(64);
+                ba.storage[0] = 0xffffffff;
+                ba.storage[1] = 0xffffffff;
+                ba.bitOff(32);
+                assert(ba.storage[0] === 0xffffffff);
+                assert(ba.storage[1] === 0xfffffffe);
+                assert(ba.at(31) === 1);
+                assert(ba.at(32) === 0);
+                assert(ba.at(33) === 1);
+            },
+            function () {
+                var ba = new BinaryArray(32);
+                ba.storage[0] = 0xfffffffe;
+                ba.bitOff(0);
+                assert(ba.storage[0] === 0xfffffffe);
+                ba.bitOff(0);
+                assert(ba.storage[0] === 0xfffffffe);
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('if array test', function () {
+        [
+            function () {
+                var input = [1, 1, 1, 1, 1, 1, 1, 1];
+                var ba = BinaryArray.loadFromArray(input);
+                assert(ba.maxnum === 8);
+                assert(ba.storage[0] === 0x000000ff);
+                var output = ba.toArray();
+                assert(JSON.stringify(input) === JSON.stringify(output));
+            },
+            function () {
+                var input = [
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1
+                ];
+                var ba = BinaryArray.loadFromArray(input);
+                assert(ba.maxnum === input.length);
+                assert(ba.storage[0] === 0xffffffff);
+                assert(ba.storage[1] === 0x000000ff);
+                var output = ba.toArray();
+                assert(JSON.stringify(input) === JSON.stringify(output));
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('if serialize test', function () {
+        [
+            function () {
+                var SPEC = {};
+                for (var i = 0; i < 33; i++) {
+                    SPEC['TEST_' + (i + 1)] = i;
+                }
+                var input = ['TEST_1', 'TEST_2', 'TEST_33'];
+                var SPEC_MAX = util_1.getSpecMax(SPEC);
+                var ba = BinaryArray.deserialize(input, SPEC, SPEC_MAX);
+                assert(ba.maxnum === SPEC_MAX);
+                assert(ba.storage[0] === 0x00000003);
+                assert(ba.storage[1] === 0x00000001);
+                var output = ba.serialize(SPEC);
+                assert(JSON.stringify(input) === JSON.stringify(output));
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('if other test', function () {
+        [
+            function () {
+                var input = [
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1,
+                    1, 1, 1, 1, 1, 1, 1, 1
+                ];
+                var ba = BinaryArray.loadFromArray(input);
+                assert(ba.toHexString() === 'FFFFFFFF');
+            },
+            function () {
+                var input = [
+                    1, 0, 0, 0, 0, 0, 0, 0,
+                    0, 1, 0, 0, 0, 0, 0, 0,
+                    0, 0, 1, 0, 0, 0, 0, 0,
+                    0, 0, 0, 1, 0, 0, 0, 0,
+                    0, 0, 0, 0, 1, 0, 0, 0,
+                    0, 0, 0, 0, 0, 1, 0, 0,
+                    0, 0, 0, 0, 0, 0, 1, 0,
+                    0, 0, 0, 0, 0, 0
+                ];
+                var ba = BinaryArray.loadFromArray(input);
+                assert(ba.toHexString() === '0040201008040201');
+            },
+            function () {
+                var ba = BinaryArray.loadFromHexString(32, 'FFFFFFFF');
+                assert(ba.toHexString() === 'FFFFFFFF');
+            },
+            function () {
+                var input = [1, 0, 1, 0, 1, 0, 1];
+                var ba = BinaryArray.loadFromArray(input);
+                var json = ba.toJSON();
+                assert(json === JSON.stringify(input));
+            }
+        ].forEach(function (f) { f(); });
+    });
+    it('other test', function () {
+        [
+            function () {
+                var ba = new BinaryArray(1024);
+                [0, 1, 2, 3, 4, 5, 10].forEach(function (v) { ba.bitOn(v); });
+                assert(ba.check([0, 1, 2, 3, 4, 5]));
+                assert(!ba.check([0, 1, 2, 3, 4, 5], [10]));
+                assert(ba.check([0, 1, 2, 3, 4, 5], [7, 8, 9]));
+            },
+            function () {
+                var ba = new BinaryArray(1024);
+                ba.bitOn(3);
+                var obj = ba.rangeOf([0, 1, 2, 3, 4, 5]);
+                assert(!obj[0]);
+                assert(obj[3]);
+            },
+            function () {
+                var ba = new BinaryArray(1024);
+                ba.bitOn(3);
+                var obj = ba.rangeOf(3);
+                assert(obj[3]);
+            },
+            function () {
+                var flag = 1;
+                var ba = new BinaryArray(1024);
+                ba.bitOn(3);
+                try {
+                    var obj = ba.rangeOf("AAA");
+                }
+                catch (e) {
+                    flag = 0;
+                }
+                assert(flag === 0);
+            },
+            function () {
+                var ba = new BinaryArray(1024);
+                assert(ba.isRange(1023));
+                assert(!ba.isRange(1024));
+                assert(!ba.isRange(-1));
+            }
+        ].forEach(function (f) { f(); });
+    });
+});

package.json

 {
   "name": "binaryarray",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "the binary array",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
   "repository": {
@@ -19,9 +20,12 @@ "type": "git",
   "devDependencies": {
-    "istanbul":"",
-    "coveralls":"",
-    "power-assert":"",
-    "mocha":""
+    "@types/node": "",
+    "@types/mocha": "",
+    "typescript": "",
+    "istanbul": "",
+    "coveralls": "",
+    "mocha": ""
   },
   "scripts": {
-    "test": "./node_modules/.bin/istanbul cover ./node_modules/mocha/bin/_mocha",
+    "build": "./node_modules/.bin/tsc -p ./",
+    "test": "./node_modules/.bin/istanbul cover ./node_modules/mocha/bin/_mocha ./dist/test",
     "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
@@ -28,0 +32,0 @@ },

.travis.yml

-language: node_js
-node_js:
-  - "4.1"
-  - "0.12"
-  - "0.10"
-script: npm test --coverage
-after_success:
-  - npm run coveralls

example/ex1.js

-var BinaryArray = require('..');
-
-var EVENT_CLEAR = {
-    TUTORIAL : 0,
-    QUEST1 : 1,
-    QUEST2 : 2,
-    QUEST3 : 3,
-    QUEST4 : 4,
-    QUEST5 : 5,
-    QUEST6 : 6,
-    LASTBOSS : 7,
-}
-var EVENT_CLEAR_MAX = Object.keys(EVENT_CLEAR).reduce(function(r, k){ return Math.max(EVENT_CLEAR[k], r) }, 0) + 1;
-
-var ba = new BinaryArray(EVENT_CLEAR_MAX)
-
-ba.bitOn(EVENT_CLEAR.TUTORIAL);
-ba.bitOn(EVENT_CLEAR.QUEST1);
-ba.bitOn(EVENT_CLEAR.QUEST4);
-
-var save = ba.toArray();
-var ba2 = BinaryArray.loadFromArray(save);
-console.log(save);
-console.log(ba2.toArray());
-
-ba2.bitOn(2);
-ba2.bitOn(3);
-ba2.bitOff(4);
-console.log(ba.toHexString())
-console.log(ba2.toHexString())
-
-
-if(ba.at(EVENT_CLEAR.QUEST4)) console.log("ok")
-if(!ba2.at(EVENT_CLEAR.QUEST4)) console.log("ok")

example/ex2.js

-var BinaryArray = require('..');
-
-var EVENT_CLEAR = {
-    TUTORIAL : 0,
-    QUEST1 : 1,
-    QUEST2 : 2,
-    QUEST3 : 3,
-    QUEST4 : 4,
-    QUEST5 : 5,
-    QUEST6 : 6,
-    LASTBOSS : 7,
-}
-var EVENT_CLEAR_MAX = Math.max.apply(Math, Object.keys(EVENT_CLEAR).map(function(k){ return EVENT_CLEAR[k] })) + 1;
-
-var ba = new BinaryArray(EVENT_CLEAR_MAX)
-
-ba.bitOn(EVENT_CLEAR.TUTORIAL);
-ba.bitOn(EVENT_CLEAR.QUEST1);
-ba.bitOn(EVENT_CLEAR.QUEST4);
-
-var serialize = ba.serialize(EVENT_CLEAR);
-console.log(serialize);
-
-var ba2 = BinaryArray.deserialize(serialize, EVENT_CLEAR, EVENT_CLEAR_MAX);
-console.log(ba2.serialize(EVENT_CLEAR));
-

example/ex3.js

-var BinaryArray = require('..');
-
-var EVENT_CLEAR = {
-    TUTORIAL : 0,
-    QUEST1 : 1,
-    QUEST2 : 2,
-    QUEST3 : 3,
-    QUEST4 : 4,
-    QUEST5 : 5,
-    QUEST6 : 6,
-    LASTBOSS : 7,
-}
-var EVENT_CLEAR_MAX = Math.max.apply(Math, Object.keys(EVENT_CLEAR).map(function(k){ return EVENT_CLEAR[k] })) + 1;
-
-var ba = new BinaryArray(EVENT_CLEAR_MAX)
-
-ba.bitOn(EVENT_CLEAR.TUTORIAL);
-ba.bitOn(EVENT_CLEAR.QUEST1);
-ba.bitOn(EVENT_CLEAR.QUEST2);
-ba.bitOn(EVENT_CLEAR.QUEST3);
-ba.bitOn(EVENT_CLEAR.QUEST4);
-ba.bitOff(EVENT_CLEAR.QUEST6);
-ba.bitOff(EVENT_CLEAR.LASTBOSS);
-
-if(ba.check([
-    EVENT_CLEAR.QUEST1,
-    EVENT_CLEAR.QUEST2,
-    EVENT_CLEAR.QUEST3,
-    EVENT_CLEAR.QUEST4
-],[
-    EVENT_CLEAR.QUEST6,
-    EVENT_CLEAR.LASTBOSS
-])){
-    console.log("GO LAST BOSS");
-}else{
-    console.log("BOO");
-}
-
-

example/ex4.js

-"use strict"
-const BinaryArray = require('..')
-
-const JOB = Object.freeze({
-    NONE : 0,
-    FIGHTER : 1,
-    MAGE : 2,
-    PRIEST : 3,
-    MONK : 4,
-    KNIGHT : 5,
-    SUMMONER : 6,
-});
-
-const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
-
-let JOB_GROUP = {
-    TANK : BinaryArray.deserialize([
-        'FIGHTER',
-        'MONK',
-        'KNIGHT'
-    ], JOB, JOB_MAX),
-    CASTER : BinaryArray.deserialize([
-        'MAGE',
-        'PRIEST',
-        'SUMMONER'
-    ], JOB, JOB_MAX),
-    HEALER : BinaryArray.deserialize([
-        'PRIEST'
-    ], JOB, JOB_MAX),
-    EXJOB : BinaryArray.deserialize([
-        'SUMMONER',
-        'KNIGHT'
-    ], JOB, JOB_MAX),
-}
-
-let job_id = JOB.FIGHTER;
-if( JOB_GROUP.TANK.at(job_id) ){
-    console.log("tank job")
-}else{
-    console.log("not tank job")
-}
-

example/ex5.js

-"use strict"
-const BinaryArray = require('..')
-
-const JOB = Object.freeze({
-    NONE : 0,
-    FIGHTER : 1,
-    MAGE : 2,
-    PRIEST : 3,
-    MONK : 4,
-    KNIGHT : 5,
-    SUMMONER : 6,
-});
-
-const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
-
-let ba = new BinaryArray(JOB_MAX);
-ba.bitOn(JOB.FIGHTER);
-ba.bitOn(JOB.PRIEST);
-let save = ba.serialize(JOB);
-console.log(save);
-
-let ba2 = BinaryArray.deserialize(save, JOB, JOB_MAX);
-console.log(ba2.serialize(JOB));
-

example/ex6.js

-"use strict"
-const BinaryArray = require('..')
-
-const JOB = Object.freeze({
-    NONE : 0,
-    FIGHTER : 1,
-    MAGE : 2,
-    PRIEST : 3,
-    MONK : 4,
-    KNIGHT : 5,
-    SUMMONER : 6,
-});
-
-const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
-
-let ba = new BinaryArray(JOB_MAX);
-ba.bitOn(JOB.FIGHTER);
-ba.bitOn(JOB.PRIEST);
-if(ba.check([JOB.FIGHTER, JOB.PRIEST], [JOB.KNIGHT])){
-    ba.bitOn(JOB.KNIGHT);
-    console.log("EXJOB GET")
-}
-let save = ba.serialize(JOB);
-console.log(save);
-
-let ba2 = BinaryArray.deserialize(save, JOB, JOB_MAX);
-if(ba2.check([JOB.FIGHTER, JOB.PRIEST], [JOB.KNIGHT])){
-    ba2.bitOn(JOB.KNIGHT);
-    console.log("EXJOB GET")
-}
-console.log(ba2.serialize(JOB));
-

index.js

-module.exports = require('./lib/binaryarray');

lib/binaryarray.js

-"use strict";
-var assert = require('assert');
-var util = require('./util');
-
-var BinaryArray = module.exports = function(maxnum){
-    this.maxnum = maxnum;
-    this.storage = util.createArray(util.getArraySize(maxnum), 0);
-}
-BinaryArray.prototype.toArray = function(){
-    var w = [];
-    var max = this.maxnum;
-    for(var i = 0; i < max; ++i ){
-        w.push(this.at(i));
-    }
-    return w;
-}
-BinaryArray.prototype.serialize = function(spec){
-    assert(spec instanceof Object, 'spec is must be Object')
-    var w = this.toArray();
-    return Object.keys(spec)
-        .filter(function(k){ return w[spec[k]] })
-        .map(function(k){ return k })
-}
-BinaryArray.prototype.toJSON = function(){
-    return JSON.stringify(this.toArray())
-}
-BinaryArray.prototype.isRange = function(no){
-    if(!(this.maxnum > no)){
-            return false;
-    }
-    var idx = util.getArrayIndex(no);
-    if(!(idx >= 0 && idx < this.storage.length)){
-        return false;
-    }
-    return true;
-}
-BinaryArray.prototype.at = function(no){
-    assert(this.maxnum > no, 'get:over flagmax');
-    var idx = util.getArrayIndex(no);
-    assert(idx >= 0 && idx < this.storage.length, 'is:over idx range');
-    var pos = util.getFlagPos(no);
-    var flag = 1 << pos;
-    return this.storage[idx] & flag ? 1 : 0;
-}
-BinaryArray.prototype.rangeOf = function(xs){
-    if(!(xs instanceof Array)){
-        xs = [xs];
-    }
-    var self = this;
-    return xs.reduce(function(r, v){
-        r[v] = self.at(v)
-        return r;
-    }, {})
-}
-BinaryArray.prototype.check = function(on_list, 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.bitOn = function(no){
-    assert(this.maxnum > no, 'on:over flagmax');
-    var idx = util.getArrayIndex(no);
-    assert(idx >= 0 && idx < this.storage.length, 'on:over idx range');
-    var pos = util.getFlagPos(no);
-    var flag = 1 << pos;
-    this.storage[idx] |= flag;
-    return this;
-}
-BinaryArray.prototype.bitOff = function(no){
-    assert(this.maxnum > no, 'off:over flagmax');
-    var idx = util.getArrayIndex(no);
-    assert(idx >= 0 && idx < this.storage.length, 'off:over idx range');
-    var pos = util.getFlagPos(no);
-    var flag = 1 << pos;
-    if(this.storage[idx] & flag){
-        this.storage[idx] ^= flag;
-    }
-    return this;
-}
-BinaryArray.prototype.toHexString = function(){
-    var str = '';
-    var n = this.storage.length;
-    for(var i=n-1;i>=0;--i){
-        str = str + util.NumberToHexString(this.storage[i], 8);
-    }
-    return str;
-}
-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(xs){
-    var ba = new BinaryArray(xs.length);
-    xs.map(function(v, i){ return [v, i] })
-        .filter(function(v){ return v[0] })
-        .forEach(function(v){
-            ba.bitOn(v[1]);
-        })
-    return ba;
-}
-BinaryArray.deserialize = function(list, spec, max){
-    var ba = new BinaryArray(max);
-    list.forEach(function(v){ ba.bitOn(spec[v]) })
-    return ba;
-}
-

lib/util.js

-"use strict";
-
-// 配列一つに入るビットの数
-var BITS = 32;
-
-// フラグ数から配列のサイズを求める
-var getArraySize = exports.getArraySize = function(flagmax){
-    return Math.ceil(flagmax/BITS);
-};
-// フラグ番号から配列の位置を求める
-var getArrayIndex = exports.getArrayIndex = function(no){
-    return Math.floor(no/BITS);
-};
-// フラグ番号から実際のフラグの位置を求める
-var getFlagPos = exports.getFlagPos = function(no){
-    return no % BITS;
-};
-var digitfix = exports.digitfix = function(str, b){
-    if(str.length < b ){
-        var len = b - str.length;
-        for(var i = 0; i < len; ++i){
-            str = '0' + str;
-        }
-    }
-    return str;
-};
-var hexconv = exports.hexconv = function(n){
-    switch (n) {
-        case 10: return 'A';
-        case 11: return 'B';
-        case 12: return 'C';
-        case 13: return 'D';
-        case 14: return 'E';
-        case 15: return 'F';
-    }
-    return n.toString();
-};
-// 数値からヘックスの文字列にする
-var NumberToHexString = exports.NumberToHexString = function(num, digit){
-    var remainder = 0;
-    var str = '';
-    while (num > 0) {
-        remainder = num % 16;
-        num = (num - remainder) / 16;
-        str = hexconv(remainder) + str;
-    }
-    return digitfix(str, digit);
-}
-
-// 初期化済みの配列を作成する
-var createArray = exports.createArray = function(size, init_val){
-    init_val = init_val || 0;
-    var w = new Uint32Array(size);
-    for(var i = 0; i < size; ++i){
-        w[i] = init_val;
-    }
-    return w;
-}

test/test_binaryarray.js

-var assert = require('power-assert');
-var BinaryArray = require('../');
-
-describe('test', function() {
-    describe('array length test', function() {
-        [
-        function(){
-            var ba = new BinaryArray(0);
-            assert(ba.maxnum === 0);
-            assert(ba.storage.length === 0);
-        },
-        function(){
-            var ba = new BinaryArray(1);
-            assert(ba.maxnum === 1);
-            assert(ba.storage.length === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            assert(ba.maxnum === 32);
-            assert(ba.storage.length === 1);
-        },
-        function(){
-            var ba = new BinaryArray(33);
-            assert(ba.maxnum === 33);
-            assert(ba.storage.length === 2);
-        },
-        function(){
-            var ba = new BinaryArray(64);
-            assert(ba.maxnum === 64);
-            assert(ba.storage.length === 2);
-        },
-        function(){
-            var ba = new BinaryArray(65);
-            assert(ba.maxnum === 65);
-            assert(ba.storage.length === 3);
-        }].forEach(function(f){f()})
-    });
-    describe('binary on test', function() {
-        [
-        function(){
-            var ba = new BinaryArray(32);
-            assert(ba.storage[0] === 0x00000000);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.bitOn(0);
-            assert(ba.storage[0] === 0x00000001);
-            assert(ba.at(0) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.bitOn(0);
-            ba.bitOn(1);
-            assert(ba.storage[0] === 0x00000003);
-            assert(ba.at(0) === 1);
-            assert(ba.at(1) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.bitOn(0);
-            ba.bitOn(1);
-            ba.bitOn(2);
-            assert(ba.storage[0] === 0x00000007);
-            assert(ba.at(0) === 1);
-            assert(ba.at(1) === 1);
-            assert(ba.at(2) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.bitOn(31);
-            assert(ba.storage[0] === 0x80000000);
-            assert(ba.at(31) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(33);
-            ba.bitOn(32);
-            assert(ba.storage[0] === 0x00000000);
-            assert(ba.storage[1] === 0x00000001);
-            assert(ba.at(31) === 0);
-            assert(ba.at(32) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.bitOn(0);
-            assert(ba.storage[0] === 0x00000001);
-            ba.bitOn(0);
-            assert(ba.storage[0] === 0x00000001);
-        }].forEach(function(f){f()})
-    });
-    describe('binary off test', function() {
-        [
-        function(){
-            var ba = new BinaryArray(32);
-            ba.storage[0] = 0xffffffff;
-            ba.bitOff(0);
-            assert(ba.storage[0] === 0xfffffffe);
-            assert(ba.at(0) === 0);
-            assert(ba.at(1) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.storage[0] = 0xffffffff;
-            ba.bitOff(31);
-            assert(ba.storage[0] === 0x7fffffff);
-            assert(ba.at(0) === 1);
-            assert(ba.at(30) === 1);
-            assert(ba.at(31) === 0);
-        },
-        function(){
-            var ba = new BinaryArray(64);
-            ba.storage[0] = 0xffffffff;
-            ba.storage[1] = 0xffffffff;
-            ba.bitOff(32);
-            assert(ba.storage[0] === 0xffffffff);
-            assert(ba.storage[1] === 0xfffffffe);
-            assert(ba.at(31) === 1);
-            assert(ba.at(32) === 0);
-            assert(ba.at(33) === 1);
-        },
-        function(){
-            var ba = new BinaryArray(32);
-            ba.storage[0] = 0xfffffffe;
-            ba.bitOff(0);
-            assert(ba.storage[0] === 0xfffffffe);
-            ba.bitOff(0);
-            assert(ba.storage[0] === 0xfffffffe);
-        }].forEach(function(f){f()})
-    });
-    describe('if array test', function() {
-        [
-        function(){
-            var input = [1,1,1,1,1,1,1,1];
-            var ba = BinaryArray.loadFromArray(input);
-            assert(ba.maxnum === 8);
-            assert(ba.storage[0] === 0x000000ff);
-            var output = ba.toArray();
-            assert(JSON.stringify(input) === JSON.stringify(output));
-        },
-        function(){
-            var input = [
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1
-            ];
-            var ba = BinaryArray.loadFromArray(input);
-            assert(ba.maxnum === input.length);
-            assert(ba.storage[0] === 0xffffffff);
-            assert(ba.storage[1] === 0x000000ff);
-            var output = ba.toArray();
-            assert(JSON.stringify(input) === JSON.stringify(output));
-        }].forEach(function(f){f()})
-    });
-    describe('if serialize test', function() {
-        [
-        function(){
-            var SPEC = {};
-            for(var i = 0; i<33; i++){ SPEC['TEST_'+(i+1)] = i }
-            var input = ['TEST_1','TEST_2','TEST_33'];
-            var ba = BinaryArray.deserialize(input, SPEC, i);
-            assert(ba.maxnum === i);
-            assert(ba.storage[0] === 0x00000003);
-            assert(ba.storage[1] === 0x00000001);
-            var output = ba.serialize(SPEC);
-            assert(JSON.stringify(input) === JSON.stringify(output));
-        }].forEach(function(f){f()})
-    });
-    describe('if other test', function() {
-        [
-        function(){
-            var input = [
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1,
-                1,1,1,1,1,1,1,1
-            ];
-            var ba = BinaryArray.loadFromArray(input);
-            assert(ba.toHexString() === 'FFFFFFFF');
-        },
-        function(){
-            var input = [
-                1,0,0,0,0,0,0,0,
-                0,1,0,0,0,0,0,0,
-                0,0,1,0,0,0,0,0,
-                0,0,0,1,0,0,0,0,
-                0,0,0,0,1,0,0,0,
-                0,0,0,0,0,1,0,0,
-                0,0,0,0,0,0,1,0,
-                0,0,0,0,0,0
-            ];
-            var ba = BinaryArray.loadFromArray(input);
-            assert(ba.toHexString() === '0040201008040201');
-        },
-        function(){
-            var ba = BinaryArray.loadFromHexString(32, 'FFFFFFFF');
-            assert(ba.toHexString() === 'FFFFFFFF');
-        },
-        function(){
-            var input = [1,0,1,0,1,0,1];
-            var ba = BinaryArray.loadFromArray(input);
-            var json = ba.toJSON()
-            assert(json === JSON.stringify(input));
-        }].forEach(function(f){f()})
-    });
-    describe('other test', function() {
-        [
-        function(){
-            var ba = new BinaryArray(1024);
-            [0,1,2,3,4,5,10].forEach(function(v){ ba.bitOn(v) });
-            assert(ba.check([0,1,2,3,4,5]))
-            assert(!ba.check([0,1,2,3,4,5], [10]))
-            assert(ba.check([0,1,2,3,4,5],[7,8,9]))
-        },
-        function(){
-            var ba = new BinaryArray(1024);
-            ba.bitOn(3);
-            var obj = ba.rangeOf([0,1,2,3,4,5]);
-            assert(!obj[0]);
-            assert(obj[3]);
-        },
-        function(){
-            var ba = new BinaryArray(1024);
-            ba.bitOn(3);
-            var obj = ba.rangeOf(3);
-            assert(obj[3]);
-        },
-        function(){
-            var ba = new BinaryArray(1024);
-            ba.bitOn(3);
-            try{
-                var obj = ba.rangeOf("AAA");
-            }catch(e){
-            }
-        },
-        function(){
-            var ba = new BinaryArray(1024);
-            assert(ba.isRange(1023));
-            assert(!ba.isRange(1024));
-            assert(!ba.isRange(-1));
-        }].forEach(function(f){f()})
-    });
-});
-
-

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

20797

-6.11%

Dev dependency count

6

50%

Number of package files

11

-26.67%

Lines of code

465

-19.27%

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes