tylen/ESP-Ventilation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mqtt and socket added

Browse Source
This commit is contained in:
Miisa Ekholm
2022-10-21 11:17:48 +03:00
parent 52370df9ce
commit 9e3d953b9e
751 changed files with 185105 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeIterator.d.ts generated vendored Normal file
View File

@@ -0,0 +1,11 @@
import TreeNode from './TreeNode';
import { ContainerIterator } from "../../ContainerBase/index";
declare abstract class TreeIterator<K, V> extends ContainerIterator<K | [K, V]> {
protected node: TreeNode<K, V>;
protected header: TreeNode<K, V>;
pre: () => this;
next: () => this;
constructor(node: TreeNode<K, V>, header: TreeNode<K, V>, iteratorType?: boolean);
equals(obj: TreeIterator<K, V>): boolean;
}
export default TreeIterator;

62
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeIterator.js generated vendored Normal file
View File

@@ -0,0 +1,62 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
import { ContainerIterator } from "../../ContainerBase/index";
var TreeIterator = /** @class */ (function (_super) {
__extends(TreeIterator, _super);
function TreeIterator(node, header, iteratorType) {
var _this = _super.call(this, iteratorType) || this;
_this.node = node;
_this.header = header;
if (_this.iteratorType === ContainerIterator.NORMAL) {
_this.pre = function () {
if (this.node === this.header.left) {
throw new RangeError('LinkList iterator access denied!');
}
this.node = this.node.pre();
return this;
};
_this.next = function () {
if (this.node === this.header) {
throw new RangeError('LinkList iterator access denied!');
}
this.node = this.node.next();
return this;
};
}
else {
_this.pre = function () {
if (this.node === this.header.right) {
throw new RangeError('LinkList iterator access denied!');
}
this.node = this.node.next();
return this;
};
_this.next = function () {
if (this.node === this.header) {
throw new RangeError('LinkList iterator access denied!');
}
this.node = this.node.pre();
return this;
};
}
return _this;
}
TreeIterator.prototype.equals = function (obj) {
return this.node === obj.node;
};
return TreeIterator;
}(ContainerIterator));
export default TreeIterator;

36
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeNode.d.ts generated vendored Normal file
View File

@@ -0,0 +1,36 @@
declare class TreeNode<K, V> {
static readonly RED = true;
static readonly BLACK = false;
color: boolean;
key: K | undefined;
value: V | undefined;
left: TreeNode<K, V> | undefined;
right: TreeNode<K, V> | undefined;
parent: TreeNode<K, V> | undefined;
constructor(key?: K, value?: V);
/**
* @description Get the pre node.
* @return TreeNode about the pre node.
*/
pre(): TreeNode<K, V>;
/**
* @description Get the next node.
* @return TreeNode about the next node.
*/
next(): TreeNode<K, V>;
/**
* @description Rotate left.
* @return TreeNode about moved to original position after rotation.
*/
rotateLeft(): TreeNode<K, V>;
/**
* @description Rotate left.
* @return TreeNode about moved to original position after rotation.
*/
rotateRight(): TreeNode<K, V>;
/**
* @description Remove this.
*/
remove(): void;
}
export default TreeNode;

121
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/TreeNode.js generated vendored Normal file
View File

