feat: SortedMap

Author: dirkmc

src/utils.js renamed to src/utils/index.js

@@ -0,0 +1,102 @@
+'use strict'
+
+/**
+ * SortedMap is a Map whose iterator order can be defined by the user
+ */
+class SortedMap extends Map {
+  /**
+   * @param {Array<k, v>} [entries]
+   * @param {function(a, b)} [cmp]
+   */
+  constructor (entries, cmp) {
+    super(entries)
+    this._cmp = cmp
+    this._keys = []
+  }
+
+  // Performance is O(N log(N)).
+  // Could be O(log(N)) if we use a sorted array. Fix this if performance isn't
+  // good enough.
+  set (k, data) {
+    super.set(k, data)
+    const i = this._keys.indexOf(k)
+    if (i < 0) {
+      this._keys.push(k)
+      this._keys.sort(this._kvCmp.bind(this))
+    }
+  }
+
+  clear () {
+    super.clear()
+    this._keys = []
+  }
+
+  /**
+   * Call update to manually trigger a sort.
+   * For example if the compare function sorts by the priority field, and the
+   * priority changes, call update.
+   *
+   * @param {Object} [k] the key corresponding to the entry whose position
+   * should be updated.
+   */
+  update (k) {
+    this._keys.sort(this._kvCmp.bind(this))
+  }
+
+  // Same performance comments as set()
+  delete (k) {
+    const i = this._keys.indexOf(k)
+    if (i >= 0) {
+      this._keys.splice(i, 1)
+      super.delete(k)
+    }
+  }
+
+  * keys () {
+    for (const k of this._keys) {
+      yield k
+    }
+  }
+
+  * values () {
+    for (const k of this._keys) {
+      yield this.get(k)
+    }
+  }
+
+  * entries () {
+    for (const k of this._keys) {
+      yield [k, this.get(k)]
+    }
+  }
+
+  * [Symbol.iterator] () {
+    yield * this.entries()
+  }
+
+  forEach (cb, thisArg) {
+    if (!cb) {
+      return
+    }
+
+    for (const k of this._keys) {
+      cb.apply(thisArg, [[k, this.get(k)]])
+    }
+  }
+
+  _kvCmp (a, b) {
+    // By default sort by built-in compare
+    if (!this._cmp) {
+      if (a < b) return -1
+      if (b < a) return 1
+      return 0
+    }
+
+    return this._cmp(
+      [a, this.get(a)],
+      [b, this.get(b)]
+    )
+  }
+}
+
+module.exports = SortedMap

src/utils/sorted-map.js

@@ -10,6 +10,7 @@ const BitswapMessageEntry = require('../src/types/message/entry')
 chai.use(require('dirty-chai'))
 const expect = chai.expect
 const { groupBy, uniqWith, pullAllWith, includesWith, sortBy, isMapEqual } = require('../src/utils')
+const SortedMap = require('../src/utils/sorted-map')
 
 describe('utils spec', function () {
   it('groupBy', () => {
@@ -165,4 +166,95 @@ describe('utils spec', function () {
       )).to.be.true()
     })
   })
+
+  describe('SortedMap', () => {
+    it('size', () => {
+      const sm = new SortedMap()
+      sm.set('one', 1)
+      sm.set('two', 2)
+      sm.set('three', 3)
+
+      expect(sm.size).to.eql(3)
+    })
+
+    it('get / set', () => {
+      const sm = new SortedMap()
+      sm.set('one', 1)
+      sm.set('two', 2)
+      sm.set('three', 3)
+
+      expect(sm.get('one')).to.eql(1)
+      expect(sm.get('two')).to.eql(2)
+      expect(sm.get('three')).to.eql(3)
+    })
+
+    it('delete', () => {
+      const sm = new SortedMap()
+      sm.set('one', 1)
+      sm.set('two', 2)
+      sm.set('three', 3)
+
+      expect(sm.get('two')).to.eql(2)
+
+      sm.delete('two')
+
+      expect(sm.get('two')).to.be.undefined()
+      expect(sm.size).to.eql(2)
+    })
+
+    it('clear', () => {
+      const sm = new SortedMap()
+      sm.set('one', 1)
+      sm.set('two', 2)
+      sm.set('three', 3)
+
+      expect(sm.get('two')).to.eql(2)
+
+      sm.clear('two')
+
+      expect(sm.get('two')).to.be.undefined()
+      expect(sm.size).to.eql(0)
+      expect([...sm.keys()]).to.eql([])
+    })
+
+    it('default order', () => {
+      const sm = new SortedMap()
+
+      sm.set(1, 'a')
+      sm.set(3, 'c')
+      sm.set(2, 'b')
+
+      expect(sm.size).to.eql(3)
+      expect([...sm.keys()]).to.eql([1, 2, 3])
+      expect([...sm.values()]).to.eql(['a', 'b', 'c'])
+      expect([...sm.entries()]).to.eql([[1, 'a'], [2, 'b'], [3, 'c']])
+      expect([...sm]).to.eql([...sm.entries()])
+
+      const collected = []
+      sm.forEach(i => { collected.push(i) })
+      expect(collected).to.eql([...sm])
+    })
+
+    it('custom order', () => {
+      const sm = new SortedMap([], (a, b) => b[1].priority - a[1].priority)
+
+      const data1 = { k: 'v1', priority: 1 }
+      const data2 = { k: 'v2', priority: 3 }
+      const data3 = { k: 'v3', priority: 2 }
+      sm.set('one', data1)
+      sm.set('two', data2)
+      sm.set('three', data3)
+
+      expect([...sm.keys()]).to.eql(['two', 'three', 'one'])
+      expect([...sm.values()].map(v => v.k)).to.eql(['v2', 'v3', 'v1'])
+
+      // After changing data that affects the sort order, need to call update
+      // to actually trigger the sort
+      data3.priority = 5
+      sm.update('three')
+
+      expect([...sm.keys()]).to.eql(['three', 'two', 'one'])
+      expect([...sm.values()].map(v => v.k)).to.eql(['v3', 'v2', 'v1'])
+    })
+  })
 })