abstract-chained-batch.js

// Generated by CoffeeScript 1.12.7
(function() {
  var AbstractChainedBatch, Errors, InvalidArgumentError, setImmediate;

  setImmediate = global.setImmediate || process.nextTick;

  Errors = require("./abstract-error");

  InvalidArgumentError = Errors.InvalidArgumentError;

  module.exports = AbstractChainedBatch = (function() {
    function AbstractChainedBatch(db) {
      this._db = db;
      this._operations = [];
      this._written = false;
    }

    AbstractChainedBatch.prototype._checkWritten = function() {
      if (this._written) {
        throw new Error("write() already called on this batch");
      }
    };

    AbstractChainedBatch.prototype.put = function(key, value) {
      var err;
      this._checkWritten();
      err = this._db._checkKey(key, "key", this._db._isBuffer);
      if (err) {
        throw err;
      }
      if (!this._db._isBuffer(key)) {
        key = String(key);
      }
      if (!this._db._isBuffer(value)) {
        value = String(value);
      }
      if (typeof this._put === "function") {
        this._put(key, value);
      } else {
        this._operations.push({
          type: "put",
          key: key,
          value: value
        });
      }
      return this;
    };

    AbstractChainedBatch.prototype.del = function(key) {
      var err;
      this._checkWritten();
      err = this._db._checkKey(key, "key", this._db._isBuffer);
      if (err) {
        throw err;
      }
      if (!this._db._isBuffer(key)) {
        key = String(key);
      }
      if (typeof this._del === "function") {
        this._del(key);
      } else {
        this._operations.push({
          type: "del",
          key: key
        });
      }
      return this;
    };

    AbstractChainedBatch.prototype.clear = function() {
      this._checkWritten();
      this._operations = [];
      if (typeof this._clear === "function") {
        this._clear();
      }
      return this;
    };

    AbstractChainedBatch.prototype._write = function(options, callback) {
      var that;
      that = this;
      if (this._writeSync) {
        return setImmediate(function() {
          var err, result;
          result = void 0;
          try {
            result = that._writeSync(options);
          } catch (error) {
            err = error;
            callback(err);
            return;
          }
          return callback(null, result);
        });
      } else if (typeof this._db._batch === "function") {
        return this._db._batch(this._operations, options, callback);
      } else {
        return setImmediate(callback);
      }
    };

    AbstractChainedBatch.prototype.writeSync = function(options) {
      var result;
      this._checkWritten();
      this._written = true;
      if (this._writeSync) {
        result = this._writeSync(options);
      } else if (typeof this._db._batchSync === "function") {
        result = this._db._batchSync(this._operations, options);
      }
      return result;
    };

    AbstractChainedBatch.prototype.writeAsync = function(options, callback) {
      this._checkWritten();
      if (typeof options === "function") {
        callback = options;
      }
      if (typeof options !== "object") {
        options = {};
      }
      if (typeof callback !== "function") {
        throw new InvalidArgumentError("write() requires a callback argument");
      }
      this._written = true;
      if (typeof this._write === "function") {
        return this._write(options, callback);
      }
      return setImmediate(callback);
    };

    AbstractChainedBatch.prototype.write = function(options, callback) {
      if (typeof options === "function") {
        callback = options;
      }
      if (typeof options !== "object") {
        options = {};
      }
      if (typeof callback === "function") {
        return this.writeAsync(options, callback);
      } else {
        return this.writeSync(options);
      }
    };

    return AbstractChainedBatch;

  })();

}).call(this);