@fluidframework/merge-tree 0.51.0 → 0.52.0

package/lib/collections.js

@@ -2,11 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-/* eslint-disable @typescript-eslint/consistent-type-assertions, eqeqeq, object-shorthand */
-/* eslint-disable no-bitwise */
-/* Remove once strictNullCheck is enabled */
-import { Trace } from "@fluidframework/common-utils";
-import { internedSpaces } from "./mergeTree";
 export class Stack {
     constructor() {
         this.items = [];
@@ -24,7 +19,7 @@ export class Stack {
         return this.items.pop();
     }
 }
-export function ListRemoveEntry(entry) {
+function ListRemoveEntry(entry) {
     if (entry === undefined) {
         return undefined;
     }
@@ -37,7 +32,7 @@ export function ListRemoveEntry(entry) {
     }
     return (entry);
 }
-export function ListMakeEntry(data) {
+function ListMakeEntry(data) {
     return new List(false, data);
 }
 export function ListMakeHead() {
@@ -120,13 +115,6 @@ export class List {
     empty() {
         return (this.next === this);
     }
-    pushEntry(entry) {
-        entry.isHead = false;
-        entry.next = this.next;
-        entry.prev = this;
-        this.next = entry;
-        entry.next.prev = entry;
-    }
     push(data) {
         const entry = ListMakeEntry(data);
         entry.data = data;
@@ -136,46 +124,7 @@ export class List {
         this.next = entry;
         entry.next.prev = entry;
     }
-    popEntry(head) {
-        if (this.next.isHead) {
-            return undefined;
-        }
-        else {
-            return ListRemoveEntry(this.next);
-        }
-    }
-    insertEntry(entry) {
-        entry.isHead = false;
-        this.prev.next = entry;
-        entry.next = this;
-        entry.prev = this.prev;
-        this.prev = entry;
-        return entry;
-    }
-    insertAfter(data) {
-        const entry = ListMakeEntry(data);
-        entry.next = this.next;
-        entry.prev = this;
-        this.next = entry;
-        entry.next.prev = entry;
-        return (entry);
-    }
-    insertBefore(data) {
-        const entry = ListMakeEntry(data);
-        return this.insertEntryBefore(entry);
-    }
-    insertEntryBefore(entry) {
-        this.prev.next = entry;
-        entry.next = this;
-        entry.prev = this.prev;
-        this.prev = entry;
-        return (entry);
-    }
 }
-export const numberComparer = {
-    min: Number.MIN_VALUE,
-    compare: (a, b) => a - b,
-};
 export class Heap {
     constructor(a, comp) {
         this.comp = comp;
@@ -227,93 +176,6 @@ export class Heap {
         }
     }
 }
-// For testing
-export function LinearDictionary(compareKeys) {
-    const props = [];
-    const compareProps = (a, b) => compareKeys(a.key, b.key);
-    function diag() {
-        console.log(`size is ${props.length}`);
-    }
-    function mapRange(action, accum, start, end) {
-        let _start = start;
-        let _end = end;
-        if (props.length !== 0) {
-            return;
-        }
-        if (_start === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            _start = min().key;
-        }
-        if (_end === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            _end = max().key;
-        }
-        for (let i = 0, len = props.length; i < len; i++) {
-            if (compareKeys(_start, props[i].key) <= 0) {
-                const ecmp = compareKeys(_end, props[i].key);
-                if (ecmp < 0) {
-                    break;
-                }
-                if (!action(props[i], accum)) {
-                    break;
-                }
-            }
-        }
-    }
-    function map(action, accum) {
-        mapRange(action, accum);
-    }
-    function min() {
-        if (props.length > 0) {
-            return props[0];
-        }
-    }
-    function max() {
-        if (props.length > 0) {
-            return props[props.length - 1];
-        }
-    }
-    function get(key) {
-        for (let i = 0, len = props.length; i < len; i++) {
-            if (props[i].key == key) {
-                return props[i];
-            }
-        }
-    }
-    function put(key, data) {
-        if (key !== undefined) {
-            if (data === undefined) {
-                remove(key);
-            }
-            else {
-                props.push({ key, data });
-                props.sort(compareProps); // Go to insertion sort if too slow
-            }
-        }
-    }
-    function remove(key) {
-        if (key !== undefined) {
-            for (let i = 0, len = props.length; i < len; i++) {
-                if (props[i].key == key) {
-                    props[i] = props[len - 1];
-                    props.length--;
-                    props.sort(compareProps);
-                    break;
-                }
-            }
-        }
-    }
-    return {
-        min: min,
-        max: max,
-        map: map,
-        mapRange: mapRange,
-        remove: remove,
-        get: get,
-        put: put,
-        diag: diag,
-    };
-}
 export var RBColor;
 (function (RBColor) {
     RBColor[RBColor["RED"] = 0] = "RED";
@@ -489,18 +351,6 @@ export class RedBlackTree {
             this.aug.update(node);
         }
     }
-    removeMin() {
-        if (this.root) {
-            if ((!this.isRed(this.root.left)) && (!this.isRed(this.root.right))) {
-                this.root.color = 0 /* RED */;
-            }
-            this.root = this.nodeRemoveMin(this.root);
-            if (this.root) {
-                this.root.color = 1 /* BLACK */;
-            }
-        }
-        // TODO: error on empty
-    }
     nodeRemoveMin(node) {
         let _node = node;
         if (_node.left) {
@@ -512,33 +362,6 @@ export class RedBlackTree {
             return this.balance(_node);
         }
     }
-    removeMax() {
-        if (this.root) {
-            if ((!this.isRed(this.root.left)) && (!this.isRed(this.root.right))) {
-                this.root.color = 0 /* RED */;
-            }
-            this.root = this.nodeRemoveMax(this.root);
-            if (this.root) {
-                this.root.color = 1 /* BLACK */;
-            }
-        }
-        // TODO: error on empty
-    }
-    nodeRemoveMax(node) {
-        let _node = node;
-        if (this.isRed(_node.left)) {
-            _node = this.rotateRight(_node);
-        }
-        if (!_node.right) {
-            return undefined;
-        }
-        if ((!this.isRed(_node.right)) && (!this.isRed(_node.right.left))) {
-            _node = this.moveRedRight(_node);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        _node.right = this.nodeRemoveMax(_node.right);
-        return this.balance(_node);
-    }
     remove(key) {
         if (key !== undefined) {
             if (!this.contains(key)) {
@@ -875,115 +698,11 @@ export class RedBlackTree {
         console.log(`Height is ${this.height()}`);
     }
 }
-/**
- * Union of two ranges; assumes for both ranges start \<= end.
- * @param a - A range
- * @param b - A range
- */
-export function integerRangeUnion(a, b) {
-    return {
-        start: Math.min(a.start, b.start),
-        end: Math.max(a.end, b.end),
-    };
-}
-export function integerRangeOverlaps(a, b) {
-    return (a.start < b.end) && (a.end > b.start);
-}
-export function integerRangeComparer(a, b) {
-    if (a.start === b.start) {
-        return a.end - b.end;
-    }
-    else {
-        return a.start - b.start;
-    }
-}
-export const integerRangeCopy = (r) => ({ start: r.start, end: r.end });
 export const integerRangeToString = (range) => `[${range.start},${range.end})`;
-// TODO: handle duplicate keys
-export class IntegerRangeTree {
-    constructor() {
-        this.ranges = new RedBlackTree(integerRangeComparer, this);
-        this.diag = false;
-    }
-    remove(r) {
-        this.ranges.remove(r);
-    }
-    put(r) {
-        this.ranges.put(r, { minmax: integerRangeCopy(r) });
-    }
-    toString() {
-        return this.nodeToString(this.ranges.root);
-    }
-    nodeToString(node) {
-        let buf = "";
-        let indentAmt = 0;
-        const actions = {
-            pre: (n) => {
-                let red = "";
-                if (n.color === 0 /* RED */) {
-                    red = "R ";
-                }
-                buf += internedSpaces(indentAmt);
-                buf += `${red}key: ${integerRangeToString(n.key)} minmax: ${integerRangeToString(n.data.minmax)}\n`;
-                indentAmt += 2;
-                return true;
-            },
-            post: (n) => {
-                indentAmt -= 2;
-                return true;
-            },
-            showStructure: true,
-        };
-        this.ranges.nodeWalk(node, actions);
-        return buf;
-    }
-    matchPos(pos) {
-        return this.match({ start: pos, end: pos + 1 });
-    }
-    match(r) {
-        return this.ranges.gather(r, this);
-    }
-    matchNode(node, key) {
-        return !!node && integerRangeOverlaps(node.key, key);
-    }
-    continueSubtree(node, key) {
-        const cont = !!node && integerRangeOverlaps(node.data.minmax, key);
-        if (this.diag && (!cont)) {
-            if (node) {
-                console.log(`skipping subtree of size ${node.size} key ${integerRangeToString(key)}`);
-                console.log(this.nodeToString(node));
-            }
-        }
-        return cont;
-    }
-    update(node) {
-        if (node.left && node.right) {
-            node.data.minmax = integerRangeUnion(node.key, integerRangeUnion(node.left.data.minmax, node.right.data.minmax));
-        }
-        else {
-            if (node.left) {
-                node.data.minmax = integerRangeUnion(node.key, node.left.data.minmax);
-            }
-            else if (node.right) {
-                node.data.minmax = integerRangeUnion(node.key, node.right.data.minmax);
-            }
-            else {
-                node.data.minmax = integerRangeCopy(node.key);
-            }
-        }
-    }
-}
-export const intervalComparer = (a, b) => a.compare(b);
+const intervalComparer = (a, b) => a.compare(b);
 export class IntervalTree {
     constructor() {
         this.intervals = new RedBlackTree(intervalComparer, this);
-        this.diag = false;
-        this.timePut = false;
-        this.putTime = 0;
-        this.putCount = 0;
-    }
-    printTiming() {
-        console.log(`put total = ${this.putTime} avg=${(this.putTime / this.putCount).toFixed(2)}`);
     }
     remove(x) {
         this.intervals.remove(x);
@@ -1001,15 +720,7 @@ export class IntervalTree {
                 };
             };
         }
-        if (this.timePut) {
-            const trace = Trace.start();
-            this.intervals.put(x, { minmax: x.clone() }, rbConflict);
-            this.putTime += trace.trace().duration * 1000;
-            this.putCount++;
-        }
-        else {
-            this.intervals.put(x, { minmax: x.clone() }, rbConflict);
-        }
+        this.intervals.put(x, { minmax: x.clone() }, rbConflict);
     }
     map(fn) {
         const actions = {
@@ -1048,14 +759,7 @@ export class IntervalTree {
         return !!node && node.key.overlaps(key);
     }
     continueSubtree(node, key) {
-        const cont = !!node && node.data.minmax.overlaps(key);
-        if (this.diag && (!cont)) {
-            if (node) {
-                console.log(`skipping subtree of size ${node.size} key ${key.toString()}`);
-                // console.log(this.nodeToString(node));
-            }
-        }
-        return cont;
+        return !!node && node.data.minmax.overlaps(key);
     }
     update(node) {
         if (node.left && node.right) {
@@ -1203,26 +907,6 @@ export class TST {
         this.collectPairs(x.mid, { text: prefix.text + x.c }, q);
         this.collectPairs(x.right, prefix, q);
     }
-    patternCollect(x, prefix, d, pattern, q) {
-        if (x === undefined) {
-            return;
-        }
-        const c = pattern.charAt(d);
-        if ((c === ".") || (c < x.c)) {
-            this.patternCollect(x.left, prefix, d, pattern, q);
-        }
-        else if ((c === ".") || (c === x.c)) {
-            if ((d === (pattern.length - 1)) && (x.val !== undefined)) {
-                q.push(prefix.text + x.c);
-            }
-            else if (d < (pattern.length - 1)) {
-                this.patternCollect(x.mid, { text: prefix.text + x.c }, d + 1, pattern, q);
-            }
-        }
-        if ((c === ".") || (c > x.c)) {
-            this.patternCollect(x.right, prefix, d, pattern, q);
-        }
-    }
     nodeProximity(x, prefix, d, pattern, distance, q) {
         if ((x === undefined) || (distance < 0)) {
             return;
@@ -1252,10 +936,5 @@ export class TST {
             this.nodeProximity(x.right, prefix, d, pattern, distance, q);
         }
     }
-    match(pattern) {
-        const q = [];
-        this.patternCollect(this.root, { text: "" }, 0, pattern, q);
-        return q;
-    }
 }
 //# sourceMappingURL=collections.js.map