@fluid-experimental/tree 0.59.2001 → 0.59.3000

package/lib/id-compressor/AppendOnlySortedMap.d.ts

@@ -8,9 +8,9 @@
  */
 export declare class AppendOnlySortedMap<K, V> {
     protected readonly comparator: (a: K, b: K) => number;
-    protected readonly elements: [K, V][];
+    protected readonly elements: (K | V)[];
     /**
-     * @param comparator a comparator for keys
+     * @param comparator - a comparator for keys
      */
     constructor(comparator: (a: K, b: K) => number);
     /**
@@ -25,6 +25,26 @@ export declare class AppendOnlySortedMap<K, V> {
      * @returns the max key in the map.
      */
     maxKey(): K | undefined;
+    /**
+     * @returns the min value in the map.
+     */
+    minValue(): V | undefined;
+    /**
+     * @returns the min value in the map.
+     */
+    maxValue(): V | undefined;
+    /**
+     * @returns the min key in the map.
+     */
+    first(): [K, V] | undefined;
+    /**
+     * @returns the max key in the map.
+     */
+    last(): [K, V] | undefined;
+    /**
+     * Returns the element at the insertion index.
+     */
+    getAtIndex(index: number): [K, V] | undefined;
     /**
      * @returns an iterable of the entries in the map.
      */
@@ -42,25 +62,24 @@ export declare class AppendOnlySortedMap<K, V> {
      */
     entriesReversed(): IterableIterator<readonly [K, V]>;
     /**
-     * Adds a new key/value pair to the map. `key` must be > to all keys in the map.
-     * @param key the key to add.
-     * @param value the value to add.
+     * Adds a new key/value pair to the map. `key` must be \> to all keys in the map.
+     * @param key - the key to add.
+     * @param value - the value to add.
      */
     append(key: K, value: V): void;
-    private readonly compareKeys;
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the value associated with `key` if such an entry exists, and undefined otherwise.
      */
     get(key: K): V | undefined;
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the entry associated with `key` if such an entry exists, the entry associated with the next lower key if such an entry
      * exists, and undefined otherwise.
      */
     getPairOrNextLower(key: K): readonly [K, V] | undefined;
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the entry associated with `key` if such an entry exists, the entry associated with the next higher key if such an entry
      * exists, and undefined otherwise.
      */
@@ -69,30 +88,31 @@ export declare class AppendOnlySortedMap<K, V> {
      * Compares two `AppendOnlySortedMap`s.
      */
     equals(other: AppendOnlySortedMap<K, V>, compareValues: (a: V, b: V) => boolean): boolean;
+    /**
+     * Test-only expensive assertions to check the internal validity of the data structure.
+     */
+    assertValid(): void;
     /**
      * Queries a range of entries.
-     * @param from the key to start the range query at, inclusive.
-     * @param to the key to end the range query at, inclusive.
+     * @param from - the key to start the range query at, inclusive.
+     * @param to - the key to end the range query at, inclusive.
      * @returns the range of entries.
      */
     getRange(from: K, to: K): IterableIterator<readonly [K, V]>;
-    protected getPairOrNextLowerBy<T>(search: T, comparator: (search: T, element: readonly [K, V]) => number): readonly [K, V] | undefined;
-    private getIndexOfOrNextLower;
-    protected getPairOrNextHigherBy<T>(search: T, comparator: (search: T, element: readonly [K, V]) => number): readonly [K, V] | undefined;
-    private getIndexOfOrNextHigher;
+    protected getPairOrNextLowerBy<T>(search: T, comparator: (search: T, key: K, value: V) => number): readonly [K, V] | undefined;
+    private getKeyIndexOfOrNextLower;
+    protected getPairOrNextHigherBy<T>(search: T, comparator: (search: T, key: K, value: V) => number): readonly [K, V] | undefined;
+    private getKeyIndexOfOrNextHigher;
     /**
      * The value xor'd with the result index when a search fails.
      */
     static readonly failureXor = -1;
     /**
      * Performs a binary search on the sorted array.
-     * @param elements
-     * @param search
-     * @param comparator
-     * @returns the index of `search`, or (if not present) the index it would have been inserted into xor'd with `failureXor`. Note that
-     * negating is not an adequate solution as that could result in -0.
+     * @returns the index of the key for `search`, or (if not present) the index it would have been inserted into xor'd
+     * with `failureXor`. Note that negating is not an adequate solution as that could result in -0.
      */
-    static indexOf<T, K, V>(elements: readonly (readonly [K, V])[], search: T, comparator: (search: T, element: readonly [K, V]) => number): number;
+    static keyIndexOf<T, K, V>(elements: readonly (K | V)[], search: T, comparator: (search: T, key: K, value: V) => number): number;
 }
 /**
  * A map in which entries are always added in both key-sorted and value-sorted order.
@@ -101,27 +121,31 @@ export declare class AppendOnlySortedMap<K, V> {
 export declare class AppendOnlyDoublySortedMap<K, V, S> extends AppendOnlySortedMap<K, V> {
     private readonly extractSearchValue;
     private readonly valueComparator;
-    constructor(keyComparator: (a: K, b: K) => number, extractSearchValue: (value: V) => S, valueComparator: (search: S, value: V) => number);
+    constructor(keyComparator: (a: K, b: K) => number, extractSearchValue: (value: V) => S, valueComparator: (search: S, value: S) => number);
     append(key: K, value: V): void;
     private readonly compareValues;
     /**
-     * @param value the value to lookup.
+     * @param value - the value to lookup.
      * @returns the key associated with `value` if such an entry exists, and undefined otherwise.
      */
     getByValue(value: S): K | undefined;
     /**
-     * @param searchValue the search value to lookup.
-     * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
-     * exists, this method returns the next lower entry as determined by the value comparator provided to the constructor. If no such entry
-     * exists, this method returns undefined.
+     * @param searchValue - the search value to lookup.
+     * @returns the entry who's value, when run through the extractor provided to the constructor, matches
+     * `searchValue`. If no such entry exists, this method returns the next lower entry as determined by the value
+     * comparator provided to the constructor. If no such entry exists, this method returns undefined.
      */
     getPairOrNextLowerByValue(searchValue: S): readonly [K, V] | undefined;
     /**
-     * @param searchValue the search value to lookup.
+     * @param searchValue - the search value to lookup.
      * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
      * exists, this method returns the next higher entry as determined by the value comparator provided to the constructor. If no such entry
      * exists, this method returns undefined.
      */
     getPairOrNextHigherByValue(searchValue: S): readonly [K, V] | undefined;
+    /**
+     * Test-only expensive assertions to check the internal validity of the data structure.
+     */
+    assertValid(): void;
 }
 //# sourceMappingURL=AppendOnlySortedMap.d.ts.map

package/lib/id-compressor/AppendOnlySortedMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AppendOnlySortedMap.d.ts","sourceRoot":"","sources":["../../src/id-compressor/AppendOnlySortedMap.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AppendOnlySortedMap.d.ts","sourceRoot":"","sources":["../../src/id-compressor/AppendOnlySortedMap.ts"],"names":[],"mappings":"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"}

package/lib/id-compressor/AppendOnlySortedMap.js

@@ -3,109 +3,159 @@
  * Licensed under the MIT License.
  */
 /* eslint-disable no-bitwise */
-import { fail } from '../Common';
+import { assert, fail } from '../Common';
 /**
  * A map in which entries are always added in key-sorted order.
  * Supports appending and searching.
  */
 export class AppendOnlySortedMap {
     /**
-     * @param comparator a comparator for keys
+     * @param comparator - a comparator for keys
      */
     constructor(comparator) {
         this.comparator = comparator;
         this.elements = [];
-        this.compareKeys = (search, element) => {
-            return this.comparator(search, element[0]);
-        };
     }
     /**
      * @returns the number of entries in this map
      */
     get size() {
-        return this.elements.length;
+        return this.elements.length / 2;
     }
     /**
      * @returns the min key in the map.
      */
     minKey() {
-        var _a;
-        return (_a = this.elements[0]) === null || _a === void 0 ? void 0 : _a[0];
+        return this.elements[0];
     }
     /**
      * @returns the max key in the map.
      */
     maxKey() {
-        var _a;
-        return (_a = this.elements[this.size - 1]) === null || _a === void 0 ? void 0 : _a[0];
+        return this.elements[this.elements.length - 2];
+    }
+    /**
+     * @returns the min value in the map.
+     */
+    minValue() {
+        return this.elements[1];
+    }
+    /**
+     * @returns the min value in the map.
+     */
+    maxValue() {
+        return this.elements[this.elements.length - 1];
+    }
+    /**
+     * @returns the min key in the map.
+     */
+    first() {
+        const { elements } = this;
+        const { length } = elements;
+        if (length === 0) {
+            return undefined;
+        }
+        return [elements[0], elements[1]];
+    }
+    /**
+     * @returns the max key in the map.
+     */
+    last() {
+        const { elements } = this;
+        const { length } = elements;
+        if (length === 0) {
+            return undefined;
+        }
+        const lastKeyIndex = length - 2;
+        return [elements[lastKeyIndex], elements[lastKeyIndex + 1]];
+    }
+    /**
+     * Returns the element at the insertion index.
+     */
+    getAtIndex(index) {
+        const realIndex = index * 2;
+        const { elements } = this;
+        if (realIndex < 0 || realIndex > elements.length - 1) {
+            return undefined;
+        }
+        return [elements[realIndex], elements[realIndex + 1]];
     }
     /**
      * @returns an iterable of the entries in the map.
      */
     *entries() {
-        for (const entry of this.elements) {
-            yield entry;
+        const { elements } = this;
+        for (let i = 0; i < elements.length; i += 2) {
+            yield [elements[i], elements[i + 1]];
         }
     }
     /**
      * @returns an iterable of the keys in the map.
      */
     *keys() {
-        for (const entry of this.elements) {
-            yield entry[0];
+        const { elements } = this;
+        for (let i = 0; i < elements.length; i += 2) {
+            yield elements[i];
         }
     }
     /**
      * @returns an iterable of the values in the map.
      */
     *values() {
-        for (const entry of this.elements) {
-            yield entry[1];
+        const { elements } = this;
+        for (let i = 0; i < elements.length; i += 2) {
+            yield elements[i + 1];
         }
     }
     /**
      * @returns an iterable of the entries in the map, reversed.
      */
     *entriesReversed() {
-        for (let i = this.size - 1; i >= 0; i--) {
-            yield this.elements[i];
+        const { elements } = this;
+        for (let i = elements.length - 2; i >= 0; i -= 2) {
+            yield [elements[i], elements[i + 1]];
         }
     }
     /**
-     * Adds a new key/value pair to the map. `key` must be > to all keys in the map.
-     * @param key the key to add.
-     * @param value the value to add.
+     * Adds a new key/value pair to the map. `key` must be \> to all keys in the map.
+     * @param key - the key to add.
+     * @param value - the value to add.
      */
     append(key, value) {
-        if (this.size !== 0 && this.comparator(key, this.elements[this.size - 1][0]) <= 0) {
+        const { elements } = this;
+        const { length } = elements;
+        if (length !== 0 && this.comparator(key, this.maxKey()) <= 0) {
             fail('Inserted key must be > all others in the map.');
         }
-        this.elements.push([key, value]);
+        elements.push(key);
+        elements.push(value);
     }
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the value associated with `key` if such an entry exists, and undefined otherwise.
      */
     get(key) {
-        var _a;
-        const index = AppendOnlySortedMap.indexOf(this.elements, key, this.compareKeys);
-        return (_a = this.elements[index]) === null || _a === void 0 ? void 0 : _a[1];
+        const index = AppendOnlySortedMap.keyIndexOf(this.elements, key, this.comparator);
+        if (index < 0) {
+            return undefined;
+        }
+        return this.elements[index + 1];
     }
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the entry associated with `key` if such an entry exists, the entry associated with the next lower key if such an entry
      * exists, and undefined otherwise.
      */
     getPairOrNextLower(key) {
-        return this.getPairOrNextLowerBy(key, this.compareKeys);
+        return this.getPairOrNextLowerBy(key, this.comparator);
     }
     /**
-     * @param key the key to lookup.
+     * @param key - the key to lookup.
      * @returns the entry associated with `key` if such an entry exists, the entry associated with the next higher key if such an entry
      * exists, and undefined otherwise.
      */
     getPairOrNextHigher(key) {
-        return this.getPairOrNextHigherBy(key, this.compareKeys);
+        return this.getPairOrNextHigherBy(key, this.comparator);
     }
     /**
      * Compares two `AppendOnlySortedMap`s.
@@ -114,12 +164,14 @@ export class AppendOnlySortedMap {
         if (other === this) {
             return true;
         }
-        if (this.size !== other.size) {
+        if (this.elements.length !== other.elements.length) {
             return false;
         }
-        for (let i = this.size - 1; i >= 0; i--) {
-            const [keyThis, valueThis] = this.elements[i];
-            const [keyOther, valueOther] = other.elements[i];
+        for (let i = this.elements.length - 2; i >= 0; i -= 2) {
+            const keyThis = this.elements[i];
+            const valueThis = this.elements[i + 1];
+            const keyOther = other.elements[i];
+            const valueOther = other.elements[i + 1];
             if (this.comparator(keyThis, keyOther) !== 0) {
                 return false;
             }
@@ -129,83 +181,95 @@ export class AppendOnlySortedMap {
         }
         return true;
     }
+    /**
+     * Test-only expensive assertions to check the internal validity of the data structure.
+     */
+    assertValid() {
+        let prev;
+        for (const kv of this.entries()) {
+            if (prev !== undefined) {
+                assert(this.comparator(kv[0], prev[0]) > 0, 'Keys in map must be sorted.');
+            }
+            prev = kv;
+        }
+    }
     /**
      * Queries a range of entries.
-     * @param from the key to start the range query at, inclusive.
-     * @param to the key to end the range query at, inclusive.
+     * @param from - the key to start the range query at, inclusive.
+     * @param to - the key to end the range query at, inclusive.
      * @returns the range of entries.
      */
     *getRange(from, to) {
-        const indexFrom = this.getIndexOfOrNextHigher(from, this.compareKeys);
-        if (indexFrom === undefined) {
+        const keyIndexFrom = this.getKeyIndexOfOrNextHigher(from, this.comparator);
+        if (keyIndexFrom === undefined) {
             return;
         }
-        const indexTo = this.getIndexOfOrNextLower(to, this.compareKeys);
-        if (indexTo === undefined) {
+        const keyIndexTo = this.getKeyIndexOfOrNextLower(to, this.comparator);
+        if (keyIndexTo === undefined) {
             return;
         }
-        for (let i = indexFrom; i <= indexTo; i++) {
-            yield this.elements[i];
+        for (let i = keyIndexFrom; i <= keyIndexTo; i += 2) {
+            yield [this.elements[i], this.elements[i + 1]];
         }
     }
     getPairOrNextLowerBy(search, comparator) {
-        const index = this.getIndexOfOrNextLower(search, comparator);
-        if (index === undefined) {
+        const keyIndex = this.getKeyIndexOfOrNextLower(search, comparator);
+        if (keyIndex === undefined) {
             return undefined;
         }
-        return this.elements[index];
+        return [this.elements[keyIndex], this.elements[keyIndex + 1]];
     }
-    getIndexOfOrNextLower(search, comparator) {
-        const { size } = this;
-        if (size === 0) {
+    getKeyIndexOfOrNextLower(search, comparator) {
+        const { elements } = this;
+        if (elements.length === 0) {
             return undefined;
         }
-        let index = AppendOnlySortedMap.indexOf(this.elements, search, comparator);
-        if (index < 0) {
-            index ^= AppendOnlySortedMap.failureXor;
-            if (index > 0) {
-                return index - 1;
+        let keyIndex = AppendOnlySortedMap.keyIndexOf(elements, search, comparator);
+        if (keyIndex < 0) {
+            keyIndex ^= AppendOnlySortedMap.failureXor;
+            if (keyIndex > 0) {
+                return keyIndex - 2;
             }
             return undefined;
         }
-        return index;
+        return keyIndex;
     }
     getPairOrNextHigherBy(search, comparator) {
-        const index = this.getIndexOfOrNextHigher(search, comparator);
-        if (index === undefined) {
+        const keyIndex = this.getKeyIndexOfOrNextHigher(search, comparator);
+        if (keyIndex === undefined) {
             return undefined;
         }
-        return this.elements[index];
+        return [this.elements[keyIndex], this.elements[keyIndex + 1]];
     }
-    getIndexOfOrNextHigher(search, comparator) {
-        const { size } = this;
-        if (size === 0) {
+    getKeyIndexOfOrNextHigher(search, comparator) {
+        const { elements } = this;
+        const { length } = elements;
+        if (length === 0) {
             return undefined;
         }
-        let index = AppendOnlySortedMap.indexOf(this.elements, search, comparator);
-        if (index < 0) {
-            index ^= AppendOnlySortedMap.failureXor;
-            if (index < size) {
-                return index;
+        let keyIndex = AppendOnlySortedMap.keyIndexOf(elements, search, comparator);
+        if (keyIndex < 0) {
+            keyIndex ^= AppendOnlySortedMap.failureXor;
+            if (keyIndex < length) {
+                return keyIndex;
             }
             return undefined;
         }
-        return index;
+        return keyIndex;
     }
     /**
      * Performs a binary search on the sorted array.
-     * @param elements
-     * @param search
-     * @param comparator
-     * @returns the index of `search`, or (if not present) the index it would have been inserted into xor'd with `failureXor`. Note that
-     * negating is not an adequate solution as that could result in -0.
+     * @returns the index of the key for `search`, or (if not present) the index it would have been inserted into xor'd
+     * with `failureXor`. Note that negating is not an adequate solution as that could result in -0.
      */
-    static indexOf(elements, search, comparator) {
+    static keyIndexOf(elements, search, comparator) {
+        // Low, high, and mid are addresses of [K,V] pairs and *not* key indices
         let low = 0;
-        let high = elements.length;
+        let high = elements.length / 2;
         let mid = high >> 1;
         while (low < high) {
-            const c = comparator(search, elements[mid]);
+            const keyIndex = mid * 2;
+            const c = comparator(search, elements[keyIndex], elements[keyIndex + 1]);
             if (c > 0) {
                 low = mid + 1;
             }
@@ -213,14 +277,14 @@ export class AppendOnlySortedMap {
                 high = mid;
             }
             else if (c === 0) {
-                return mid;
+                return keyIndex;
             }
             else {
                 fail('Invalid comparator.');
             }
             mid = (low + high) >> 1;
         }
-        return mid ^ AppendOnlySortedMap.failureXor;
+        return (mid * 2) ^ AppendOnlySortedMap.failureXor;
     }
 }
 /**
@@ -236,37 +300,37 @@ export class AppendOnlyDoublySortedMap extends AppendOnlySortedMap {
         super(keyComparator);
         this.extractSearchValue = extractSearchValue;
         this.valueComparator = valueComparator;
-        this.compareValues = (search, element) => {
-            return this.valueComparator(search, element[1]);
+        this.compareValues = (search, _, value) => {
+            return this.valueComparator(search, this.extractSearchValue(value));
         };
     }
     append(key, value) {
-        if (this.size !== 0 &&
-            this.valueComparator(this.extractSearchValue(value), this.elements[this.size - 1][1]) <= 0) {
+        if (this.elements.length !== 0 &&
+            this.valueComparator(this.extractSearchValue(value), this.extractSearchValue(this.maxValue())) <= 0) {
             fail('Inserted value must be > all others in the map.');
         }
         super.append(key, value);
     }
     /**
-     * @param value the value to lookup.
+     * @param value - the value to lookup.
      * @returns the key associated with `value` if such an entry exists, and undefined otherwise.
      */
     getByValue(value) {
         var _a;
-        const index = AppendOnlySortedMap.indexOf(this.elements, value, this.compareValues);
+        const index = AppendOnlySortedMap.keyIndexOf(this.elements, value, this.compareValues);
         return (_a = this.elements[index]) === null || _a === void 0 ? void 0 : _a[0];
     }
     /**
-     * @param searchValue the search value to lookup.
-     * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
-     * exists, this method returns the next lower entry as determined by the value comparator provided to the constructor. If no such entry
-     * exists, this method returns undefined.
+     * @param searchValue - the search value to lookup.
+     * @returns the entry who's value, when run through the extractor provided to the constructor, matches
+     * `searchValue`. If no such entry exists, this method returns the next lower entry as determined by the value
+     * comparator provided to the constructor. If no such entry exists, this method returns undefined.
      */
     getPairOrNextLowerByValue(searchValue) {
         return this.getPairOrNextLowerBy(searchValue, this.compareValues);
     }
     /**
-     * @param searchValue the search value to lookup.
+     * @param searchValue - the search value to lookup.
      * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
      * exists, this method returns the next higher entry as determined by the value comparator provided to the constructor. If no such entry
      * exists, this method returns undefined.
@@ -274,5 +338,18 @@ export class AppendOnlyDoublySortedMap extends AppendOnlySortedMap {
     getPairOrNextHigherByValue(searchValue) {
         return this.getPairOrNextHigherBy(searchValue, this.compareValues);
     }
+    /**
+     * Test-only expensive assertions to check the internal validity of the data structure.
+     */
+    assertValid() {
+        super.assertValid();
+        let prev;
+        for (const kv of this.entries()) {
+            if (prev !== undefined) {
+                assert(this.valueComparator(this.extractSearchValue(kv[1]), this.extractSearchValue(prev[1])) > 0, 'Values in map must be sorted.');
+            }
+            prev = kv;
+        }
+    }
 }
 //# sourceMappingURL=AppendOnlySortedMap.js.map