leveldb.js

// Generated by CoffeeScript 1.12.7
(function() {
  var AbstractNoSQL, ChainedBatch, Errors, InvalidArgumentError, Iterator, LevelDB, binding, inherits;

  inherits = require('inherits-ex');

  AbstractNoSQL = require('abstract-nosql');

  Errors = require('abstract-nosql/abstract-error');

  binding = require('bindings')('leveldown.node').leveldown;

  ChainedBatch = require('./chained-batch');

  Iterator = require('./iterator');

  InvalidArgumentError = Errors.InvalidArgumentError;

  LevelDB = (function() {
    inherits(LevelDB, AbstractNoSQL);

    function LevelDB(location) {
      if (!(this instanceof LevelDB)) {
        return new LevelDB(location);
      }
      LevelDB.__super__.constructor.call(this, location);
      this.binding = binding(location);
      return;
    }

    LevelDB.prototype._openSync = function(options) {
      return this.binding.openSync(options);
    };

    LevelDB.prototype._closeSync = function() {
      return this.binding.closeSync();
    };


    /* ## the native close async maybe crash ...
    _close: (cb)->
      return @binding.close(cb)
     */

    LevelDB.prototype._isExistsSync = function(key, options) {
      var result;
      result = this.binding.isExistsSync(key, options);
      return result;
    };

    LevelDB.prototype._mGetSync = function(keys, options) {
      var asBuffer, i, result;
      asBuffer = false;
      if (typeof options === 'object') {
        if (options.asBuffer === true) {
          asBuffer = true;
        }
      }
      result = this.binding.mGetSync(keys, options);
      if (asBuffer) {
        i = 1;
        while (i < result.length) {
          result[i] = new Buffer(result[i]);
          i += 2;
        }
      }
      return result;
    };

    LevelDB.prototype._getBufferSync = function(key, destBuffer, options) {
      var result;
      result = this.binding.getBufferSync(key, destBuffer, options);
      return result;
    };

    LevelDB.prototype._getSync = function(key, options) {
      var asBuffer, result;
      asBuffer = false;
      if (typeof options === 'object') {
        if (options.asBuffer === true) {
          asBuffer = true;
        }
      }
      result = this.binding.getSync(key, options);
      if (asBuffer) {
        result = new Buffer(result);
      }
      return result;
    };

    LevelDB.prototype._putSync = function(key, value, options) {
      return this.binding.putSync(key, value, options);
    };

    LevelDB.prototype._delSync = function(key, options) {
      return this.binding.delSync(key, options);
    };

    LevelDB.prototype._batchSync = function(operations, options) {
      return this.binding.batchSync(operations, options);
    };

    LevelDB.prototype._approximateSizeSync = function(start, end) {
      return this.binding.approximateSizeSync(start, end);
    };

    LevelDB.prototype.compactRangeSync = function(start, end) {
      return this.binding.compactRangeSync(start, end);
    };

    LevelDB.prototype.compactRangeAsync = function(start, end, callback) {
      var that;
      that = this;
      return setImmediate(function() {
        var err, result;
        result = void 0;
        try {
          result = that.compactRangeSync(start, end);
        } catch (error) {
          err = error;
          callback(err);
          return;
        }
        callback(null, result);
      });
    };

    LevelDB.prototype.compactRange = function(start, end, callback) {
      if (typeof callback !== 'function') {
        return this.compactRangeSync(start, end);
      } else {
        return this.compactRangeAsync(start, end, callback);
      }
    };

    LevelDB.prototype._chainedBatch = function() {
      return new ChainedBatch(this);
    };

    LevelDB.prototype.getProperty = function(property) {
      if (typeof property !== 'string') {
        throw new InvalidArgumentError('getProperty() requires a valid `property` argument');
      }
      return this.binding.getProperty(property);
    };

    LevelDB.prototype.IteratorClass = Iterator;

    LevelDB.destroySync = function(location) {
      return binding.destroySync(location);
    };

    LevelDB.repairSync = function(location) {
      return binding.repairSync(location);
    };

    LevelDB.repairAsync = function(location, callback) {
      var that;
      that = this;
      return setImmediate(function() {
        var err, result;
        result = void 0;
        try {
          result = that.repairSync(location);
        } catch (error) {
          err = error;
          callback(err);
          return;
        }
        callback(null, result);
      });
    };

    LevelDB.destroyAsync = function(location, callback) {
      var that;
      that = this;
      return setImmediate(function() {
        var err, result;
        result = void 0;
        try {
          result = that.destroySync(location);
        } catch (error) {
          err = error;
          callback(err);
          return;
        }
        callback(null, result);
      });
    };

    LevelDB.destroy = function(location, callback) {
      if (typeof location !== 'string') {
        throw new InvalidArgumentError('destroy() requires a location string argument');
      }
      if (typeof callback !== 'function') {
        return this.destroySync(location);
      } else {
        return this.destroyAsync(location, callback);
      }
    };

    LevelDB.repair = function(location, callback) {
      if (typeof location !== 'string') {
        throw new InvalidArgumentError('repair() requires a location string argument');
      }
      if (typeof callback !== 'function') {
        return this.repairSync(location);
      } else {
        return this.repairAsync(location, callback);
      }
    };

    return LevelDB;

  })();

  module.exports = LevelDB;

}).call(this);