Added check function and fixed up boolean status from null changed values

Author: CMCDragonkai

dist/Counter-browser.js

@@ -1142,6 +1142,27 @@ function setupBitMapConstructors(blockSize) {
           callback(null, null);
         }
       }
+
+      /**
+       * Checks if the counter has been set
+       * @param {number} counter
+       * @param {function} callback
+       */
+
+    }, {
+      key: 'check',
+      value: function check(counter, callback) {
+        var index = counter - this.begin;
+        if (index >= 0 && index < blockSize) {
+          if (isSet(this.bitMap, index)) {
+            callback(true);
+          } else {
+            callback(false);
+          }
+        } else {
+          callback(null);
+        }
+      }
     }]);
 
     return Leaf;
@@ -1279,6 +1300,25 @@ function setupBitMapConstructors(blockSize) {
           callback(null, null);
         }
       }
+
+      /**
+       * Checks if the counter has been set
+       * @param {number} counter
+       * @param {function} callback
+       */
+
+    }, {
+      key: 'check',
+      value: function check(counter, callback) {
+        var index = Math.floor((counter - this.begin) / Math.pow(blockSize, this.depth));
+        if (this.bitMapTrees[index]) {
+          this.bitMapTrees[index].check(counter, function (set) {
+            callback(set);
+          });
+        } else {
+          callback(null);
+        }
+      }
     }]);
 
     return Node;
@@ -1325,7 +1365,7 @@ var Counter = function () {
    * Allocates a counter sequentially
    * If a counter is specified, it will allocate it explicitly
    * But it will skip over intermediate children, and subsequent allocations is still sequential
-   * @param {number} [counter]
+   * @param {?number} counter
    * @returns {number|boolean}
    * @throws {RangeError} - Will throw if the explicitly allocated counter is out of bounds
    */
@@ -1344,6 +1384,7 @@ var Counter = function () {
       }
       this._bitMapTree.allocate(index, function (index_, bitMap, changed_) {
         index = index_;
+        // this can be null if the index checked is outside of the tree
         changed = changed_;
       });
       if (index !== null) {
@@ -1368,9 +1409,29 @@ var Counter = function () {
     value: function deallocate(counter) {
       var changed = void 0;
       this._bitMapTree.deallocate(counter - this._begin, function (bitMap, changed_) {
+        // this can be null if the index checked is outside of the tree
         changed = changed_;
       });
-      return changed;
+      // an index outside of the tree is assumed to be unallocated
+      return !!changed;
+    }
+
+    /**
+     * Checks if a number has been allocated or not
+     * @param {number} counter
+     * @returns {boolean}
+     */
+
+  }, {
+    key: 'check',
+    value: function check(counter) {
+      var set = void 0;
+      this._bitMapTree.check(counter - this._begin, function (set_) {
+        // this can be null if the index checked is outside of the tree
+        set = set_;
+      });
+      // an index outside of the tree is assumed to be unallocated
+      return !!set;
     }
   }]);
 

dist/Counter.cjs.js

@@ -173,6 +173,24 @@ function setupBitMapConstructors(blockSize) {
       }
     }
 
