refactor small int + big int decoders

Author: runk

lib/decoder.js

@@ -30,15 +30,15 @@ function cursor(value, offset) {
 
 module.exports = Decoder;
 
-function Decoder(fileStream, baseOffset) {
- assert(this.fileStream = fileStream, 'File stream is required');
+function Decoder(db, baseOffset) {
+ assert(this.db = db, 'File stream is required');
  assert(this.baseOffset = baseOffset, 'Base offset is required');
 }
 
 
 Decoder.prototype.decode = function(offset) {
  var tmp,
- ctrlByte = this.fileStream[offset++],
+ ctrlByte = this.db[offset++],
  type = types[ctrlByte >> 5];
 
 
@@ -48,7 +48,7 @@ Decoder.prototype.decode = function(offset) {
  }
 
  if (type === 'extended') {
- tmp = this.fileStream[offset] + 7;
+ tmp = this.db[offset] + 7;
  if (tmp < 8) {
  throw new Error('Maxmind: Invalid Extended Type at offset ' + offset + ' val ' + tmp);
  }
@@ -81,7 +81,7 @@ Decoder.prototype.decodeByType = function(type, offset, size) {
  case 'map':
  return this.decodeMap(size, offset);
  case 'uint32':
- return cursor(this.decodeUint32(offset, size), newOffset);
+ return cursor(this.decodeUint(offset, size), newOffset);
  case 'double':
  return cursor(this.decodeDouble(offset, size), newOffset);
  case 'array':
@@ -93,17 +93,16 @@ Decoder.prototype.decodeByType = function(type, offset, size) {
  case 'bytes':
  return cursor(this.decodeBytes(offset, size), newOffset);
  case 'uint16':
- return cursor(this.decodeUint32(offset, size), newOffset);
+ return cursor(this.decodeUint(offset, size), newOffset);
  case 'int32':
  return cursor(this.decodeInt32(offset, size), newOffset);
  case 'uint64':
- return cursor(this.decodeUint64(offset, size), newOffset);
+ return cursor(this.decodeUint(offset, size), newOffset);
  case 'uint128':
- return cursor(this.decodeUint128(offset, size), newOffset);
-
- default:
- throw new Error('Maxmind: Unknown or unexpected type ' + type + ' at offset ' + offset);
+ return cursor(this.decodeUint(offset, size), newOffset);
  }
+
+ throw new Error('Maxmind: Unknown or unexpected type ' + type + ' at offset ' + offset);
 };
 
 
@@ -133,25 +132,25 @@ Decoder.prototype.sizeFromCtrlByte = function(ctrlByte, offset) {
  // If the value is 29, then the size is 29 + *the next byte after the type
  // specifying bytes as an unsigned integer*.
  if (size === 29)
- return cursor(29 + this.fileStream[offset], offset + 1);
+ return cursor(29 + this.db[offset], offset + 1);
 
  // If the value is 30, then the size is 285 + *the next two bytes after the type
  // specifying bytes as a single unsigned integer*.
  if (size === 30)
- return cursor(285 + this.fileStream.readUInt16BE(offset, false), offset + 2);
+ return cursor(285 + this.db.readUInt16BE(offset, false), offset + 2);
 
  // If the value is 31, then the size is 65,821 + *the next three bytes after the
  // type specifying bytes as a single unsigned integer*.
  if (size === 31)
  return cursor(
- 65821 + utils.concat3(this.fileStream[offset], this.fileStream[offset + 1], this.fileStream[offset + 2]),
+ 65821 + utils.concat3(this.db[offset], this.db[offset + 1], this.db[offset + 2]),
  offset + 3
  );
 };
 
 
 Decoder.prototype.decodeBytes = function(offset, size) {
- return this.fileStream.slice(offset, offset + size)
+ return this.db.slice(offset, offset + size)
 };
 
 
@@ -171,23 +170,23 @@ Decoder.prototype.decodePointer = function(ctrlByte, offset) {
  // If the size is 0, the pointer is built by appending the next byte to the last
  // three bits to produce an 11-bit value.
  if (pointerSize === 0) {
- packed = utils.concat2(ctrlByte & 7, this.fileStream[offset]);
+ packed = utils.concat2(ctrlByte & 7, this.db[offset]);
 
  // If the size is 1, the pointer is built by appending the next two bytes to the
  // last three bits to produce a 19-bit value + 2048.
  } else if (pointerSize === 1) {
- packed = utils.concat3(ctrlByte & 7, this.fileStream[offset], this.fileStream[offset + 1]);
+ packed = utils.concat3(ctrlByte & 7, this.db[offset], this.db[offset + 1]);
 
  // If the size is 2, the pointer is built by appending the next three bytes to the
  // last three bits to produce a 27-bit value + 526336.
  } else if (pointerSize === 2) {
- packed = utils.concat4(ctrlByte & 7, this.fileStream[offset], this.fileStream[offset + 1], this.fileStream[offset + 2]);
+ packed = utils.concat4(ctrlByte & 7, this.db[offset], this.db[offset + 1], this.db[offset + 2]);
 
  // Finally, if the size is 3, the pointer's value is contained in the next four
  // bytes as a 32-bit value. In this case, the last three bits of the control byte
  // are ignored.
  } else if (pointerSize === 3) {
- packed = this.fileStream.readUInt32BE(offset, true);
+ packed = this.db.readUInt32BE(offset, true);
  }
 
  offset += pointerSize + 1;
@@ -215,12 +214,12 @@ Decoder.prototype.decodeBoolean = function(size) {
 
 
 Decoder.prototype.decodeDouble = function(offset, size) {
- return this.fileStream.readDoubleBE(offset, true);
+ return this.db.readDoubleBE(offset, true);
 };
 
 
 Decoder.prototype.decodeFloat = function(offset, size) {
- return this.fileStream.readFloatBE(offset, true);
+ return this.db.readFloatBE(offset, true);
 };
 
 
@@ -243,36 +242,30 @@ Decoder.prototype.decodeMap = function(size, offset) {
 
 Decoder.prototype.decodeInt32 = function(offset, size) {
  if (size == 0) return 0;
- return this.fileStream.readInt32BE(offset, true);
-};
-
-
-Decoder.prototype.decodeUint32 = function(offset, size) {
- if (size == 0) return 0;
- if (size == 1) return this.fileStream[offset];
- if (size == 2) return utils.concat2(this.fileStream[offset + 0], this.fileStream[offset + 1]);
- if (size == 3) return utils.concat3(this.fileStream[offset + 0], this.fileStream[offset + 1], this.fileStream[offset + 2]);
- if (size == 4) return utils.concat4(this.fileStream[offset + 0], this.fileStream[offset + 1], this.fileStream[offset + 2], this.fileStream[offset + 3]);
+ return this.db.readInt32BE(offset, true);
 };
 
 
-Decoder.prototype.decodeUint64 = function(offset, size) {
- return this.decodeBigUint(offset, size, 8);
-};
-
-
-Decoder.prototype.decodeUint128 = function(offset, size) {
- return this.decodeBigUint(offset, size, 16);
+Decoder.prototype.decodeUint = function(offset, size) {
+ switch (size) {
+ case 0: return 0;
+ case 1: return this.db[offset];
+ case 2: return utils.concat2(this.db[offset + 0], this.db[offset + 1]);
+ case 3: return utils.concat3(this.db[offset + 0], this.db[offset + 1], this.db[offset + 2]);
+ case 4: return utils.concat4(this.db[offset + 0], this.db[offset + 1], this.db[offset + 2], this.db[offset + 3]);
+ case 8: return this.decodeBigUint(offset, size);
+ case 16: return this.decodeBigUint(offset, size);
+ }
+ return 0;
 };
 
 
-Decoder.prototype.decodeBigUint = function(offset, size, intSize) {
- var buffer = new Buffer(intSize);
- buffer.fill(0);
- this.fileStream.copy(buffer, intSize - size, offset, offset + intSize);
+Decoder.prototype.decodeBigUint = function(offset, size) {
+ var buffer = new Buffer(size);
+ this.db.copy(buffer, 0, offset, offset + size);
 
  var integer = 0;
- var numberOfLongs = intSize / 4;
+ var numberOfLongs = size / 4;
  for (var i = 0; i < numberOfLongs; i++) {
  integer = bigInt(integer).multiply(4294967296).add(buffer.readUInt32BE(i << 2, true));
  }
@@ -282,5 +275,5 @@ Decoder.prototype.decodeBigUint = function(offset, size, intSize) {
 
 
 Decoder.prototype.decodeString = function(offset, size) {
- return this.fileStream.utf8Slice(offset, offset + size);
+ return this.db.utf8Slice(offset, offset + size);
 };