Method to look up the node index of an object

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -460,6 +460,40 @@ class SymbolTree {
                 return iterator;
         }
 
+        /**
+         * Find the index of the given object (the number of preceding siblings).
+         *
+         * `O(n)`
+         *
+         * @method index
+         * @memberOf module:symbol-tree#
+         * @param {Object} child
+         * @return {Number} The number of preceding siblings, or -1 if the object has no parent
+         */
+        index(child) {
+                const parentNode = this._node(this._node(child).parent);
+
+                if (!parentNode) {
+                        // In principal, you could also find out the number of preceding siblings
+                        // for objects that do not have a parent. This method limits itself only to
+                        // objects that have a parent because that lets us optimize more.
+                        return -1;
+                }
+
+                let index = 0;
+                let object = parentNode.first;
+
+                while (object) {
+                        if (object === child) {
+                                break;
+                        }
+                        ++index;
+                        object = this._node(object).next;
+                }
+
+                return index;
+        }
+
         /**
          * Remove the object from this tree.
          * Has no effect if already removed.

test/SymbolTree.js

@@ -893,3 +893,28 @@ test('tree iterator', function(t) {
 
         t.end();
 });
+
+test('look up the index of an object', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const ac = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(ac, a);
+        tree.insertAfter(b, a);
+
+        t.equal(-1, tree.index(a), 'should return -1 if an object has no parent');
+        t.equal(0, tree.index(aa));
+        t.equal(1, tree.index(ab));
+        t.equal(0, tree.index(aba));
+        t.equal(2, tree.index(ac));
+        t.equal(-1, tree.index(b));
+
+        t.end();
+});