#49 add compatibility with 1.3.4

Author: folkvir

README.md

@@ -544,11 +544,15 @@ In the case you want to use your own hash functions, you can override the `_seri
 ```js
 const {BaseFilter, BloomFilter} = require('bloom-filters')
 
-// override the method
-BaseFilter.prototype._serialize = function (element, seed=undefined) { return Number(1) }
+function _serialize(element, seed=undefined) { return Number(1) }
+
+// override the method globaly for all classes
+BaseFilter.prototype._serialize = _serialize
 
 // use the library as usual
 const bl = BloomFilter.create(2, 0.01)
+// override just your structure locally
+bl._serialize = _serialize
 bl.add('a')
 ```
 See `test/utils-test.js` "_Use different hash functions_" describe close.

src/base-filter.ts

@@ -299,4 +299,78 @@ export default abstract class BaseFilter {
     const hash = this._hashAsInt(elem, seed)
     return {int: hash, string: numberToHex(hash)}
   }
+
+  /**
+   * @deprecated
+   * Generate a set of distinct indexes on interval [0, size) using the double hashing technique
+   * This function is the old method called by a lot of filters.
+   * To work in the current version, replace, the getIndexes function of the filters by this one
+   * @param  element  - The element to hash
+   * @param  size     - the range on which we can generate an index [0, size) = size
+   * @param  number   - The number of indexes desired
+   * @param  seed     - The seed used
+   * @return A array of indexes
+   * @author Arnaud Grall
+   */
+  protected _deprecated_getDistinctIndices(
+    element: HashableInput,
+    size: number,
+    number: number,
+    seed?: number
+  ): Array<number> {
+    if (seed === undefined) {
+      seed = getDefaultSeed()
+    }
+
+    // old and deprecated double hashing used until version 1.3.9
+    const _deprecated_double_hashing = (
+      n: number,
+      hashA: number,
+      hashB: number,
+      size: number
+    ): number => {
+      return Math.abs((hashA + n * hashB) % size)
+    }
+
+    const _deprecated_getDistinctIndicesBis = (
+      n: number,
+      elem: HashableInput,
+      size: number,
+      count: number,
+      indexes: Array<number> = []
+    ): Array<number> => {
+      if (indexes.length === count) {
+        return indexes
+      } else {
+        const hashes = this._hashTwice(elem, seed! + (size % n))
+        const ind = _deprecated_double_hashing(
+          n,
+          hashes.first,
+          hashes.second,
+          size
+        )
+        if (indexes.includes(ind)) {
+          // console.log('generate index: %d for %s', ind, elem)
+          return _deprecated_getDistinctIndicesBis(
+            n + 1,
+            elem,
+            size,
+            count,
+            indexes
+          )
+        } else {
+          // console.log('already found: %d for %s', ind, elem)
+          indexes.push(ind)
+          return _deprecated_getDistinctIndicesBis(
+            n + 1,
+            elem,
+            size,
+            count,
+            indexes
+          )
+        }
+      }
+    }
+    return _deprecated_getDistinctIndicesBis(1, element, size, number)
+  }
 }

test/compatibility-test.js

@@ -0,0 +1,41 @@
+/*
+MIT License
+
+Copyright (c) 2022 Arnaud Grall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+'use strict'
+
+require('chai').should()
+const {BloomFilter} = require('../dist/api.js')
+
+describe('Compatibility between versions', () => {
+  it('1.3.4 compatibility (issue #49)', () => {
+    const bl = BloomFilter.create(2, 0.01)
+    bl._getIndexes = bl._deprecated_getDistinctIndices
+    bl.add('alice')
+    bl.add('bob')
+    bl.has('alice').should.be.true
+    bl.has('bob').should.be.true
+    const exported = bl.saveAsJSON()
+    console.log(exported)
+  })
+})

test/utils-test.js

@@ -170,12 +170,14 @@ describe('Utils', () => {
 
   describe('Use different hash functions', () => {
     it('overriding serialize function by always returning Number(1)', () => {
-      BaseFilter.prototype._serialize = function (_element, _seed = undefined) { // eslint-disable-line
+      function _serialize(_element, _seed = undefined) { // eslint-disable-line
         return Number(1)
       }
       const bl = BloomFilter.create(2, 0.01)
+      bl._serialize = _serialize
       bl.add('a')
       const bl2 = BloomFilter.create(2, 0.01)
+      bl2._serialize = _serialize
       bl2.add('b')
       // 2 bloom filters with a hash functions returning everytime the same thing must be equal
       bl.equals(bl2).should.be.true