webglimpse
Version:
Webglimpse is a data visualization library for the web.
191 lines • 26.3 kB
JavaScript
/*
* Copyright (c) 2014, Metron, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import { BinaryTree } from './binary_tree';
import { getObjectId } from './util';
// A sorted map which allows multiple string values per key (K)
export class SortedMultimap {
constructor(comparator, idFn = getObjectId) {
this._tree = new BinaryTree(this.createContainerComparator(comparator));
this._idFn = idFn;
}
createContainerComparator(comparator) {
return {
compare: function (container1, container2) {
return comparator.compare(container1.key, container2.key);
}
};
}
// Inserts the value into the tree. Nothing is inserted if the value already exists
insert(key, value) {
const wrappedKey = new Container(key);
let values = this._tree.getValue(wrappedKey);
if (values === null) {
values = wrappedKey;
this._tree.insert(values);
}
values.add(value, this._idFn);
}
remove(key, value) {
const wrappedKey = new Container(key);
const values = this._tree.getValue(wrappedKey);
if (values === null) {
return;
}
values.remove(value, this._idFn);
if (values.size === 0) {
this._tree.remove(values);
}
}
contains(key, value) {
const wrappedKey = new Container(key);
const values = this._tree.getValue(wrappedKey);
if (values === null) {
return false;
}
else {
return values.contains(value, this._idFn);
}
}
// Returns the lowest element greater than or equal to the given value, or null if no such element exists
ceiling(key) {
return this.unwrap(this._tree.ceiling(this.wrap(key)));
}
// Returns the greatest element less than or equal to the given value, or null if no such element exists
floor(key) {
return this.unwrap(this._tree.floor(this.wrap(key)));
}
// Returns the greatest element strictly less than the given value, or null if no such element exists
lower(key) {
return this.unwrap(this._tree.lower(this.wrap(key)));
}
// Returns the lowest element strictly greater than the given value, or null if no such element exists
higher(key) {
return this.unwrap(this._tree.higher(this.wrap(key)));
}
// Returns all elements greater than (or equal to, if inclusive is true) the provided value (sorted from low to high)
headSet(key, inclusive = true) {
return this.unwrapArray(this._tree.headSet(this.wrap(key), inclusive));
}
// Returns all elements less than ( or equal to, if inclusive is true) the provided value (sorted from low to high)
tailSet(key, inclusive = false) {
return this.unwrapArray(this._tree.tailSet(this.wrap(key), inclusive));
}
// Returns all elements between the provided values (sorted from low to high)
subSet(low, high, lowInclusive = true, highInclusive = false) {
const wrappedLow = new Container(low);
const wrappedHigh = new Container(high);
const values = this._tree.subSet(wrappedLow, wrappedHigh, lowInclusive, highInclusive);
return this.unwrapArray(values);
}
// Returns all keys in the tree (sorted from low to high)
toArray() {
return this.unwrapArray(this._tree.toArray());
}
iterator() {
const iter = this._tree.iterator();
let currentArray = null;
let currentIndex = 0;
return {
next: function () {
let value;
if (currentArray == null || currentIndex >= currentArray.length) {
currentArray = iter.next().toArray();
currentIndex = 0;
value = currentArray[currentIndex];
}
else {
value = currentArray[currentIndex];
}
currentIndex += 1;
return value;
},
hasNext: function () {
return iter.hasNext() || (currentArray != null && currentIndex < currentArray.length);
}
};
}
wrap(key) {
return new Container(key);
}
unwrap(values) {
if (values === null) {
return [];
}
else {
return values.toArray();
}
}
unwrapArray(values) {
const unwrappedValues = new Array();
values.forEach(function (value) {
value.toArray().forEach(function (val) {
unwrappedValues.push(val);
});
});
return unwrappedValues;
}
}
export class SortedStringMultimap extends SortedMultimap {
constructor(comparator) {
super(comparator, (value) => value);
}
}
// a container which stores a set of values (V) associated with a sorted key (K)
// OrderedSet or even BinaryTree could be used here instead
// more sophisticated set implementation: http://stackoverflow.com/questions/7958292/mimicking-sets-in-javascript
class Container {
constructor(key) {
this._key = key;
this._values = {};
}
get size() {
return this.toArray().length;
}
get key() {
return this._key;
}
get values() {
return this._values;
}
toArray() {
return Object.keys(this._values).map(key => this._values[key]);
}
contains(value, idFn) {
// safer than 'value in this._values' because of potential conflict with built in properties/methods
return Object.prototype.hasOwnProperty.call(this._values, idFn(value));
}
add(value, idFn) {
this._values[idFn(value)] = value;
}
remove(value, idFn) {
delete this._values[idFn(value)];
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sorted_multimap.js","sourceRoot":"","sources":["../../../../src/webglimpse/util/sorted_multimap.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2014, Metron, Inc.\r\n * All rights reserved.\r\n *\r\n * Redistribution and use in source and binary forms, with or without modification,\r\n * are permitted provided that the following conditions are met:\r\n *\r\n * 1. Redistributions of source code must retain the above copyright notice, this\r\n *    list of conditions and the following disclaimer.\r\n *\r\n * 2. Redistributions in binary form must reproduce the above copyright notice,\r\n *    this list of conditions and the following disclaimer in the documentation\r\n *    and/or other materials provided with the distribution.\r\n *\r\n * 3. Neither the name of the copyright holder nor the names of its contributors\r\n *    may be used to endorse or promote products derived from this software without\r\n *    specific prior written permission.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\r\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\r\n * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\r\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\n * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n */\r\nimport { BinaryTree, Comparator, Iterator } from './binary_tree';\r\nimport { IdFunction, StringMap, getObjectId } from './util';\r\n\r\n// A sorted map which allows multiple string values per key (K)\r\nexport class SortedMultimap<K, V> {\r\n\r\n    private _tree: BinaryTree<Container<K, V>>;\r\n    private _idFn: IdFunction<V>;\r\n\r\n    constructor(comparator: Comparator<K>, idFn: IdFunction<V> = getObjectId) {\r\n        this._tree = new BinaryTree<Container<K, V>>(this.createContainerComparator<V>(comparator));\r\n        this._idFn = idFn;\r\n    }\r\n\r\n    private createContainerComparator<U>(comparator: Comparator<K>): Comparator<Container<K, U>> {\r\n        return {\r\n            compare: function (container1: Container<K, U>, container2: Container<K, U>): number {\r\n                return comparator.compare(container1.key, container2.key);\r\n            }\r\n        };\r\n    }\r\n\r\n    // Inserts the value into the tree. Nothing is inserted if the value already exists\r\n    insert(key: K, value: V) {\r\n        const wrappedKey = new Container<K, V>(key);\r\n        let values: Container<K, V> = this._tree.getValue(wrappedKey);\r\n\r\n        if (values === null) {\r\n            values = wrappedKey;\r\n            this._tree.insert(values);\r\n        }\r\n\r\n        values.add(value, this._idFn);\r\n    }\r\n\r\n    remove(key: K, value: V) {\r\n        const wrappedKey = new Container<K, V>(key);\r\n        const values: Container<K, V> = this._tree.getValue(wrappedKey);\r\n\r\n        if (values === null) {\r\n            return;\r\n        }\r\n\r\n        values.remove(value, this._idFn);\r\n\r\n        if (values.size === 0) {\r\n            this._tree.remove(values);\r\n        }\r\n    }\r\n\r\n    contains(key: K, value: V) {\r\n        const wrappedKey = new Container<K, V>(key);\r\n        const values: Container<K, V> = this._tree.getValue(wrappedKey);\r\n\r\n        if (values === null) {\r\n            return false;\r\n        }\r\n        else {\r\n            return values.contains(value, this._idFn);\r\n        }\r\n    }\r\n\r\n    // Returns the lowest element greater than or equal to the given value, or null if no such element exists\r\n    ceiling(key: K): V[] {\r\n        return this.unwrap(this._tree.ceiling(this.wrap(key)));\r\n    }\r\n\r\n    // Returns the greatest element less than or equal to the given value, or null if no such element exists\r\n    floor(key: K): V[] {\r\n        return this.unwrap(this._tree.floor(this.wrap(key)));\r\n    }\r\n\r\n    // Returns the greatest element strictly less than the given value, or null if no such element exists\r\n    lower(key: K): V[] {\r\n        return this.unwrap(this._tree.lower(this.wrap(key)));\r\n    }\r\n\r\n    // Returns the lowest element strictly greater than the given value, or null if no such element exists\r\n    higher(key: K): V[] {\r\n        return this.unwrap(this._tree.higher(this.wrap(key)));\r\n    }\r\n\r\n    // Returns all elements greater than (or equal to, if inclusive is true) the provided value (sorted from low to high)\r\n    headSet(key: K, inclusive: boolean = true): V[] {\r\n        return this.unwrapArray(this._tree.headSet(this.wrap(key), inclusive));\r\n    }\r\n\r\n    // Returns all elements less than ( or equal to, if inclusive is true) the provided value (sorted from low to high)\r\n    tailSet(key: K, inclusive: boolean = false): V[] {\r\n        return this.unwrapArray(this._tree.tailSet(this.wrap(key), inclusive));\r\n    }\r\n\r\n    // Returns all elements between the provided values (sorted from low to high)\r\n    subSet(low: K, high: K, lowInclusive: boolean = true, highInclusive: boolean = false): V[] {\r\n        const wrappedLow = new Container<K, V>(low);\r\n        const wrappedHigh = new Container<K, V>(high);\r\n        const values: Container<K, V>[] = this._tree.subSet(wrappedLow, wrappedHigh, lowInclusive, highInclusive);\r\n        return this.unwrapArray(values);\r\n    }\r\n\r\n    // Returns all keys in the tree (sorted from low to high)\r\n    toArray(): V[] {\r\n        return this.unwrapArray(this._tree.toArray());\r\n    }\r\n\r\n    iterator(): Iterator<V> {\r\n\r\n        const iter: Iterator<Container<K, V>> = this._tree.iterator();\r\n        let currentArray: V[] = null;\r\n        let currentIndex = 0;\r\n\r\n        return {\r\n            next: function (): V {\r\n\r\n                let value: V;\r\n\r\n                if (currentArray == null || currentIndex >= currentArray.length) {\r\n                    currentArray = iter.next().toArray();\r\n                    currentIndex = 0;\r\n                    value = currentArray[currentIndex];\r\n                }\r\n                else {\r\n                    value = currentArray[currentIndex];\r\n                }\r\n\r\n                currentIndex += 1;\r\n\r\n                return value;\r\n            },\r\n            hasNext: function (): boolean {\r\n                return iter.hasNext() || (currentArray != null && currentIndex < currentArray.length);\r\n            }\r\n        };\r\n    }\r\n\r\n    private wrap(key: K): Container<K, V> {\r\n        return new Container<K, V>(key);\r\n    }\r\n\r\n    private unwrap(values: Container<K, V>): V[] {\r\n        if (values === null) {\r\n            return [];\r\n        }\r\n        else {\r\n            return values.toArray();\r\n        }\r\n    }\r\n\r\n    private unwrapArray(values: Container<K, V>[]): V[] {\r\n        const unwrappedValues: V[] = new Array<V>();\r\n        values.forEach(function (value: Container<K, V>) {\r\n            value.toArray().forEach(function (val: V) {\r\n                unwrappedValues.push(val);\r\n            });\r\n        });\r\n\r\n        return unwrappedValues;\r\n    }\r\n}\r\n\r\nexport class SortedStringMultimap<K> extends SortedMultimap<K, string> {\r\n    constructor(comparator: Comparator<K>) {\r\n        super(comparator, (value) => value);\r\n    }\r\n}\r\n\r\n// a container which stores a set of values (V) associated with a sorted key (K)\r\n// OrderedSet or even BinaryTree could be used here instead\r\n// more sophisticated set implementation: http://stackoverflow.com/questions/7958292/mimicking-sets-in-javascript\r\nclass Container<K, V> {\r\n\r\n    private _key: K;\r\n    private _values: StringMap<V>;\r\n\r\n    constructor(key: K) {\r\n        this._key = key;\r\n        this._values = {};\r\n    }\r\n\r\n    get size(): number {\r\n        return this.toArray().length;\r\n    }\r\n\r\n    get key(): K {\r\n        return this._key;\r\n    }\r\n\r\n    get values(): StringMap<V> {\r\n        return this._values;\r\n    }\r\n\r\n    toArray(): V[] {\r\n        return Object.keys(this._values).map(key => this._values[key]);\r\n    }\r\n\r\n    contains(value: V, idFn: IdFunction<V>): boolean {\r\n        // safer than 'value in this._values' because of potential conflict with built in properties/methods\r\n        return Object.prototype.hasOwnProperty.call(this._values, idFn(value));\r\n    }\r\n\r\n    add(value: V, idFn: IdFunction<V>) {\r\n        this._values[idFn(value)] = value;\r\n    }\r\n\r\n    remove(value: V, idFn: IdFunction<V>) {\r\n        delete this._values[idFn(value)];\r\n    }\r\n}\r\n\r\n"]}