+    /**
+     * Checks if the counter has been set
+     * @param {number} counter
+     * @param {function} callback
+     */
+    check(counter, callback) {
+      const index = counter - this.begin;
+      if (index >= 0 && index < blockSize) {
+        if (isSet(this.bitMap, index)) {
+          callback(true);
+        } else {
+          callback(false);
+        }
+      } else {
+        callback(null);
+      }
+    }
+
   }
 
   /**
@@ -283,6 +301,22 @@ function setupBitMapConstructors(blockSize) {
       }
     }
 
+    /**
+     * Checks if the counter has been set
+     * @param {number} counter
+     * @param {function} callback
+     */
+    check(counter, callback) {
+      const index = Math.floor((counter - this.begin) / Math.pow(blockSize, this.depth));
+      if (this.bitMapTrees[index]) {
+        this.bitMapTrees[index].check(counter, set => {
+          callback(set);
+        });
+      } else {
+        callback(null);
+      }
+    }
+
   }
 
   return {
@@ -321,7 +355,7 @@ class Counter {
    * Allocates a counter sequentially
    * If a counter is specified, it will allocate it explicitly
    * But it will skip over intermediate children, and subsequent allocations is still sequential
-   * @param {number} [counter]
+   * @param {?number} counter
    * @returns {number|boolean}
    * @throws {RangeError} - Will throw if the explicitly allocated counter is out of bounds
    */
@@ -336,6 +370,7 @@ class Counter {
     }
     this._bitMapTree.allocate(index, (index_, bitMap, changed_) => {
       index = index_;
+      // this can be null if the index checked is outside of the tree
       changed = changed_;
     });
     if (index !== null) {
@@ -357,9 +392,26 @@ class Counter {
   deallocate(counter) {
     let changed;
     this._bitMapTree.deallocate(counter - this._begin, (bitMap, changed_) => {
+      // this can be null if the index checked is outside of the tree
       changed = changed_;
     });
-    return changed;
+    // an index outside of the tree is assumed to be unallocated
+    return !!changed;
+  }
+
+  /**
+   * Checks if a number has been allocated or not
+   * @param {number} counter
+   * @returns {boolean}
+   */
+  check(counter) {
+    let set;
+    this._bitMapTree.check(counter - this._begin, set_ => {
+      // this can be null if the index checked is outside of the tree
+      set = set_;
+    });
+    // an index outside of the tree is assumed to be unallocated
+    return !!set;
   }
 
 }

dist/Counter.es.js

@@ -169,6 +169,24 @@ function setupBitMapConstructors(blockSize) {
       }
     }
 
+    /**
+     * Checks if the counter has been set
+     * @param {number} counter
+     * @param {function} callback
+     */
+    check(counter, callback) {
+      const index = counter - this.begin;
+      if (index >= 0 && index < blockSize) {
+        if (isSet(this.bitMap, index)) {
+          callback(true);
+        } else {
+          callback(false);
+        }
+      } else {
+        callback(null);
+      }
+    }
+
   }
 
   /**
@@ -279,6 +297,22 @@ function setupBitMapConstructors(blockSize) {
       }
     }
 
+    /**
+     * Checks if the counter has been set
+     * @param {number} counter
+     * @param {function} callback
+     */
+    check(counter, callback) {
+      const index = Math.floor((counter - this.begin) / Math.pow(blockSize, this.depth));
+      if (this.bitMapTrees[index]) {
+        this.bitMapTrees[index].check(counter, set => {
+          callback(set);
+        });
+      } else {
+        callback(null);
+      }
+    }
+
   }
 
   return {
@@ -317,7 +351,7 @@ class Counter {
    * Allocates a counter sequentially
    * If a counter is specified, it will allocate it explicitly
    * But it will skip over intermediate children, and subsequent allocations is still sequential
-   * @param {number} [counter]
+   * @param {?number} counter
    * @returns {number|boolean}
    * @throws {RangeError} - Will throw if the explicitly allocated counter is out of bounds
    */
@@ -332,6 +366,7 @@ class Counter {
     }
     this._bitMapTree.allocate(index, (index_, bitMap, changed_) => {
       index = index_;
+      // this can be null if the index checked is outside of the tree
       changed = changed_;
     });
     if (index !== null) {
@@ -353,9 +388,26 @@ class Counter {
   deallocate(counter) {
     let changed;
     this._bitMapTree.deallocate(counter - this._begin, (bitMap, changed_) => {
+      // this can be null if the index checked is outside of the tree
       changed = changed_;
     });
-    return changed;
+    // an index outside of the tree is assumed to be unallocated
+    return !!changed;
+  }
+
+  /**
+   * Checks if a number has been allocated or not
+   * @param {number} counter
+   * @returns {boolean}
+   */
+  check(counter) {
+    let set;
+    this._bitMapTree.check(counter - this._begin, set_ => {
+      // this can be null if the index checked is outside of the tree
+      set = set_;
+    });
+    // an index outside of the tree is assumed to be unallocated
+    return !!set;
   }
 
 }