@@ -0,0 +1,121 @@
var TreeNode = /** @class */ (function () {
function TreeNode(key, value) {
this.color = true;
this.key = undefined;
this.value = undefined;
this.left = undefined;
this.right = undefined;
this.parent = undefined;
this.key = key;
this.value = value;
}
/**
* @description Get the pre node.
* @return TreeNode about the pre node.
*/
TreeNode.prototype.pre = function () {
var preNode = this;
if (preNode.color === TreeNode.RED &&
preNode.parent.parent === preNode) {
preNode = preNode.right;
}
else if (preNode.left) {
preNode = preNode.left;
while (preNode.right) {
preNode = preNode.right;
}
}
else {
var pre = preNode.parent;
while (pre.left === preNode) {
preNode = pre;
pre = preNode.parent;
}
preNode = pre;
}
return preNode;
};
/**
* @description Get the next node.
* @return TreeNode about the next node.
*/
TreeNode.prototype.next = function () {
var nextNode = this;
if (nextNode.right) {
nextNode = nextNode.right;
while (nextNode.left) {
nextNode = nextNode.left;
}
}
else {
var pre = nextNode.parent;
while (pre.right === nextNode) {
nextNode = pre;
pre = nextNode.parent;
}
if (nextNode.right !== pre) {
nextNode = pre;
}
}
return nextNode;
};
/**
* @description Rotate left.
* @return TreeNode about moved to original position after rotation.
*/
TreeNode.prototype.rotateLeft = function () {
var PP = this.parent;
var V = this.right;
var R = V.left;
if (PP.parent === this)
PP.parent = V;
else if (PP.left === this)
PP.left = V;
else
PP.right = V;
V.parent = PP;
V.left = this;
this.parent = V;
this.right = R;
if (R)
R.parent = this;
return V;
};
/**
* @description Rotate left.
* @return TreeNode about moved to original position after rotation.
*/
TreeNode.prototype.rotateRight = function () {
var PP = this.parent;
var F = this.left;
var K = F.right;
if (PP.parent === this)
PP.parent = F;
else if (PP.left === this)
PP.left = F;
else
PP.right = F;
F.parent = PP;
F.right = this;
this.parent = F;
this.left = K;
if (K)
K.parent = this;
return F;
};
/**
* @description Remove this.
*/
TreeNode.prototype.remove = function () {
var parent = this.parent;
if (this === parent.left) {
parent.left = undefined;
}
else
parent.right = undefined;
};
TreeNode.RED = true;
TreeNode.BLACK = false;
return TreeNode;
}());
export default TreeNode;

127
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,127 @@
import TreeNode from './TreeNode';
import TreeIterator from './TreeIterator';
import { Container } from "../../ContainerBase/index";
declare abstract class TreeContainer<K, V> extends Container<K | [K, V]> {
protected root: TreeNode<K, V> | undefined;
protected header: TreeNode<K, V>;
protected cmp: (x: K, y: K) => number;
protected constructor(cmp?: (x: K, y: K) => number);
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is greater than or equals to the given key.
* @protected
*/
protected _lowerBound(curNode: TreeNode<K, V> | undefined, key: K): TreeNode<K, V>;
/**
* @param key The given key you want to compare.
* @return An iterator to the first element not less than the given key.
*/
abstract lowerBound(key: K): TreeIterator<K, V>;
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is greater than the given key.
* @protected
*/
protected _upperBound(curNode: TreeNode<K, V> | undefined, key: K): TreeNode<K, V>;
/**
* @param key The given key you want to compare.
* @return An iterator to the first element greater than the given key.
*/
abstract upperBound(key: K): TreeIterator<K, V>;
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is less than or equals to the given key.
* @protected
*/
protected _reverseLowerBound(curNode: TreeNode<K, V> | undefined, key: K): TreeNode<K, V>;
/**
* @param key The given key you want to compare.
* @return An iterator to the first element not greater than the given key.
*/
abstract reverseLowerBound(key: K): TreeIterator<K, V>;
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is less than the given key.
* @protected
*/
protected _reverseUpperBound(curNode: TreeNode<K, V> | undefined, key: K): TreeNode<K, V>;
/**
* @param key The given key you want to compare.
* @return An iterator to the first element less than the given key.
*/
abstract reverseUpperBound(key: K): TreeIterator<K, V>;
/**
* @description Union the other tree to self.
* <br/>
* Waiting for optimization, this is O(mlog(n+m)) algorithm now,
* but we expect it to be O(mlog(n/m+1)).<br/>
* More information =>
* https://en.wikipedia.org/wiki/Red_black_tree
* <br/>
* @param other The other tree container you want to merge.
*/
abstract union(other: TreeContainer<K, V>): void;
/**
* @description Make self balance after erase a node.
* @param curNode The node want to remove.
* @protected
*/
protected eraseNodeSelfBalance(curNode: TreeNode<K, V>): void;
/**
* @description Remove a node.
* @param curNode The node you want to remove.
* @protected
*/
protected eraseNode(curNode: TreeNode<K, V>): void;
/**
* @description InOrder traversal the tree.
* @protected
*/
protected inOrderTraversal: (curNode: TreeNode<K, V> | undefined, callback: (curNode: TreeNode<K, V>) => boolean) => boolean;
/**
* @description Make self balance after insert a node.
* @param curNode The node want to insert.
* @protected
*/
protected insertNodeSelfBalance(curNode: TreeNode<K, V>): void;
/**
* @description Find node which key is equals to the given key.
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @protected
*/
protected findElementNode(curNode: TreeNode<K, V> | undefined, key: K): TreeNode<K, V> | undefined;
/**
* @description Insert a key-value pair or set value by the given key.
* @param key The key want to insert.
* @param value The value want to set.
* @param hint You can give an iterator hint to improve insertion efficiency.
* @protected
*/
protected set(key: K, value?: V, hint?: TreeIterator<K, V>): void;
clear(): void;
/**
* @description Update node's key by iterator.
* @param iter The iterator you want to change.
* @param key The key you want to update.
* @return Boolean about if the modification is successful.
*/
updateKeyByIterator(iter: TreeIterator<K, V>, key: K): boolean;
eraseElementByPos(pos: number): void;
/**
* @description Remove the element of the specified key.
* @param key The key you want to remove.
*/
eraseElementByKey(key: K): void;
eraseElementByIterator(iter: TreeIterator<K, V>): TreeIterator<K, V>;
/**
* @description Get the height of the tree.
* @return Number about the height of the RB-tree.
*/
getHeight(): number;
}
export default TreeContainer;

