@thi.ng/sparse-set
Version:
TypedArray-based sparse set implementations with extended ES Set API
210 lines (209 loc) • 6.27 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __typeError = (msg) => {
throw TypeError(msg);
};
var __decorateClass = (decorators, target, key, kind) => {
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
for (var i = decorators.length - 1, decorator; i >= 0; i--)
if (decorator = decorators[i])
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
if (kind && result) __defProp(target, key, result);
return result;
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateWrapper = (obj, member, setter, getter) => ({
set _(value) {
__privateSet(obj, member, value, setter);
},
get _() {
return __privateGet(obj, member, getter);
}
});
var _dense, _sparse, _n;
import { dissoc } from "@thi.ng/associative/dissoc";
import { __disposableValues } from "@thi.ng/associative/internal/dispose";
import { __tostringMixin } from "@thi.ng/associative/internal/tostring";
import { into } from "@thi.ng/associative/into";
import { isNumber } from "@thi.ng/checks/is-number";
import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
const __fail = () => illegalArgs(`dense & sparse arrays must be of same size`);
let ASparseSet = class extends Set {
constructor(dense, sparse) {
super();
__privateAdd(this, _dense);
__privateAdd(this, _sparse);
__privateAdd(this, _n, 0);
__privateSet(this, _dense, dense);
__privateSet(this, _sparse, sparse);
}
[Symbol.iterator]() {
return this.keys();
}
// mixin
[Symbol.dispose]() {
}
get size() {
return __privateGet(this, _n);
}
get capacity() {
return __privateGet(this, _dense).length;
}
clear() {
__privateSet(this, _n, 0);
}
equiv(o) {
if (this === o) {
return true;
}
if (!(o instanceof Set) || this.size !== o.size) {
return false;
}
const d = __privateGet(this, _dense);
for (let i = __privateGet(this, _n); i-- > 0; ) {
if (!o.has(d[i])) {
return false;
}
}
return true;
}
add(key) {
const max = __privateGet(this, _dense).length;
const i = __privateGet(this, _sparse)[key];
const n = __privateGet(this, _n);
if (key < max && n < max && !(i < n && __privateGet(this, _dense)[i] === key)) {
__privateGet(this, _dense)[n] = key;
__privateGet(this, _sparse)[key] = n;
__privateWrapper(this, _n)._++;
}
return this;
}
delete(key) {
const dense = __privateGet(this, _dense);
const sparse = __privateGet(this, _sparse);
const i = sparse[key];
if (i < __privateGet(this, _n) && dense[i] === key) {
const j = dense[--__privateWrapper(this, _n)._];
dense[i] = j;
sparse[j] = i;
return true;
}
return false;
}
has(key) {
const i = __privateGet(this, _sparse)[key];
return i < __privateGet(this, _n) && __privateGet(this, _dense)[i] === key;
}
get(key, notFound = -1) {
return this.has(key) ? key : notFound;
}
first() {
return __privateGet(this, _n) ? __privateGet(this, _dense)[0] : void 0;
}
into(keys) {
return into(this, keys);
}
disj(keys) {
return dissoc(this, keys);
}
forEach(fn, thisArg) {
const dense = __privateGet(this, _dense);
const n = __privateGet(this, _n);
for (let i = 0; i < n; i++) {
const v = dense[i];
fn.call(thisArg, v, v, this);
}
}
*entries() {
const dense = __privateGet(this, _dense);
const n = __privateGet(this, _n);
for (let i = 0; i < n; i++) {
yield [dense[i], dense[i]];
}
}
*keys() {
const dense = __privateGet(this, _dense);
const n = __privateGet(this, _n);
for (let i = 0; i < n; i++) {
yield dense[i];
}
}
values() {
return this.keys();
}
__copyTo(dest) {
__privateSet(dest, _dense, __privateGet(this, _dense).slice());
__privateSet(dest, _sparse, __privateGet(this, _sparse).slice());
__privateSet(dest, _n, __privateGet(this, _n));
return dest;
}
};
_dense = new WeakMap();
_sparse = new WeakMap();
_n = new WeakMap();
ASparseSet = __decorateClass([
__disposableValues,
__tostringMixin
], ASparseSet);
class SparseSet8 extends ASparseSet {
constructor(n, sparse) {
isNumber(n) ? super(new Uint8Array(n), new Uint8Array(n)) : n.length === sparse.length ? super(n, sparse) : __fail();
}
get [Symbol.species]() {
return SparseSet8;
}
get [Symbol.toStringTag]() {
return "SparseSet8";
}
copy() {
return this.__copyTo(new SparseSet8(0));
}
empty() {
return new SparseSet8(this.capacity);
}
}
class SparseSet16 extends ASparseSet {
constructor(n, sparse) {
isNumber(n) ? super(new Uint16Array(n), new Uint16Array(n)) : n.length === sparse.length ? super(n, sparse) : __fail();
}
get [Symbol.species]() {
return SparseSet16;
}
get [Symbol.toStringTag]() {
return "SparseSet16";
}
copy() {
return this.__copyTo(new SparseSet16(0));
}
empty() {
return new SparseSet16(this.capacity);
}
}
class SparseSet32 extends ASparseSet {
constructor(n, sparse) {
isNumber(n) ? super(new Uint32Array(n), new Uint32Array(n)) : n.length === sparse.length ? super(n, sparse) : __fail();
}
get [Symbol.species]() {
return SparseSet32;
}
get [Symbol.toStringTag]() {
return "SparseSet32";
}
copy() {
return this.__copyTo(new SparseSet32(0));
}
empty() {
return new SparseSet32(this.capacity);
}
}
const defSparseSet = (n) => n <= 256 ? new SparseSet8(n) : n <= 65536 ? new SparseSet16(n) : new SparseSet32(n);
export {
ASparseSet,
SparseSet16,
SparseSet32,
SparseSet8,
defSparseSet
};