Support objects when cmp(a, b) === 0 but a !== b

[closes #10]

Author: adamhooper

src/SortedSet/AbstractBinaryTreeStrategy.js

@@ -45,7 +45,7 @@ class AbstractBinaryTree {
         node = node.right;
       }
     }
-    return node !== null && node.value === value;
+    return node !== null && comparator(node.value, value) === 0;
   }
 
   findIterator(value) {

src/SortedSet/ArrayStrategy.js

@@ -87,7 +87,7 @@ class ArrayStrategy {
 
   remove(value) {
     const index = binarySearchForIndex(this.data, value, this.comparator);
-    if (this.data[index] !== value) {
+    if (this.comparator(this.data[index], value) !== 0) {
       throw 'Value not in set';
     }
     return this.data.splice(index, 1);
@@ -99,7 +99,7 @@ class ArrayStrategy {
 
   contains(value) {
     const index = binarySearchForIndex(this.data, value, this.comparator);
-    return this.index !== this.data.length && this.data[index] === value;
+    return this.index !== this.data.length && this.comparator(this.data[index], value) === 0;
   }
 
   forEachImpl(callback, sortedSet, thisArg) {

src/SortedSet/BinaryTreeStrategy.js

@@ -52,7 +52,7 @@ class BinaryTreeStrategy extends AbstractBinaryTreeStrategy {
 
   insert(value) {
     const compare = this.comparator;
-    if (this.root != null) {
+    if (this.root !== null) {
       let parent = this.root;
       let leftOrRight = null;
       while (true) {

src/SortedSet/RedBlackTreeStrategy.js

@@ -132,7 +132,7 @@ const removeFromNode = (h, value, compare) => {
   if (h === null) {
     throw 'Value not in set';
   }
-  if (h.value !== value && compare(value, h.value) < 0) {
+  if (compare(value, h.value) < 0) {
     if (h.left === null) {
       throw 'Value not in set';
     }
@@ -145,7 +145,7 @@ const removeFromNode = (h, value, compare) => {
       h = rotateRight(h);
     }
     if (h.right === null) {
-      if (value === h.value) {
+      if (compare(value, h.value) === 0) {
         return null; // leaf node; LLRB assures no left value here
       } else {
         throw 'Value not in set';
@@ -154,7 +154,7 @@ const removeFromNode = (h, value, compare) => {
     if (!h.right.isRed && !(h.right.left !== null && h.right.left.isRed)) {
       h = moveRedRight(h);
     }
-    if (value === h.value) {
+    if (compare(value, h.value) === 0) {
       h.value = findMinNode(h.right).value;
       h.right = removeMinNode(h.right);
     } else {

test/helpers/StrategyHelper.js

@@ -59,6 +59,7 @@ const describeStrategy = (description, strategy) => {
         expect(callback).not.to.have.been.called
       })
     })
+
     describe('with some numbers', function () {
       beforeEach(function () {
         priv = new strategy({
@@ -212,6 +213,56 @@ const describeStrategy = (description, strategy) => {
       })
     })
 
+    describe('with objects for which cmp(a, b) === 0 and a !== b', function () {
+      beforeEach(function () {
+        priv = new strategy({
+          comparator: (a, b) => a.id - b.id
+        })
+        // Insert in this order so binary tree isn't one-sided
+        priv.insert({ id: 2 })
+        priv.insert({ id: 1 })
+        priv.insert({ id: 3 })
+      })
+
+      it('should insert in the middle', function () {
+        priv.insert({ id: 2.5 })
+        expect(priv.toArray()).to.deep.eq([{ id: 1 }, { id: 2 }, { id: 2.5 }, { id: 3 }])
+      })
+
+      it('should remove from the beginning', function () {
+        priv.remove({ id: 1 })
+        expect(priv.toArray()).to.deep.eq([{ id: 2 }, { id: 3 }])
+      })
+
+      it('should remove from the end', function () {
+        priv.remove({ id: 3 })
+        expect(priv.toArray()).to.deep.eq([{ id: 1 }, { id: 2 }])
+      })
+
+      it('should remove from the middle', function () {
+        priv.remove({ id: 2 })
+        expect(priv.toArray()).to.deep.eq([{ id: 1 }, { id: 3 }])
+      })
+
+      it('should contain a middle value', function () {
+        expect(priv.contains({ id: 2 })).to.eq(true)
+      })
+
+      it('should not contain a value in between two values', function () {
+        expect(priv.contains({ id: 1.5 })).to.eq(false)
+      })
+
+      it('should find an iterator', function () {
+        const iterator = priv.findIterator({ id: 2 })
+        expect(iterator.value()).to.deep.eq({ id: 2 })
+      })
+
+      it('should find an iterator between values', function () {
+        const iterator = priv.findIterator({ id: 1.5 })
+        expect(iterator.value()).to.deep.eq({ id: 2 })
+      })
+    })
+
     describe('with allowSetValue', function () {
       beforeEach(function () {
         priv = new strategy({
@@ -243,14 +294,8 @@ const describeStrategy = (description, strategy) => {
         }
         const onInsertConflict = SortedSet.OnInsertConflictThrow
         priv = new strategy({ comparator, onInsertConflict })
-        priv.insert({
-          v: 1,
-          q: 'a'
-        })
-        priv.insert({
-          v: 2,
-          q: 'b'
-        })
+        priv.insert({ v: 1, q: 'a' })
+        priv.insert({ v: 2, q: 'b' })
       })
 
       it('should throw when inserting an element that matches another', function () {
@@ -266,30 +311,15 @@ const describeStrategy = (description, strategy) => {
         }
         onInsertConflict = SortedSet.OnInsertConflictReplace
         priv = new strategy({ comparator, onInsertConflict })
-        priv.insert({
-          v: 1,
-          q: 'a'
-        })
-        priv.insert({
-          v: 2,
-          q: 'b'
-        })
+        priv.insert({ v: 1, q: 'a' })
+        priv.insert({ v: 2, q: 'b' })
       })
 
       it('should replace a matching element with the new element', function () {
-        priv.insert({
-          v: 1,
-          q: 'c'
-        })
+        priv.insert({ v: 1, q: 'c' })
         expect(priv.toArray()).to.deep.eq([
-          {
-            v: 1,
-            q: 'c'
-          },
-          {
-            v: 2,
-            q: 'b'
-          }
+          { v: 1, q: 'c' },
+          { v: 2, q: 'b' }
         ])
       })
     })
@@ -301,30 +331,15 @@ const describeStrategy = (description, strategy) => {
         }
         const onInsertConflict = SortedSet.OnInsertConflictIgnore
         priv = new strategy({ comparator, onInsertConflict })
-        priv.insert({
-          v: 1,
-          q: 'a'
-        })
-        priv.insert({
-          v: 2,
-          q: 'b'
-        })
+        priv.insert({ v: 1, q: 'a' })
+        priv.insert({ v: 2, q: 'b' })
       })
 
       it('should ignore the new element when inserting an element that matches another ', function () {
-        priv.insert({
-          v: 1,
-          q: 'c'
-        })
+        priv.insert({ v: 1, q: 'c' })
         expect(priv.toArray()).to.deep.eq([
-          {
-            v: 1,
-            q: 'a'
-          },
-          {
-            v: 2,
-            q: 'b'
-          }
+          { v: 1, q: 'a' },
+          { v: 2, q: 'b' }
         ])
       })
     })