601
WebUI/node_modules/js-sdsl/dist/esm/container/TreeContainer/Base/index.js generated vendored Normal file
View File

@@ -0,0 +1,601 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
import TreeNode from './TreeNode';
import { Container } from "../../ContainerBase/index";
import { checkWithinAccessParams } from "../../../utils/checkParams";
var TreeContainer = /** @class */ (function (_super) {
__extends(TreeContainer, _super);
function TreeContainer(cmp) {
if (cmp === void 0) { cmp = function (x, y) {
if (x < y)
return -1;
if (x > y)
return 1;
return 0;
}; }
var _this = _super.call(this) || this;
_this.root = undefined;
_this.header = new TreeNode();
/**
* @description InOrder traversal the tree.
* @protected
*/
_this.inOrderTraversal = function (curNode, callback) {
if (curNode === undefined)
return false;
var ifReturn = _this.inOrderTraversal(curNode.left, callback);
if (ifReturn)
return true;
if (callback(curNode))
return true;
return _this.inOrderTraversal(curNode.right, callback);
};
_this.cmp = cmp;
return _this;
}
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is greater than or equals to the given key.
* @protected
*/
TreeContainer.prototype._lowerBound = function (curNode, key) {
var resNode;
while (curNode) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult < 0) {
curNode = curNode.right;
}
else if (cmpResult > 0) {
resNode = curNode;
curNode = curNode.left;
}
else
return curNode;
}
return resNode === undefined ? this.header : resNode;
};
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is greater than the given key.
* @protected
*/
TreeContainer.prototype._upperBound = function (curNode, key) {
var resNode;
while (curNode) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult <= 0) {
curNode = curNode.right;
}
else if (cmpResult > 0) {
resNode = curNode;
curNode = curNode.left;
}
}
return resNode === undefined ? this.header : resNode;
};
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is less than or equals to the given key.
* @protected
*/
TreeContainer.prototype._reverseLowerBound = function (curNode, key) {
var resNode;
while (curNode) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult < 0) {
resNode = curNode;
curNode = curNode.right;
}
else if (cmpResult > 0) {
curNode = curNode.left;
}
else
return curNode;
}
return resNode === undefined ? this.header : resNode;
};
/**
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @return TreeNode which key is less than the given key.
* @protected
*/
TreeContainer.prototype._reverseUpperBound = function (curNode, key) {
var resNode;
while (curNode) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult < 0) {
resNode = curNode;
curNode = curNode.right;
}
else if (cmpResult >= 0) {
curNode = curNode.left;
}
}
return resNode === undefined ? this.header : resNode;
};
/**
* @description Make self balance after erase a node.
* @param curNode The node want to remove.
* @protected
*/
TreeContainer.prototype.eraseNodeSelfBalance = function (curNode) {
while (true) {
var parentNode = curNode.parent;
if (parentNode === this.header)
return;
if (curNode.color === TreeNode.RED) {
curNode.color = TreeNode.BLACK;
return;
}
if (curNode === parentNode.left) {
var brother = parentNode.right;
if (brother.color === TreeNode.RED) {
brother.color = TreeNode.BLACK;
parentNode.color = TreeNode.RED;
if (parentNode === this.root) {
this.root = parentNode.rotateLeft();
}
else
parentNode.rotateLeft();
}
else if (brother.color === TreeNode.BLACK) {
if (brother.right && brother.right.color === TreeNode.RED) {
brother.color = parentNode.color;
parentNode.color = TreeNode.BLACK;
brother.right.color = TreeNode.BLACK;
if (parentNode === this.root) {
this.root = parentNode.rotateLeft();
}
else
parentNode.rotateLeft();
return;
}
else if (brother.left && brother.left.color === TreeNode.RED) {
brother.color = TreeNode.RED;
brother.left.color = TreeNode.BLACK;
brother.rotateRight();
}
else {
brother.color = TreeNode.RED;
curNode = parentNode;
}
}
}
else {
var brother = parentNode.left;
if (brother.color === TreeNode.RED) {
brother.color = TreeNode.BLACK;
parentNode.color = TreeNode.RED;
if (parentNode === this.root) {
this.root = parentNode.rotateRight();
}
else
parentNode.rotateRight();
}
else {
if (brother.left && brother.left.color === TreeNode.RED) {
brother.color = parentNode.color;
parentNode.color = TreeNode.BLACK;
brother.left.color = TreeNode.BLACK;
if (parentNode === this.root) {
this.root = parentNode.rotateRight();
}
else
parentNode.rotateRight();
return;
}
else if (brother.right && brother.right.color === TreeNode.RED) {
brother.color = TreeNode.RED;
brother.right.color = TreeNode.BLACK;
brother.rotateLeft();
}
else {
brother.color = TreeNode.RED;
curNode = parentNode;
}
}
}
}
};
/**
* @description Remove a node.
* @param curNode The node you want to remove.
* @protected
*/
TreeContainer.prototype.eraseNode = function (curNode) {
var _a, _b;
if (this.length === 1) {
this.clear();
return;
}
var swapNode = curNode;
while (swapNode.left || swapNode.right) {
if (swapNode.right) {
swapNode = swapNode.right;
while (swapNode.left)
swapNode = swapNode.left;
}
else if (swapNode.left) {
swapNode = swapNode.left;
}
_a = __read([swapNode.key, curNode.key], 2), curNode.key = _a[0], swapNode.key = _a[1];
_b = __read([swapNode.value, curNode.value], 2), curNode.value = _b[0], swapNode.value = _b[1];
curNode = swapNode;
}
if (this.header.left === swapNode) {
this.header.left = swapNode.parent;
}
else if (this.header.right === swapNode) {
this.header.right = swapNode.parent;
}
this.eraseNodeSelfBalance(swapNode);
swapNode.remove();
this.length -= 1;
this.root.color = TreeNode.BLACK;
};
/**
* @description Make self balance after insert a node.
* @param curNode The node want to insert.
* @protected
*/
TreeContainer.prototype.insertNodeSelfBalance = function (curNode) {
while (true) {
var parentNode = curNode.parent;
if (parentNode.color === TreeNode.BLACK)
return;
var grandParent = parentNode.parent;
if (parentNode === grandParent.left) {
var uncle = grandParent.right;
if (uncle && uncle.color === TreeNode.RED) {
uncle.color = parentNode.color = TreeNode.BLACK;
if (grandParent === this.root)
return;
grandParent.color = TreeNode.RED;
curNode = grandParent;
continue;
}
else if (curNode === parentNode.right) {
curNode.color = TreeNode.BLACK;
if (curNode.left)
curNode.left.parent = parentNode;
if (curNode.right)
curNode.right.parent = grandParent;
parentNode.right = curNode.left;
grandParent.left = curNode.right;
curNode.left = parentNode;
curNode.right = grandParent;
if (grandParent === this.root) {
this.root = curNode;
this.header.parent = curNode;
}
else {
var GP = grandParent.parent;
if (GP.left === grandParent) {
GP.left = curNode;
}
else
GP.right = curNode;
}
curNode.parent = grandParent.parent;
parentNode.parent = curNode;
grandParent.parent = curNode;
}
else {
parentNode.color = TreeNode.BLACK;
if (grandParent === this.root) {
this.root = grandParent.rotateRight();
}
else
grandParent.rotateRight();
}
grandParent.color = TreeNode.RED;
}
else {
var uncle = grandParent.left;
if (uncle && uncle.color === TreeNode.RED) {
uncle.color = parentNode.color = TreeNode.BLACK;
if (grandParent === this.root)
return;
grandParent.color = TreeNode.RED;
curNode = grandParent;
continue;
}
else if (curNode === parentNode.left) {
curNode.color = TreeNode.BLACK;
if (curNode.left)
curNode.left.parent = grandParent;
if (curNode.right)
curNode.right.parent = parentNode;
grandParent.right = curNode.left;
parentNode.left = curNode.right;
curNode.left = grandParent;
curNode.right = parentNode;
if (grandParent === this.root) {
this.root = curNode;
this.header.parent = curNode;
}
else {
var GP = grandParent.parent;
if (GP.left === grandParent) {
GP.left = curNode;
}
else
GP.right = curNode;
}
curNode.parent = grandParent.parent;
parentNode.parent = curNode;
grandParent.parent = curNode;
}
else {
parentNode.color = TreeNode.BLACK;
if (grandParent === this.root) {
this.root = grandParent.rotateLeft();
}
else
grandParent.rotateLeft();
}
grandParent.color = TreeNode.RED;
}
return;
}
};
/**
* @description Find node which key is equals to the given key.
* @param curNode The starting node of the search.
* @param key The key you want to search.
* @protected
*/
TreeContainer.prototype.findElementNode = function (curNode, key) {
while (curNode) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult < 0) {
curNode = curNode.right;
}
else if (cmpResult > 0) {
curNode = curNode.left;
}
else
return curNode;
}
return curNode;
};
/**
* @description Insert a key-value pair or set value by the given key.
* @param key The key want to insert.
* @param value The value want to set.
* @param hint You can give an iterator hint to improve insertion efficiency.
* @protected
*/
TreeContainer.prototype.set = function (key, value, hint) {
if (this.root === undefined) {
this.length += 1;
this.root = new TreeNode(key, value);
this.root.color = TreeNode.BLACK;
this.root.parent = this.header;
this.header.parent = this.root;
this.header.left = this.root;
this.header.right = this.root;
return;
}
var curNode;
var minNode = this.header.left;
var compareToMin = this.cmp(minNode.key, key);
if (compareToMin === 0) {
minNode.value = value;
return;
}
else if (compareToMin > 0) {
minNode.left = new TreeNode(key, value);
minNode.left.parent = minNode;
curNode = minNode.left;
this.header.left = curNode;
}
else {
var maxNode = this.header.right;
var compareToMax = this.cmp(maxNode.key, key);
if (compareToMax === 0) {
maxNode.value = value;
return;
}
else if (compareToMax < 0) {
maxNode.right = new TreeNode(key, value);
maxNode.right.parent = maxNode;
curNode = maxNode.right;
this.header.right = curNode;
}
else {
if (hint !== undefined) {
// @ts-ignore
var iterNode = hint.node;
if (iterNode !== this.header) {
var iterCmpRes = this.cmp(iterNode.key, key);
if (iterCmpRes === 0) {
iterNode.value = value;
return;
}
else if (iterCmpRes > 0) {
var preNode = iterNode.pre();
var preCmpRes = this.cmp(preNode.key, key);
if (preCmpRes === 0) {
preNode.value = value;
return;
}
else if (preCmpRes < 0) {
curNode = new TreeNode(key, value);
if (preNode.right === undefined) {
preNode.right = curNode;
curNode.parent = preNode;
}
else {
iterNode.left = curNode;
curNode.parent = iterNode;
}
}
}
}
}
if (curNode === undefined) {
curNode = this.root;
while (true) {
var cmpResult = this.cmp(curNode.key, key);
if (cmpResult > 0) {
if (curNode.left === undefined) {
curNode.left = new TreeNode(key, value);
curNode.left.parent = curNode;
curNode = curNode.left;
break;
}
curNode = curNode.left;
}
else if (cmpResult < 0) {
if (curNode.right === undefined) {
curNode.right = new TreeNode(key, value);
curNode.right.parent = curNode;
curNode = curNode.right;
break;
}
curNode = curNode.right;
}
else {
curNode.value = value;
return;
}
}
}
}
}
this.length += 1;
this.insertNodeSelfBalance(curNode);
};
TreeContainer.prototype.clear = function () {
this.length = 0;
this.root = undefined;
this.header.parent = undefined;
this.header.left = this.header.right = undefined;
};
/**
* @description Update node's key by iterator.
* @param iter The iterator you want to change.
* @param key The key you want to update.
* @return Boolean about if the modification is successful.
*/
TreeContainer.prototype.updateKeyByIterator = function (iter, key) {
// @ts-ignore
var node = iter.node;
if (node === this.header) {
throw new TypeError('Invalid iterator!');
}
if (this.length === 1) {
node.key = key;
return true;
}
if (node === this.header.left) {
if (this.cmp(node.next().key, key) > 0) {
node.key = key;
return true;
}
return false;
}
if (node === this.header.right) {
if (this.cmp(node.pre().key, key) < 0) {
node.key = key;
return true;
}
return false;
}
var preKey = node.pre().key;
if (this.cmp(preKey, key) >= 0)
return false;
var nextKey = node.next().key;
if (this.cmp(nextKey, key) <= 0)
return false;
node.key = key;
return true;
};
TreeContainer.prototype.eraseElementByPos = function (pos) {
var _this = this;
checkWithinAccessParams(pos, 0, this.length - 1);
var index = 0;
this.inOrderTraversal(this.root, function (curNode) {
if (pos === index) {
_this.eraseNode(curNode);
return true;
}
index += 1;
return false;
});
};
/**
* @description Remove the element of the specified key.
* @param key The key you want to remove.
*/
TreeContainer.prototype.eraseElementByKey = function (key) {
if (!this.length)
return;
var curNode = this.findElementNode(this.root, key);
if (curNode === undefined)
return;
this.eraseNode(curNode);
};
TreeContainer.prototype.eraseElementByIterator = function (iter) {
// @ts-ignore
var node = iter.node;
if (node === this.header) {
throw new RangeError('Invalid iterator');
}
if (node.right === undefined) {
iter = iter.next();
}
this.eraseNode(node);
return iter;
};
/**
* @description Get the height of the tree.
* @return Number about the height of the RB-tree.
*/
TreeContainer.prototype.getHeight = function () {
if (!this.length)
return 0;
var traversal = function (curNode) {
if (!curNode)
return 0;
return Math.max(traversal(curNode.left), traversal(curNode.right)) + 1;
};
return traversal(this.root);
};
return TreeContainer;
}(Container));
export default TreeContainer;