@fluidframework/merge-tree 1.2.1 → 2.0.0-internal.1.0.0

package/src/collections/index.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export * from "./heap";
+export * from "./intervalTree";
+export * from "./list";
+export * from "./rbTree";
+export * from "./stack";
+export * from "./tst";

package/src/collections/intervalTree.ts

@@ -0,0 +1,140 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import {
+    IIntegerRange,
+} from "../base";
+import { ConflictAction, IRBAugmentation, IRBMatcher, RBNode, RBNodeActions, RedBlackTree } from "./rbTree";
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export interface AugmentedIntervalNode {
+    minmax: IInterval;
+}
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export const integerRangeToString = (range: IIntegerRange) => `[${range.start},${range.end})`;
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export interface IInterval {
+    clone(): IInterval;
+    compare(b: IInterval): number;
+    compareStart(b: IInterval): number;
+    compareEnd(b: IInterval): number;
+    modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage): IInterval | undefined;
+    overlaps(b: IInterval): boolean;
+    union(b: IInterval): IInterval;
+}
+
+const intervalComparer = (a: IInterval, b: IInterval) => a.compare(b);
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export type IntervalNode<T extends IInterval> = RBNode<T, AugmentedIntervalNode>;
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export type IntervalConflictResolver<TInterval> = (a: TInterval, b: TInterval) => TInterval;
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export class IntervalTree<T extends IInterval> implements IRBAugmentation<T, AugmentedIntervalNode>,
+    IRBMatcher<T, AugmentedIntervalNode> {
+    public intervals = new RedBlackTree<T, AugmentedIntervalNode>(intervalComparer, this);
+
+    public remove(x: T) {
+        this.intervals.remove(x);
+    }
+
+    public removeExisting(x: T) {
+        this.intervals.removeExisting(x);
+    }
+
+    public put(x: T, conflict?: IntervalConflictResolver<T>) {
+        let rbConflict: ConflictAction<T, AugmentedIntervalNode> | undefined;
+        if (conflict) {
+            rbConflict = (key: T, currentKey: T) => {
+                const ival = conflict(key, currentKey);
+                return {
+                    key: ival,
+                };
+            };
+        }
+        this.intervals.put(x, { minmax: x.clone() }, rbConflict);
+    }
+
+    public map(fn: (x: T) => void) {
+        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+            infix: (node) => {
+                fn(node.key);
+                return true;
+            },
+            showStructure: true,
+        };
+        this.intervals.walk(actions);
+    }
+
+    public mapUntil(fn: (X: T) => boolean) {
+        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+            infix: (node) => {
+                return fn(node.key);
+            },
+            showStructure: true,
+        };
+        this.intervals.walk(actions);
+    }
+
+    public mapBackward(fn: (x: T) => void) {
+        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+            infix: (node) => {
+                fn(node.key);
+                return true;
+            },
+            showStructure: true,
+        };
+        this.intervals.walkBackward(actions);
+    }
+
+    // TODO: toString()
+    public match(x: T) {
+        return this.intervals.gather(x, this);
+    }
+
+    public matchNode(node: IntervalNode<T> | undefined, key: T) {
+        return !!node && node.key.overlaps(key);
+    }
+
+    public continueSubtree(node: IntervalNode<T> | undefined, key: T) {
+        return !!node && node.data.minmax.overlaps(key);
+    }
+
+    public update(node: IntervalNode<T>) {
+        if (node.left && node.right) {
+            node.data.minmax = node.key.union(
+                node.left.data.minmax.union(node.right.data.minmax));
+        } else {
+            if (node.left) {
+                node.data.minmax = node.key.union(node.left.data.minmax);
+            } else if (node.right) {
+                node.data.minmax = node.key.union(node.right.data.minmax);
+            } else {
+                node.data.minmax = node.key.clone();
+            }
+        }
+    }
+}

package/src/collections/list.ts

@@ -0,0 +1,165 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export function ListRemoveEntry<U>(entry: List<U>): List<U> | undefined {
+    if (entry === undefined) {
+        return undefined;
+    } else if (entry.isHead) {
+        return undefined;
+    } else {
+        entry.next.prev = entry.prev;
+        entry.prev.next = entry.next;
+        entry.next = deadhead;
+        entry.prev = deadhead;
+    }
+    return (entry);
+}
+
+function ListMakeEntry<U>(data: U): List<U> {
+    return new List<U>(false, data);
+}
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export function ListMakeHead<U>(): List<U> {
+    return new List<U>(true, undefined);
+}
+
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
+export class List<T> {
+    public next: List<T>;
+    public prev: List<T>;
+
+    constructor(public isHead: boolean, public data: T | undefined) {
+        this.prev = this;
+        this.next = this;
+    }
+
+    public clear(): void {
+        if (this.isHead) {
+            this.prev = this;
+            this.next = this;
+        }
+    }
+
+    private add(data: T): List<T> {
+        const entry = ListMakeEntry(data);
+        this.prev.next = entry;
+        entry.next = this;
+        entry.prev = this.prev;
+        this.prev = entry;
+        return (entry);
+    }
+
+    public dequeue(): T | undefined {
+        if (!this.empty()) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const removedEntry = ListRemoveEntry(this.next)!;
+            return removedEntry.data;
+        }
+    }
+
+    public enqueue(data: T): List<T> {
+        return this.add(data);
+    }
+
+    public pop?(): T | undefined {
+        const removedEntry = ListRemoveEntry(this.prev);
+        return removedEntry ? removedEntry.data : undefined;
+    }
+
+    public walk(fn: (data: T, l: List<T>) => void): void {
+        for (let entry = this.next; !(entry.isHead); entry = entry.next) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            fn(entry.data!, entry);
+        }
+    }
+
+    public some(fn: (data: T, l: List<T>) => boolean, rev?: boolean): T[] {
+        const rtn: T[] = [];
+        const start = rev ? this.prev : this.next;
+        for (let entry = start; !(entry.isHead); entry = rev ? entry.prev : entry.next) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const data = entry.data!;
+            if (fn(data, entry)) {
+                if (rev) {
+                    // preserve list order when in reverse
+                    rtn.unshift(data);
+                } else {
+                    rtn.push(data);
+                }
+            }
+        }
+        return rtn;
+    }
+
+    public count(): number {
+        let entry: List<T>;
+        let i: number;
+
+        entry = this.next;
+        for (i = 0; !(entry.isHead); i++) {
+            entry = entry.next;
+        }
+        return (i);
+    }
+
+    public first(): T | undefined {
+        if (!this.empty()) {
+            return (this.next.data);
+        }
+    }
+
+    public last(): T | undefined {
+        if (!this.empty()) {
+            return (this.prev.data);
+        }
+    }
+
+    public empty(): boolean {
+        return (this.next === this);
+    }
+
+    public unshift(data: T): void {
+        const entry = ListMakeEntry(data);
+        entry.data = data;
+        entry.isHead = false;
+        entry.next = this.next;
+        entry.prev = this;
+        this.next = entry;
+        entry.next.prev = entry;
+    }
+
+    public [Symbol.iterator]() {
+        let node: List<T> | undefined = this.next;
+        const iterator: IterableIterator<T> = {
+            next(): IteratorResult<T> {
+                while (node && node.isHead === false) {
+                    const value = node.data;
+                    node = node.next;
+                    if (value !== undefined) {
+                        return { value, done: false };
+                    }
+                }
+                return { value: undefined, done: true };
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    }
+}
+
+const deadhead = ListMakeHead<any>();