Merge pull request #46 from theSherwood/master

simple iterator implementation

Author: alexbol99

README.md

@@ -75,7 +75,7 @@ Method returns reference to the inserted node
 let node = tree.insert(key, value)
 ```
 
-### Exist(key,value)
+### Exist(key, value)
 Method returns true if item {key, value} exists in the tree. <br/>
 Method may be useful if need to support unique items.
 ```javascript
@@ -171,6 +171,29 @@ Clear tree
 tree.clear()
 ```
 
+### Iterate([interval, outputMapperFn])
+Returns an iterator (and iterable). <br/>
+Call `next` on the iterator to navigate to successor tree nodes and return the corresponding values. <br/>
+In the absence of a starting interval, the iterator will start with the lowest interval. <br/>
+```javascript
+let iterator = tree.iterate();
+let next = iterator.next().value;
+```
+Optional *outputMapperFn(value, key)* enables to map search results into custom defined output. <br/>
+Example:
+```javascript
+let iterator = tree.iterate([5,5], (value, key) => key);
+let next_key = iterator.next().value;
+```
+Supports `for .. of` syntax. <br/>
+Example:
+```javascript
+for (let key of tree.iterate([5,5], (value, key) => key)) {
+    if (key[0] > 8) break;
+    console.log(key);
+}
+```
+
 ## Documentation
 Documentation may be found here: [https://alexbol99.github.io/flatten-interval-tree](https://alexbol99.github.io/flatten-interval-tree/)
 

package-lock.json

@@ -11,7 +11,8 @@
   "types": "index.d.ts",
   "nyc": {
     "require": [
-      "@babel/register"
+      "@babel/register",
+      "@babel/polyfill"
     ],
     "sourceMap": false,
     "instrument": false

package.json

@@ -157,15 +157,34 @@ class IntervalTree {
         this.tree_walk(this.root, (node) => visitor(node.item.key, node.item.value));
     }
 
-    /** Value Mapper. Walk through every node and map node value to another value
-    * @param callback(value,key) - function to be called for each tree item
-    */
+    /**
+     * Value Mapper. Walk through every node and map node value to another value
+     * @param callback(value,key) - function to be called for each tree item
+     */
     map(callback) {
         const tree = new IntervalTree();
         this.tree_walk(this.root, (node) => tree.insert(node.item.key, callback(node.item.value, node.item.key)));
         return tree;
     }
 
+    /**
+     * @param {Interval} interval - optional if the iterator is intended to start from the beginning or end
+     * @param outputMapperFn(value,key) - optional function that maps (value, key) to custom output
+     * @returns {Iterator}
+     */
+    *iterate(interval, outputMapperFn = (value, key) => value === key ? key.output() : value) {
+        let node;
+        if (interval) {
+            node = this.tree_search_nearest_forward(this.root, new Node(interval));
+        } else if (this.root) {
+            node = this.local_minimum(this.root);
+        }
+        while (node) {
+            yield outputMapperFn(node.item.value, node.item.key);
+            node = this.tree_successor(node);
+        }
+    }
+
     recalc_max(node) {
         let node_current = node;
         while (node_current.parent != null) {
@@ -398,6 +417,21 @@ class IntervalTree {
         }
     }
 
+    tree_search_nearest_forward(node, search_node) {
+        let best;
+        let curr = node;
+        while (curr && curr != this.nil_node) {
+            if (curr.less_than(search_node)) {
+                if (curr.intersect(search_node) && (!best || curr.less_than(best))) best = curr;
+                curr = curr.right;
+            } else {
+                if (!best || curr.less_than(best)) best = curr;
+                curr = curr.left;
+            }
+        }
+        return best || null;
+    }
+
     // Original search_interval method; container res support push() insertion
     // Search all intervals intersecting given one
     tree_search_interval(node, search_node, res) {
@@ -595,7 +629,7 @@ class IntervalTree {
         }
         height += heightLeft;
         return height;
-    };
+    }
 };
 
 export default IntervalTree;

src/classes/intervalTree.js

@@ -9,7 +9,7 @@ import {Interval} from "../index";
 // import IntervalTree from '../dist/interval-tree.esm';
 
 describe('#IntervalTree', function() {
-    it('Create new instanse of IntervalTree ', function () {
+    it('Create new instance of IntervalTree ', function () {
         let tree = new IntervalTree();
         expect(tree).to.be.an.instanceof(IntervalTree);
     });
@@ -310,4 +310,69 @@ describe('#IntervalTree', function() {
         const resp2 = tree.search([4,11]);
         expect(resp2).to.deep.equal([[5,7],[7,8]]);
     })
+    describe('##Iterator', function() {
+        it('May find first intersecting interval', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([3,8]);
+            expect(iterator.next().value).to.deep.equal([1,3]);
+        });
+        it('May find first forward interval when there is no intersection', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([4,4]);
+            expect(iterator.next().value).to.deep.equal([5,7]);
+        });
+        it('May find first interval when no interval is passed', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate();
+            expect(iterator.next().value).to.deep.equal([1,1]);
+        });
+        it('Supports iteration with `for .. of` syntax', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let results = [];
+            for (let val of tree.iterate([4,4])) {
+                results.push(val);
+            }
+            expect(results).to.deep.equal([[5,7],[5,12],[6,8]]);
+        });
+        it('Returns `{done: true}` when it reaches the end', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([8,8]);
+            expect(iterator.next().value).to.deep.equal([5,12]);
+            expect(iterator.next().value).to.deep.equal([6,8]);
+            let res = iterator.next();
+            expect(res.value).to.equal(undefined);
+            expect(res.done).to.equal(true);
+        });
+        it('Supports custom transformed objects', function () {
+            const composers = [
+                {name: "Ludwig van Beethoven", period: [1770,1827]},
+                {name: "Johann Sebastian Bach", period: [1685, 1750]},
+                {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+                {name: "Johannes Brahms", period: [1833, 1897]},
+                {name: "Richard Wagner", period: [1813, 1883]},
+                {name: "Claude Debussy", period: [1862, 1918]},
+                {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+                {name: "Frédéric Chopin", period: [1810, 1849]},
+                {name: "Joseph Haydn", period: [1732, 1809]},
+                {name: "Antonio Vivaldi", period: [1678, 1741]}
+            ];
+            const tree = new IntervalTree();
+            for (let composer of composers)
+                tree.insert(composer.period, composer.name);
+            let iterator = tree.iterate([1600, 1700],
+                (name, period) => {return `${name} (${period.low}-${period.high})`});
+            expect(iterator.next().value).to.equal("Antonio Vivaldi (1678-1741)");
+            expect(iterator.next().value).to.equal("Johann Sebastian Bach (1685-1750)");
+        });
+    });
 });