1058 lines
32 KiB
JavaScript
1058 lines
32 KiB
JavaScript
var _a, _b;
|
|
import { compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase } from './strings.js';
|
|
export class StringIterator {
|
|
constructor() {
|
|
this._value = '';
|
|
this._pos = 0;
|
|
}
|
|
reset(key) {
|
|
this._value = key;
|
|
this._pos = 0;
|
|
return this;
|
|
}
|
|
next() {
|
|
this._pos += 1;
|
|
return this;
|
|
}
|
|
hasNext() {
|
|
return this._pos < this._value.length - 1;
|
|
}
|
|
cmp(a) {
|
|
const aCode = a.charCodeAt(0);
|
|
const thisCode = this._value.charCodeAt(this._pos);
|
|
return aCode - thisCode;
|
|
}
|
|
value() {
|
|
return this._value[this._pos];
|
|
}
|
|
}
|
|
export class ConfigKeysIterator {
|
|
constructor(_caseSensitive = true) {
|
|
this._caseSensitive = _caseSensitive;
|
|
}
|
|
reset(key) {
|
|
this._value = key;
|
|
this._from = 0;
|
|
this._to = 0;
|
|
return this.next();
|
|
}
|
|
hasNext() {
|
|
return this._to < this._value.length;
|
|
}
|
|
next() {
|
|
// this._data = key.split(/[\\/]/).filter(s => !!s);
|
|
this._from = this._to;
|
|
let justSeps = true;
|
|
for (; this._to < this._value.length; this._to++) {
|
|
const ch = this._value.charCodeAt(this._to);
|
|
if (ch === 46 /* CharCode.Period */) {
|
|
if (justSeps) {
|
|
this._from++;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
justSeps = false;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
cmp(a) {
|
|
return this._caseSensitive
|
|
? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
|
|
: compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
|
|
}
|
|
value() {
|
|
return this._value.substring(this._from, this._to);
|
|
}
|
|
}
|
|
export class PathIterator {
|
|
constructor(_splitOnBackslash = true, _caseSensitive = true) {
|
|
this._splitOnBackslash = _splitOnBackslash;
|
|
this._caseSensitive = _caseSensitive;
|
|
}
|
|
reset(key) {
|
|
this._from = 0;
|
|
this._to = 0;
|
|
this._value = key;
|
|
this._valueLen = key.length;
|
|
for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
|
|
const ch = this._value.charCodeAt(pos);
|
|
if (!(ch === 47 /* CharCode.Slash */ || this._splitOnBackslash && ch === 92 /* CharCode.Backslash */)) {
|
|
break;
|
|
}
|
|
}
|
|
return this.next();
|
|
}
|
|
hasNext() {
|
|
return this._to < this._valueLen;
|
|
}
|
|
next() {
|
|
// this._data = key.split(/[\\/]/).filter(s => !!s);
|
|
this._from = this._to;
|
|
let justSeps = true;
|
|
for (; this._to < this._valueLen; this._to++) {
|
|
const ch = this._value.charCodeAt(this._to);
|
|
if (ch === 47 /* CharCode.Slash */ || this._splitOnBackslash && ch === 92 /* CharCode.Backslash */) {
|
|
if (justSeps) {
|
|
this._from++;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
justSeps = false;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
cmp(a) {
|
|
return this._caseSensitive
|
|
? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
|
|
: compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
|
|
}
|
|
value() {
|
|
return this._value.substring(this._from, this._to);
|
|
}
|
|
}
|
|
export class UriIterator {
|
|
constructor(_ignorePathCasing, _ignoreQueryAndFragment) {
|
|
this._ignorePathCasing = _ignorePathCasing;
|
|
this._ignoreQueryAndFragment = _ignoreQueryAndFragment;
|
|
this._states = [];
|
|
this._stateIdx = 0;
|
|
}
|
|
reset(key) {
|
|
this._value = key;
|
|
this._states = [];
|
|
if (this._value.scheme) {
|
|
this._states.push(1 /* UriIteratorState.Scheme */);
|
|
}
|
|
if (this._value.authority) {
|
|
this._states.push(2 /* UriIteratorState.Authority */);
|
|
}
|
|
if (this._value.path) {
|
|
this._pathIterator = new PathIterator(false, !this._ignorePathCasing(key));
|
|
this._pathIterator.reset(key.path);
|
|
if (this._pathIterator.value()) {
|
|
this._states.push(3 /* UriIteratorState.Path */);
|
|
}
|
|
}
|
|
if (!this._ignoreQueryAndFragment(key)) {
|
|
if (this._value.query) {
|
|
this._states.push(4 /* UriIteratorState.Query */);
|
|
}
|
|
if (this._value.fragment) {
|
|
this._states.push(5 /* UriIteratorState.Fragment */);
|
|
}
|
|
}
|
|
this._stateIdx = 0;
|
|
return this;
|
|
}
|
|
next() {
|
|
if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */ && this._pathIterator.hasNext()) {
|
|
this._pathIterator.next();
|
|
}
|
|
else {
|
|
this._stateIdx += 1;
|
|
}
|
|
return this;
|
|
}
|
|
hasNext() {
|
|
return (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */ && this._pathIterator.hasNext())
|
|
|| this._stateIdx < this._states.length - 1;
|
|
}
|
|
cmp(a) {
|
|
if (this._states[this._stateIdx] === 1 /* UriIteratorState.Scheme */) {
|
|
return compareIgnoreCase(a, this._value.scheme);
|
|
}
|
|
else if (this._states[this._stateIdx] === 2 /* UriIteratorState.Authority */) {
|
|
return compareIgnoreCase(a, this._value.authority);
|
|
}
|
|
else if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */) {
|
|
return this._pathIterator.cmp(a);
|
|
}
|
|
else if (this._states[this._stateIdx] === 4 /* UriIteratorState.Query */) {
|
|
return compare(a, this._value.query);
|
|
}
|
|
else if (this._states[this._stateIdx] === 5 /* UriIteratorState.Fragment */) {
|
|
return compare(a, this._value.fragment);
|
|
}
|
|
throw new Error();
|
|
}
|
|
value() {
|
|
if (this._states[this._stateIdx] === 1 /* UriIteratorState.Scheme */) {
|
|
return this._value.scheme;
|
|
}
|
|
else if (this._states[this._stateIdx] === 2 /* UriIteratorState.Authority */) {
|
|
return this._value.authority;
|
|
}
|
|
else if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */) {
|
|
return this._pathIterator.value();
|
|
}
|
|
else if (this._states[this._stateIdx] === 4 /* UriIteratorState.Query */) {
|
|
return this._value.query;
|
|
}
|
|
else if (this._states[this._stateIdx] === 5 /* UriIteratorState.Fragment */) {
|
|
return this._value.fragment;
|
|
}
|
|
throw new Error();
|
|
}
|
|
}
|
|
class TernarySearchTreeNode {
|
|
constructor() {
|
|
this.height = 1;
|
|
}
|
|
rotateLeft() {
|
|
const tmp = this.right;
|
|
this.right = tmp.left;
|
|
tmp.left = this;
|
|
this.updateHeight();
|
|
tmp.updateHeight();
|
|
return tmp;
|
|
}
|
|
rotateRight() {
|
|
const tmp = this.left;
|
|
this.left = tmp.right;
|
|
tmp.right = this;
|
|
this.updateHeight();
|
|
tmp.updateHeight();
|
|
return tmp;
|
|
}
|
|
updateHeight() {
|
|
this.height = 1 + Math.max(this.heightLeft, this.heightRight);
|
|
}
|
|
balanceFactor() {
|
|
return this.heightRight - this.heightLeft;
|
|
}
|
|
get heightLeft() {
|
|
var _c, _d;
|
|
return (_d = (_c = this.left) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0;
|
|
}
|
|
get heightRight() {
|
|
var _c, _d;
|
|
return (_d = (_c = this.right) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0;
|
|
}
|
|
}
|
|
export class TernarySearchTree {
|
|
constructor(segments) {
|
|
this._iter = segments;
|
|
}
|
|
static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
|
|
return new TernarySearchTree(new UriIterator(ignorePathCasing, ignoreQueryAndFragment));
|
|
}
|
|
static forStrings() {
|
|
return new TernarySearchTree(new StringIterator());
|
|
}
|
|
static forConfigKeys() {
|
|
return new TernarySearchTree(new ConfigKeysIterator());
|
|
}
|
|
clear() {
|
|
this._root = undefined;
|
|
}
|
|
set(key, element) {
|
|
const iter = this._iter.reset(key);
|
|
let node;
|
|
if (!this._root) {
|
|
this._root = new TernarySearchTreeNode();
|
|
this._root.segment = iter.value();
|
|
}
|
|
const stack = [];
|
|
// find insert_node
|
|
node = this._root;
|
|
while (true) {
|
|
const val = iter.cmp(node.segment);
|
|
if (val > 0) {
|
|
// left
|
|
if (!node.left) {
|
|
node.left = new TernarySearchTreeNode();
|
|
node.left.segment = iter.value();
|
|
}
|
|
stack.push([-1 /* Dir.Left */, node]);
|
|
node = node.left;
|
|
}
|
|
else if (val < 0) {
|
|
// right
|
|
if (!node.right) {
|
|
node.right = new TernarySearchTreeNode();
|
|
node.right.segment = iter.value();
|
|
}
|
|
stack.push([1 /* Dir.Right */, node]);
|
|
node = node.right;
|
|
}
|
|
else if (iter.hasNext()) {
|
|
// mid
|
|
iter.next();
|
|
if (!node.mid) {
|
|
node.mid = new TernarySearchTreeNode();
|
|
node.mid.segment = iter.value();
|
|
}
|
|
stack.push([0 /* Dir.Mid */, node]);
|
|
node = node.mid;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
// set value
|
|
const oldElement = node.value;
|
|
node.value = element;
|
|
node.key = key;
|
|
// balance
|
|
for (let i = stack.length - 1; i >= 0; i--) {
|
|
const node = stack[i][1];
|
|
node.updateHeight();
|
|
const bf = node.balanceFactor();
|
|
if (bf < -1 || bf > 1) {
|
|
// needs rotate
|
|
const d1 = stack[i][0];
|
|
const d2 = stack[i + 1][0];
|
|
if (d1 === 1 /* Dir.Right */ && d2 === 1 /* Dir.Right */) {
|
|
//right, right -> rotate left
|
|
stack[i][1] = node.rotateLeft();
|
|
}
|
|
else if (d1 === -1 /* Dir.Left */ && d2 === -1 /* Dir.Left */) {
|
|
// left, left -> rotate right
|
|
stack[i][1] = node.rotateRight();
|
|
}
|
|
else if (d1 === 1 /* Dir.Right */ && d2 === -1 /* Dir.Left */) {
|
|
// right, left -> double rotate right, left
|
|
node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
|
|
stack[i][1] = node.rotateLeft();
|
|
}
|
|
else if (d1 === -1 /* Dir.Left */ && d2 === 1 /* Dir.Right */) {
|
|
// left, right -> double rotate left, right
|
|
node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
|
|
stack[i][1] = node.rotateRight();
|
|
}
|
|
else {
|
|
throw new Error();
|
|
}
|
|
// patch path to parent
|
|
if (i > 0) {
|
|
switch (stack[i - 1][0]) {
|
|
case -1 /* Dir.Left */:
|
|
stack[i - 1][1].left = stack[i][1];
|
|
break;
|
|
case 1 /* Dir.Right */:
|
|
stack[i - 1][1].right = stack[i][1];
|
|
break;
|
|
case 0 /* Dir.Mid */:
|
|
stack[i - 1][1].mid = stack[i][1];
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
this._root = stack[0][1];
|
|
}
|
|
}
|
|
}
|
|
return oldElement;
|
|
}
|
|
get(key) {
|
|
var _c;
|
|
return (_c = this._getNode(key)) === null || _c === void 0 ? void 0 : _c.value;
|
|
}
|
|
_getNode(key) {
|
|
const iter = this._iter.reset(key);
|
|
let node = this._root;
|
|
while (node) {
|
|
const val = iter.cmp(node.segment);
|
|
if (val > 0) {
|
|
// left
|
|
node = node.left;
|
|
}
|
|
else if (val < 0) {
|
|
// right
|
|
node = node.right;
|
|
}
|
|
else if (iter.hasNext()) {
|
|
// mid
|
|
iter.next();
|
|
node = node.mid;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
has(key) {
|
|
const node = this._getNode(key);
|
|
return !((node === null || node === void 0 ? void 0 : node.value) === undefined && (node === null || node === void 0 ? void 0 : node.mid) === undefined);
|
|
}
|
|
delete(key) {
|
|
return this._delete(key, false);
|
|
}
|
|
deleteSuperstr(key) {
|
|
return this._delete(key, true);
|
|
}
|
|
_delete(key, superStr) {
|
|
var _c;
|
|
const iter = this._iter.reset(key);
|
|
const stack = [];
|
|
let node = this._root;
|
|
// find node
|
|
while (node) {
|
|
const val = iter.cmp(node.segment);
|
|
if (val > 0) {
|
|
// left
|
|
stack.push([-1 /* Dir.Left */, node]);
|
|
node = node.left;
|
|
}
|
|
else if (val < 0) {
|
|
// right
|
|
stack.push([1 /* Dir.Right */, node]);
|
|
node = node.right;
|
|
}
|
|
else if (iter.hasNext()) {
|
|
// mid
|
|
iter.next();
|
|
stack.push([0 /* Dir.Mid */, node]);
|
|
node = node.mid;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
if (!node) {
|
|
// node not found
|
|
return;
|
|
}
|
|
if (superStr) {
|
|
// removing children, reset height
|
|
node.left = undefined;
|
|
node.mid = undefined;
|
|
node.right = undefined;
|
|
node.height = 1;
|
|
}
|
|
else {
|
|
// removing element
|
|
node.key = undefined;
|
|
node.value = undefined;
|
|
}
|
|
// BST node removal
|
|
if (!node.mid && !node.value) {
|
|
if (node.left && node.right) {
|
|
// full node
|
|
const min = this._min(node.right);
|
|
const { key, value, segment } = min;
|
|
this._delete(min.key, false);
|
|
node.key = key;
|
|
node.value = value;
|
|
node.segment = segment;
|
|
}
|
|
else {
|
|
// empty or half empty
|
|
const newChild = (_c = node.left) !== null && _c !== void 0 ? _c : node.right;
|
|
if (stack.length > 0) {
|
|
const [dir, parent] = stack[stack.length - 1];
|
|
switch (dir) {
|
|
case -1 /* Dir.Left */:
|
|
parent.left = newChild;
|
|
break;
|
|
case 0 /* Dir.Mid */:
|
|
parent.mid = newChild;
|
|
break;
|
|
case 1 /* Dir.Right */:
|
|
parent.right = newChild;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
this._root = newChild;
|
|
}
|
|
}
|
|
}
|
|
// AVL balance
|
|
for (let i = stack.length - 1; i >= 0; i--) {
|
|
const node = stack[i][1];
|
|
node.updateHeight();
|
|
const bf = node.balanceFactor();
|
|
if (bf > 1) {
|
|
// right heavy
|
|
if (node.right.balanceFactor() >= 0) {
|
|
// right, right -> rotate left
|
|
stack[i][1] = node.rotateLeft();
|
|
}
|
|
else {
|
|
// right, left -> double rotate
|
|
node.right = node.right.rotateRight();
|
|
stack[i][1] = node.rotateLeft();
|
|
}
|
|
}
|
|
else if (bf < -1) {
|
|
// left heavy
|
|
if (node.left.balanceFactor() <= 0) {
|
|
// left, left -> rotate right
|
|
stack[i][1] = node.rotateRight();
|
|
}
|
|
else {
|
|
// left, right -> double rotate
|
|
node.left = node.left.rotateLeft();
|
|
stack[i][1] = node.rotateRight();
|
|
}
|
|
}
|
|
// patch path to parent
|
|
if (i > 0) {
|
|
switch (stack[i - 1][0]) {
|
|
case -1 /* Dir.Left */:
|
|
stack[i - 1][1].left = stack[i][1];
|
|
break;
|
|
case 1 /* Dir.Right */:
|
|
stack[i - 1][1].right = stack[i][1];
|
|
break;
|
|
case 0 /* Dir.Mid */:
|
|
stack[i - 1][1].mid = stack[i][1];
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
this._root = stack[0][1];
|
|
}
|
|
}
|
|
}
|
|
_min(node) {
|
|
while (node.left) {
|
|
node = node.left;
|
|
}
|
|
return node;
|
|
}
|
|
findSubstr(key) {
|
|
const iter = this._iter.reset(key);
|
|
let node = this._root;
|
|
let candidate = undefined;
|
|
while (node) {
|
|
const val = iter.cmp(node.segment);
|
|
if (val > 0) {
|
|
// left
|
|
node = node.left;
|
|
}
|
|
else if (val < 0) {
|
|
// right
|
|
node = node.right;
|
|
}
|
|
else if (iter.hasNext()) {
|
|
// mid
|
|
iter.next();
|
|
candidate = node.value || candidate;
|
|
node = node.mid;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
return node && node.value || candidate;
|
|
}
|
|
findSuperstr(key) {
|
|
const iter = this._iter.reset(key);
|
|
let node = this._root;
|
|
while (node) {
|
|
const val = iter.cmp(node.segment);
|
|
if (val > 0) {
|
|
// left
|
|
node = node.left;
|
|
}
|
|
else if (val < 0) {
|
|
// right
|
|
node = node.right;
|
|
}
|
|
else if (iter.hasNext()) {
|
|
// mid
|
|
iter.next();
|
|
node = node.mid;
|
|
}
|
|
else {
|
|
// collect
|
|
if (!node.mid) {
|
|
return undefined;
|
|
}
|
|
else {
|
|
return this._entries(node.mid);
|
|
}
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
forEach(callback) {
|
|
for (const [key, value] of this) {
|
|
callback(value, key);
|
|
}
|
|
}
|
|
*[Symbol.iterator]() {
|
|
yield* this._entries(this._root);
|
|
}
|
|
_entries(node) {
|
|
const result = [];
|
|
this._dfsEntries(node, result);
|
|
return result[Symbol.iterator]();
|
|
}
|
|
_dfsEntries(node, bucket) {
|
|
// DFS
|
|
if (!node) {
|
|
return;
|
|
}
|
|
if (node.left) {
|
|
this._dfsEntries(node.left, bucket);
|
|
}
|
|
if (node.value) {
|
|
bucket.push([node.key, node.value]);
|
|
}
|
|
if (node.mid) {
|
|
this._dfsEntries(node.mid, bucket);
|
|
}
|
|
if (node.right) {
|
|
this._dfsEntries(node.right, bucket);
|
|
}
|
|
}
|
|
}
|
|
class ResourceMapEntry {
|
|
constructor(uri, value) {
|
|
this.uri = uri;
|
|
this.value = value;
|
|
}
|
|
}
|
|
export class ResourceMap {
|
|
constructor(mapOrKeyFn, toKey) {
|
|
this[_a] = 'ResourceMap';
|
|
if (mapOrKeyFn instanceof ResourceMap) {
|
|
this.map = new Map(mapOrKeyFn.map);
|
|
this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey;
|
|
}
|
|
else {
|
|
this.map = new Map();
|
|
this.toKey = mapOrKeyFn !== null && mapOrKeyFn !== void 0 ? mapOrKeyFn : ResourceMap.defaultToKey;
|
|
}
|
|
}
|
|
set(resource, value) {
|
|
this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value));
|
|
return this;
|
|
}
|
|
get(resource) {
|
|
var _c;
|
|
return (_c = this.map.get(this.toKey(resource))) === null || _c === void 0 ? void 0 : _c.value;
|
|
}
|
|
has(resource) {
|
|
return this.map.has(this.toKey(resource));
|
|
}
|
|
get size() {
|
|
return this.map.size;
|
|
}
|
|
clear() {
|
|
this.map.clear();
|
|
}
|
|
delete(resource) {
|
|
return this.map.delete(this.toKey(resource));
|
|
}
|
|
forEach(clb, thisArg) {
|
|
if (typeof thisArg !== 'undefined') {
|
|
clb = clb.bind(thisArg);
|
|
}
|
|
for (const [_, entry] of this.map) {
|
|
clb(entry.value, entry.uri, this);
|
|
}
|
|
}
|
|
*values() {
|
|
for (const entry of this.map.values()) {
|
|
yield entry.value;
|
|
}
|
|
}
|
|
*keys() {
|
|
for (const entry of this.map.values()) {
|
|
yield entry.uri;
|
|
}
|
|
}
|
|
*entries() {
|
|
for (const entry of this.map.values()) {
|
|
yield [entry.uri, entry.value];
|
|
}
|
|
}
|
|
*[(_a = Symbol.toStringTag, Symbol.iterator)]() {
|
|
for (const [, entry] of this.map) {
|
|
yield [entry.uri, entry.value];
|
|
}
|
|
}
|
|
}
|
|
ResourceMap.defaultToKey = (resource) => resource.toString();
|
|
export class LinkedMap {
|
|
constructor() {
|
|
this[_b] = 'LinkedMap';
|
|
this._map = new Map();
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
this._size = 0;
|
|
this._state = 0;
|
|
}
|
|
clear() {
|
|
this._map.clear();
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
this._size = 0;
|
|
this._state++;
|
|
}
|
|
isEmpty() {
|
|
return !this._head && !this._tail;
|
|
}
|
|
get size() {
|
|
return this._size;
|
|
}
|
|
get first() {
|
|
var _c;
|
|
return (_c = this._head) === null || _c === void 0 ? void 0 : _c.value;
|
|
}
|
|
get last() {
|
|
var _c;
|
|
return (_c = this._tail) === null || _c === void 0 ? void 0 : _c.value;
|
|
}
|
|
has(key) {
|
|
return this._map.has(key);
|
|
}
|
|
get(key, touch = 0 /* Touch.None */) {
|
|
const item = this._map.get(key);
|
|
if (!item) {
|
|
return undefined;
|
|
}
|
|
if (touch !== 0 /* Touch.None */) {
|
|
this.touch(item, touch);
|
|
}
|
|
return item.value;
|
|
}
|
|
set(key, value, touch = 0 /* Touch.None */) {
|
|
let item = this._map.get(key);
|
|
if (item) {
|
|
item.value = value;
|
|
if (touch !== 0 /* Touch.None */) {
|
|
this.touch(item, touch);
|
|
}
|
|
}
|
|
else {
|
|
item = { key, value, next: undefined, previous: undefined };
|
|
switch (touch) {
|
|
case 0 /* Touch.None */:
|
|
this.addItemLast(item);
|
|
break;
|
|
case 1 /* Touch.AsOld */:
|
|
this.addItemFirst(item);
|
|
break;
|
|
case 2 /* Touch.AsNew */:
|
|
this.addItemLast(item);
|
|
break;
|
|
default:
|
|
this.addItemLast(item);
|
|
break;
|
|
}
|
|
this._map.set(key, item);
|
|
this._size++;
|
|
}
|
|
return this;
|
|
}
|
|
delete(key) {
|
|
return !!this.remove(key);
|
|
}
|
|
remove(key) {
|
|
const item = this._map.get(key);
|
|
if (!item) {
|
|
return undefined;
|
|
}
|
|
this._map.delete(key);
|
|
this.removeItem(item);
|
|
this._size--;
|
|
return item.value;
|
|
}
|
|
shift() {
|
|
if (!this._head && !this._tail) {
|
|
return undefined;
|
|
}
|
|
if (!this._head || !this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
const item = this._head;
|
|
this._map.delete(item.key);
|
|
this.removeItem(item);
|
|
this._size--;
|
|
return item.value;
|
|
}
|
|
forEach(callbackfn, thisArg) {
|
|
const state = this._state;
|
|
let current = this._head;
|
|
while (current) {
|
|
if (thisArg) {
|
|
callbackfn.bind(thisArg)(current.value, current.key, this);
|
|
}
|
|
else {
|
|
callbackfn(current.value, current.key, this);
|
|
}
|
|
if (this._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
current = current.next;
|
|
}
|
|
}
|
|
keys() {
|
|
const map = this;
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]() {
|
|
return iterator;
|
|
},
|
|
next() {
|
|
if (map._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: current.key, done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
values() {
|
|
const map = this;
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]() {
|
|
return iterator;
|
|
},
|
|
next() {
|
|
if (map._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: current.value, done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
entries() {
|
|
const map = this;
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]() {
|
|
return iterator;
|
|
},
|
|
next() {
|
|
if (map._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: [current.key, current.value], done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
[(_b = Symbol.toStringTag, Symbol.iterator)]() {
|
|
return this.entries();
|
|
}
|
|
trimOld(newSize) {
|
|
if (newSize >= this.size) {
|
|
return;
|
|
}
|
|
if (newSize === 0) {
|
|
this.clear();
|
|
return;
|
|
}
|
|
let current = this._head;
|
|
let currentSize = this.size;
|
|
while (current && currentSize > newSize) {
|
|
this._map.delete(current.key);
|
|
current = current.next;
|
|
currentSize--;
|
|
}
|
|
this._head = current;
|
|
this._size = currentSize;
|
|
if (current) {
|
|
current.previous = undefined;
|
|
}
|
|
this._state++;
|
|
}
|
|
addItemFirst(item) {
|
|
// First time Insert
|
|
if (!this._head && !this._tail) {
|
|
this._tail = item;
|
|
}
|
|
else if (!this._head) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
else {
|
|
item.next = this._head;
|
|
this._head.previous = item;
|
|
}
|
|
this._head = item;
|
|
this._state++;
|
|
}
|
|
addItemLast(item) {
|
|
// First time Insert
|
|
if (!this._head && !this._tail) {
|
|
this._head = item;
|
|
}
|
|
else if (!this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
else {
|
|
item.previous = this._tail;
|
|
this._tail.next = item;
|
|
}
|
|
this._tail = item;
|
|
this._state++;
|
|
}
|
|
removeItem(item) {
|
|
if (item === this._head && item === this._tail) {
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
}
|
|
else if (item === this._head) {
|
|
// This can only happen if size === 1 which is handled
|
|
// by the case above.
|
|
if (!item.next) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
item.next.previous = undefined;
|
|
this._head = item.next;
|
|
}
|
|
else if (item === this._tail) {
|
|
// This can only happen if size === 1 which is handled
|
|
// by the case above.
|
|
if (!item.previous) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
item.previous.next = undefined;
|
|
this._tail = item.previous;
|
|
}
|
|
else {
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
if (!next || !previous) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.next = undefined;
|
|
item.previous = undefined;
|
|
this._state++;
|
|
}
|
|
touch(item, touch) {
|
|
if (!this._head || !this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
if ((touch !== 1 /* Touch.AsOld */ && touch !== 2 /* Touch.AsNew */)) {
|
|
return;
|
|
}
|
|
if (touch === 1 /* Touch.AsOld */) {
|
|
if (item === this._head) {
|
|
return;
|
|
}
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
// Unlink the item
|
|
if (item === this._tail) {
|
|
// previous must be defined since item was not head but is tail
|
|
// So there are more than on item in the map
|
|
previous.next = undefined;
|
|
this._tail = previous;
|
|
}
|
|
else {
|
|
// Both next and previous are not undefined since item was neither head nor tail.
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
// Insert the node at head
|
|
item.previous = undefined;
|
|
item.next = this._head;
|
|
this._head.previous = item;
|
|
this._head = item;
|
|
this._state++;
|
|
}
|
|
else if (touch === 2 /* Touch.AsNew */) {
|
|
if (item === this._tail) {
|
|
return;
|
|
}
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
// Unlink the item.
|
|
if (item === this._head) {
|
|
// next must be defined since item was not tail but is head
|
|
// So there are more than on item in the map
|
|
next.previous = undefined;
|
|
this._head = next;
|
|
}
|
|
else {
|
|
// Both next and previous are not undefined since item was neither head nor tail.
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.next = undefined;
|
|
item.previous = this._tail;
|
|
this._tail.next = item;
|
|
this._tail = item;
|
|
this._state++;
|
|
}
|
|
}
|
|
toJSON() {
|
|
const data = [];
|
|
this.forEach((value, key) => {
|
|
data.push([key, value]);
|
|
});
|
|
return data;
|
|
}
|
|
fromJSON(data) {
|
|
this.clear();
|
|
for (const [key, value] of data) {
|
|
this.set(key, value);
|
|
}
|
|
}
|
|
}
|
|
export class LRUCache extends LinkedMap {
|
|
constructor(limit, ratio = 1) {
|
|
super();
|
|
this._limit = limit;
|
|
this._ratio = Math.min(Math.max(0, ratio), 1);
|
|
}
|
|
get limit() {
|
|
return this._limit;
|
|
}
|
|
set limit(limit) {
|
|
this._limit = limit;
|
|
this.checkTrim();
|
|
}
|
|
get(key, touch = 2 /* Touch.AsNew */) {
|
|
return super.get(key, touch);
|
|
}
|
|
peek(key) {
|
|
return super.get(key, 0 /* Touch.None */);
|
|
}
|
|
set(key, value) {
|
|
super.set(key, value, 2 /* Touch.AsNew */);
|
|
this.checkTrim();
|
|
return this;
|
|
}
|
|
checkTrim() {
|
|
if (this.size > this._limit) {
|
|
this.trimOld(Math.round(this._limit * this._ratio));
|
|
}
|
|
}
|
|
}
|