feat(Object): add bit related operations (#510)

Author: aisk

src/object.js

@@ -789,6 +789,39 @@ module.exports = function(AV) {
       return this.set(attr, new AV.Op.Remove(ensureArray(item)));
     },
 
+    /**
+     * Atomically apply a "bit and" operation on the value associated with a
+     * given key.
+     *
+     * @param attr {String} The key.
+     * @param value {Number} The value to apply.
+     */
+    bitAnd(attr, value) {
+      return this.set(attr, new AV.Op.BitAnd(value));
+    },
+
+    /**
+     * Atomically apply a "bit or" operation on the value associated with a
+     * given key.
+     *
+     * @param attr {String} The key.
+     * @param value {Number} The value to apply.
+     */
+    bitOr(attr, value) {
+      return this.set(attr, new AV.Op.BitOr(value));
+    },
+
+    /**
+     * Atomically apply a "bit xor" operation on the value associated with a
+     * given key.
+     *
+     * @param attr {String} The key.
+     * @param value {Number} The value to apply.
+     */
+    bitXor(attr, value) {
+      return this.set(attr, new AV.Op.BitXor(value));
+    },
+
     /**
      * Returns an instance of a subclass of AV.Op describing what kind of
      * modification has been performed on this field since the last time it was

src/op.js

@@ -194,6 +194,138 @@ module.exports = function(AV) {
     return new AV.Op.Increment(json.amount);
   });
 
+  /**
+   * @private
+   * @class
+   * BitAnd is an atomic operation where the given value will be bit and to the
+   * value than is stored in this field.
+   */
+  AV.Op.BitAnd = AV.Op._extend(/** @lends AV.Op.BitAnd.prototype */ {
+    _initialize(value) {
+      this._value = value;
+    },
+
+    value() {
+      return this._value;
+    },
+
+    /**
+     * Returns a JSON version of the operation suitable for sending to AV.
+     * @return {Object}
+     */
+    toJSON() {
+      return { __op: 'BitAnd', value: this.value() };
+    },
+
+    _mergeWithPrevious(previous) {
+      if (!previous) {
+        return this;
+      } else if (previous instanceof AV.Op.Unset) {
+        return new AV.Op.Set(0);
+      } else if (previous instanceof AV.Op.Set) {
+        return new AV.Op.Set(previous.value() & this.value());
+      } else {
+        throw new Error('Op is invalid after previous op.');
+      }
+    },
+
+    _estimate(oldValue) {
+      return oldValue & this.value();
+    },
+  });
+
+  AV.Op._registerDecoder('BitAnd', function (json) {
+    return new AV.Op.BitAnd(json.value);
+  });
+
+  /**
+   * @private
+   * @class
+   * BitOr is an atomic operation where the given value will be bit and to the
+   * value than is stored in this field.
+   */
+  AV.Op.BitOr = AV.Op._extend(/** @lends AV.Op.BitOr.prototype */ {
+    _initialize(value) {
+      this._value = value;
+    },
+
+    value() {
+      return this._value;
+    },
+
+    /**
+     * Returns a JSON version of the operation suitable for sending to AV.
+     * @return {Object}
+     */
+    toJSON() {
+      return { __op: 'BitOr', value: this.value() };
+    },
+
+    _mergeWithPrevious(previous) {
+      if (!previous) {
+        return this;
+      } else if (previous instanceof AV.Op.Unset) {
+        return new AV.Op.Set(this.value());
+      } else if (previous instanceof AV.Op.Set) {
+        return new AV.Op.Set(previous.value() | this.value());
+      } else {
+        throw new Error('Op is invalid after previous op.');
+      }
+    },
+
+    _estimate(oldValue) {
+      return oldValue | this.value();
+    },
+  });
+
+  AV.Op._registerDecoder('BitOr', function (json) {
+    return new AV.Op.BitOr(json.value);
+  });
+
+  /**
+   * @private
+   * @class
+   * BitXor is an atomic operation where the given value will be bit and to the
+   * value than is stored in this field.
+   */
+  AV.Op.BitXor = AV.Op._extend(/** @lends AV.Op.BitXor.prototype */ {
+    _initialize(value) {
+      this._value = value;
+    },
+
+    value() {
+      return this._value;
+    },
+
+    /**
+     * Returns a JSON version of the operation suitable for sending to AV.
+     * @return {Object}
+     */
+    toJSON() {
+      return { __op: 'BitXor', value: this.value() };
+    },
+
+    _mergeWithPrevious(previous) {
+      if (!previous) {
+        return this;
+      } else if (previous instanceof AV.Op.Unset) {
+        return new AV.Op.Set(this.value());
+      } else if (previous instanceof AV.Op.Set) {
+        return new AV.Op.Set(previous.value() ^ this.value());
+      } else {
+        throw new Error('Op is invalid after previous op.');
+      }
+    },
+
+    _estimate(oldValue) {
+      return oldValue ^ this.value();
+    },
+  });
+
+  AV.Op._registerDecoder('BitXor', function (json) {
+    return new AV.Op.BitXor(json.value);
+  });
+
   /**
    * @private
    * @class

storage.d.ts

@@ -281,6 +281,9 @@ declare namespace AV {
         initialize(): void;
         add(attributeName: string, item: any): Object;
         addUnique(attributeName: string, item: any): any;
+        bitAnd(attributeName: string, item: number): Object;
+        bitOr(attributeName: string, item: number): Object;
+        bitXor(attributeName: string, item: number): Object;
         change(options: any): Object;
         changedAttributes(diff: any): boolean;
         clear(options: any): any;

test/object.js

@@ -605,5 +605,42 @@ describe('Objects', function(){
 
   });
 
+  describe('Bit operations', function() {
+    it('bit and', function() {
+      var score = new GameScore();
+      score.bitAnd('flags', 0b1);
+      expect(score.get('flags')).to.be(0);
+      return score.save().then(() => {
+        expect(score.get('flags')).to.be(0);
+        return GameScore.query.get(score.id);
+      }).then((savedScore) => {
+        expect(savedScore.get('flags')).to.be(0);
+      });
+    });
+
+    it('bit or', function() {
+      var score = new GameScore();
+      score.bitOr('flags', 0b1);
+      expect(score.get('flags')).to.be(0b1);
+      return score.save().then(() => {
+        expect(score.get('flags')).to.be(0b1);
+        return GameScore.query.get(score.id);
+      }).then((savedScore) => {
+        expect(savedScore.get('flags')).to.be(0b1);
+      });
+    });
+
+    it('bit xor', function() {
+      var score = new GameScore();
+      score.bitXor('flags', 0b1);
+      expect(score.get('flags')).to.be(0b1);
+      return score.save().then(() => {
+        expect(score.get('flags')).to.be(0b1);
+        return GameScore.query.get(score.id);
+      }).then((savedScore) => {
+        expect(savedScore.get('flags')).to.be(0b1);
+      });
+    });
+  });
 
 });//END  RETRIEVING