Browse files

initial commit

  • Loading branch information...
0 parents commit bbc1ca04f912493412428077fcde1a49c2a5c35c Marcello Bastea-Forte committed Jun 20, 2011
Showing with 1,623 additions and 0 deletions.
  1. +1 −0 .gitignore
  2. +20 −0 LICENSE
  3. +78 −0 Readme.md
  4. +3 −0 buffalo.js
  5. +370 −0 lib/bson.js
  6. +118 −0 lib/extern/buffer_ieee754.js
  7. +791 −0 lib/extern/long.js
  8. +22 −0 package.json
  9. +220 −0 test/bson-test.js
1 .gitignore
@@ -0,0 +1 @@
+node_modules
20 LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2011 Marcello Bastéa-Forte (marcello@cellosoft.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source
+ distribution.
78 Readme.md
@@ -0,0 +1,78 @@
+Buffalo
+==================
+Buffalo is a lightweight [BSON][1] library for [Node.js][2]. It was built as a new underlying engine for
+[Mongolian DeadBeef][3].
+
+The motivation is to make a fast and simple parser and serializer for BSON.
+
+Installation
+------------
+**DISCLAIMER: The API is experimental. I will be adding, removing, and changing the API in the
+interest of a solid API. Use at your own risk**
+
+You can either clone the source and install with `npm link`, or install the latest published version from npm with
+`npm install buffalo`.
+
+Running Tests
+-------------
+Run the tests with `npm test`.
+
+API
+---
+Buffalo exposes two methods:
+
+ exports.parse = function(buffer) { ... }
+ exports.serialize = function(object) { ... }
+
+And several types:
+
+ exports.Long // goog.math.Long - http://closure-library.googlecode.com/svn/docs/class_goog_math_Long.html
+ exports.ObjectId = function(bytes) // bytes should be a 12-byte Buffer, accessible via the bytes property
+ exports.Timestamp // under construction
+
+The BSON types are mapped as follows:
+
++ <code>0x01</code> - Floating point - mapped to <code>Number</code>
++ <code>0x02</code> - UTF-8 string - mapped to <code>String</code>
++ <code>0x03</code> - Embedded document - mapped to <code>Object</code>
++ <code>0x04</code> - Array - mapped to <code>Array</code>
++ <code>0x05</code> - Binary data - mapped to Node.js <code>Buffer</code> (with property <code>subtype</code>)
++ <code>0x06</code> - Undefined - mapped to <code>undefined</code>
++ <code>0x07</code> - ObjectId - mapped to <code>exports.ObjectId</code>
++ <code>0x08</code> - Boolean - mapped to <code>true</code> or <code>false</code>
++ <code>0x09</code> - UTC datetime - mapped to <code>Date</code>
++ <code>0x0A</code> - Null value - mapped to <code>null</code>
++ <code>0x0B</code> - Regular expression - mapped to <code>RegExp</code> (Note: only flags g, i, and m are supported)
++ <code>0x0C</code> - DBPointer - currently unmapped
++ <code>0x0D</code> - JavaScript code - mapped to <code>Function</code> or <code>Object</code> with property <code>code</code>
++ <code>0x0E</code> - Symbol - mapped to <code>String</code>
++ <code>0x0F</code> - JavaScript code w/ scope - mapped to <code>Function</code> or <code>Object</code> with properties <code>code</code> and <code>scope</code>
++ <code>0x10</code> - 32-bit Integer - mapped to <code>Number</code>
++ <code>0x11</code> - Timestamp - mapped to <code>exports.Timestamp</code>
++ <code>0x12</code> - 64-bit integer - mapped to <code>exports.Long</code>
++ <code>0xFF</code> - Min key - currently unmapped
++ <code>0x7F</code> - Max key - currently unmapped
+
+Examples
+--------
+
+ var BSON = require('buffalo')
+
+ // Parse a Buffer
+ var object = BSON.parse(buffer)
+
+ // Serialize an object
+ var buffer = BSON.serialize(object)
+
+Contributing
+------------
+Try it out and send me feedback! Unit tests and documentation are good, too.
+
+License
+-------
+Buffalo is open source software under the [zlib license][4].
+
+[1]: http://bsonspec.org/#/specification
+[2]: http://nodejs.org/
+[3]: https://github.com/marcello3d/node-mongolian
+[4]: https://github.com/marcello3d/node-buffalo/blob/master/LICENSE
3 buffalo.js
@@ -0,0 +1,3 @@
+/* Mongolian DeadBeef by Marcello Bastea-Forte - zlib license */
+
+module.exports = require('./lib/bson')
370 lib/bson.js
@@ -0,0 +1,370 @@
+/* Mongolian DeadBeef by Marcello Bastea-Forte - zlib license */
+
+// based on http://bsonspec.org/#/specification
+
+var Long = require('./extern/long').Long,
+ IEEE754 = require('./extern/buffer_ieee754'),
+ toSource = require('tosource')
+
+
+var FLOAT_TYPE = 1
+var STRING_TYPE = 2
+var EMBEDDED_DOCUMENT_TYPE = 3
+var ARRAY_TYPE = 4
+var BINARY_TYPE = 5
+var UNDEFINED_TYPE = 6 // deprecated
+var OBJECT_ID_TYPE = 7
+var BOOLEAN_TYPE = 8
+var DATE_TIME_TYPE = 9
+var NULL_TYPE = 0x0A
+var REG_EXP_TYPE = 0x0B
+var DB_REF_TYPE = 0x0C // deprecated
+var CODE_TYPE = 0x0D
+var SYMBOL_TYPE = 0x0E
+var CODE_WITH_SCOPE_TYPE = 0x0F
+var INT32_TYPE = 0x10
+var TIMESTAMP_TYPE = 0x11
+var INT64_TYPE = 0x12
+var MIN_KEY = 0xFF
+var MAX_KEY = 0x7F
+
+var BINARY_GENERIC_SUBTYPE = 0x00
+var BINARY_FUNCTION_SUBTYPE = 0x01
+var BINARY_OLD_SUBTYPE = 0x02
+var BINARY_UUID_SUBTYPE = 0x03
+var BINARY_MD5_SUBTYPE = 0x05
+var BINARY_USER_DEFINED_SUBTYPE = 0x80
+
+exports.parse = function(buffer) {
+ return new BSONParser(buffer, 0, false)
+}
+
+exports.serialize = function(object) {
+ var buffers = new BSONSerializer(object, [], true)
+ var finalSize = 0
+ buffers.forEach(function(buffer) { finalSize += buffer.length })
+ var finalBuffer = new Buffer(finalSize)
+ var offset = 0
+ buffers.forEach(function(buffer) {
+ buffer.copy(finalBuffer, offset, 0)
+ offset += buffer.length
+ })
+ return finalBuffer
+}
+
+var BSONSerializer = function(object) {
+ this.buffers = []
+
+ if (Array.isArray(object)) {
+ object.forEach(function(element, name) {
+ this.writeElement(String(name), element)
+ }, this)
+ } else {
+ for (var key in object) this.writeElement(key, object[key])
+ }
+
+ this.writeByte(0)
+
+ var finalSize = 4
+ this.buffers.forEach(function(buffer) { finalSize += buffer.length })
+
+ // Write the int to the front of the buffers
+ this.writeInt(finalSize)
+ this.buffers.unshift(this.buffers.pop())
+
+ return this.buffers
+}
+BSONSerializer.prototype.writeElement = function(name, element) {
+ switch (typeof element) {
+ case 'string':
+ this.writeByte(STRING_TYPE)
+ this.writeCString(name)
+ this.writeString(element)
+ break
+
+ case 'function':
+ if (element instanceof RegExp) {
+ this.writeByte(REG_EXP_TYPE)
+ this.writeCString(name)
+ this.writeCString(element.source)
+ this.writeCString((element.global ? 'g' : '') +
+ (element.ignoreCase ? 'i' : '') +
+ (element.multiline ? 'm' : ''))
+ } else {
+ if (typeof (element.scope) == 'object') {
+ this.writeByte(CODE_WITH_SCOPE_TYPE)
+ this.writeCString(name)
+ // We need to compute the size of the int + code + scope sub document before "writing" anything
+ var codeBuffer = new Buffer(element.toString(), 'utf8')
+ var scopeBuffers = new BSONSerializer(element.scope)
+ var codeWithScopeFinalSize = 4 + 4 + codeBuffer.length
+ scopeBuffers.forEach(function(buffer) { codeWithScopeFinalSize += buffer.length })
+ this.writeInt(codeWithScopeFinalSize)
+ this.writeInt(codeBuffer.length + 1)
+ this.buffers.push(codeBuffer,new Buffer([0]))
+ this.buffers.push.apply(this.buffers, scopeBuffers)
+ } else {
+ this.writeByte(CODE_TYPE)
+ this.writeCString(name)
+ this.writeString(element.toString())
+ }
+ }
+ break
+ case 'number':
+ // TODO: handle >32bit longs that aren't doubles?
+ if (~~element === element) { // Integer?
+ this.writeByte(INT32_TYPE)
+ this.writeCString(name)
+ this.writeInt(element)
+ } else {
+ this.writeByte(FLOAT_TYPE)
+ this.writeCString(name)
+ this.writeDouble(element)
+ }
+ break
+ case 'undefined':
+ this.writeByte(UNDEFINED_TYPE)
+ this.writeCString(name)
+ break
+ case 'object':
+ if (element === null) {
+ this.writeByte(NULL_TYPE)
+ this.writeCString(name)
+ } else if (element instanceof Long) {
+ this.writeByte((element instanceof Timestamp) ? TIMESTAMP_TYPE : INT64_TYPE)
+ this.writeCString(name)
+ this.writeInt(element.low_)
+ this.writeInt(element.high_)
+ } else if (element instanceof ObjectId) {
+ this.writeByte(OBJECT_ID_TYPE)
+ this.writeCString(name)
+ this.buffers.push(element.bytes)
+ } else if (element instanceof Buffer) {
+ this.writeByte(BINARY_TYPE)
+ this.writeCString(name)
+ this.writeInt(element.length) // Just the length of the binary
+ this.writeByte(element.subtype || BINARY_GENERIC_SUBTYPE)
+ this.buffers.push(element)
+ } else if (element instanceof Date) {
+ this.writeByte(DATE_TIME_TYPE)
+ this.writeCString(name)
+ this.writeLong(Long.fromNumber(element.getTime()))
+ } else if (Array.isArray(element)) {
+ this.writeByte(ARRAY_TYPE)
+ this.writeCString(name)
+ this.buffers.push.apply(this.buffers, new BSONSerializer(element))
+ } else {
+ this.writeByte(EMBEDDED_DOCUMENT_TYPE)
+ this.writeCString(name)
+ this.buffers.push.apply(this.buffers, new BSONSerializer(element))
+ }
+ break
+ case 'boolean':
+ this.writeByte(BOOLEAN_TYPE)
+ this.writeCString(name)
+ this.writeByte(element ? 1 : 0)
+ break
+ default:
+ throw new Error("Unrecognized object type: "+typeof element)
+ }
+}
+
+BSONSerializer.prototype.writeByte = function(b) {
+ this.buffers.push(new Buffer([b]))
+}
+BSONSerializer.prototype.writeCString = function(string) {
+ var buffer = new Buffer(string, 'utf8')
+ for (var i=0; i<buffer.length; i++) if (buffer[i] === 0) throw new Error("Illegal c-string: 0 char not allowed")
+ this.buffers.push(buffer, new Buffer([0]))
+}
+BSONSerializer.prototype.writeString = function(string) {
+ var buffer = new Buffer(string, 'utf8')
+ this.writeInt(buffer.length + 1) // include \x00 character in count
+ this.buffers.push(buffer, new Buffer([0]))
+}
+BSONSerializer.prototype.writeInt = function(num) {
+ this.buffers.push(new Buffer([
+ (num) & 0xff,
+ (num>>8) & 0xff,
+ (num>>16) & 0xff,
+ (num>>24) & 0xff
+ ]))
+}
+BSONSerializer.prototype.writeDouble = function(num) {
+ var buffer = new Buffer(8)
+ IEEE754.writeIEEE754(buffer, num, 0, 'little', 52, 8)
+ this.buffers.push(buffer)
+}
+BSONSerializer.prototype.writeLong = function(num) {
+ this.writeInt(num.low_)
+ this.writeInt(num.high_)
+}
+
+var BSONParser = function(buffer, offset, array) {
+ this.offset = 0
+ this.buffer = buffer
+ var length = this.readInt()
+
+ // Check for too-short buffer
+ if (buffer.length < length - offset) throw new Error("Incomplete BSON buffer (expected "+length+" bytes)")
+
+ // Protect the buffer from overruns
+ if (buffer.length > length - offset) this.buffer = buffer.slice(offset, offset + length)
+
+ var object = array ? [] : {}
+ while (this.offset < length) {
+ var type = this.readByte()
+ if (type == 0) break
+ var name = this.readCString()
+ object[name] = this.readElement(type)
+ }
+
+ return object
+}
+
+var FUNCTION_MATCH = /^\s*function(?:\s+\S+)?\s*\(([^\)]*)\)\s*\{([\s\S]*)\}\s*$/
+
+BSONParser.prototype.readElement = function(type) {
+ switch (type) {
+ case FLOAT_TYPE:
+ return this.readDouble()
+ case INT32_TYPE:
+ return this.readInt()
+ case INT64_TYPE:
+ return this.readLong()
+ case STRING_TYPE:
+ return this.readString()
+ case EMBEDDED_DOCUMENT_TYPE:
+ return this.readEmbeddedObject(false)
+ case ARRAY_TYPE:
+ return this.readEmbeddedObject(true)
+ case BINARY_TYPE:
+ return this.readBinary()
+ case OBJECT_ID_TYPE:
+ return this.readObjectId()
+ case BOOLEAN_TYPE:
+ return (this.readByte() == 1)
+ case DATE_TIME_TYPE:
+ return new Date(this.readLong().toNumber())
+ case REG_EXP_TYPE:
+ return new RegExp(this.readCString(), this.readCString())
+ case DB_REF_TYPE:
+ return new DBRef(this.readString(), this.readObjectId())
+ case CODE_TYPE:
+ return this.readCode()
+ case SYMBOL_TYPE:
+ return this.readString()
+ case CODE_WITH_SCOPE_TYPE:
+ return this.readCodeWithScope()
+ case TIMESTAMP_TYPE:
+ return this.readTimestamp()
+ case UNDEFINED_TYPE:
+ return undefined
+ case NULL_TYPE:
+ case MIN_KEY:
+ case MAX_KEY:
+ return null
+ }
+ throw new Error("Unknown BSON type: "+type)
+}
+
+BSONParser.prototype.readInt = function() {
+ // Little-endian
+ return (this.buffer[this.offset++]) |
+ (this.buffer[this.offset++] << 8) |
+ (this.buffer[this.offset++] << 16) |
+ (this.buffer[this.offset++] << 24)
+}
+
+BSONParser.prototype.readLong = function() {
+ var low = this.readInt()
+ var high = this.readInt()
+ return new Long(low, high)
+}
+
+BSONParser.prototype.readDouble = function() {
+ var value = IEEE754.readIEEE754(this.buffer, this.offset, 'little', 52, 8)
+ this.offset += 8
+ return value
+}
+
+BSONParser.prototype.readEmbeddedObject = function(array) {
+ var length = this.readInt()
+ var doc = new BSONParser(this.buffer.slice(this.offset - 4, this.offset - 4 + length), 0, array)
+ this.offset += length
+ return doc
+}
+
+BSONParser.prototype.readCString = function() {
+ for (var i=this.offset; i<this.buffer.length; i++) {
+ if (this.buffer[i] === 0) {
+ var string = this.buffer.toString('utf8', this.offset, i)
+ this.offset = i + 1
+ return string
+ }
+ }
+ throw new Error("Unterminated c-string!")
+}
+
+BSONParser.prototype.readString = function() {
+ var length = this.readInt()
+ if (length > this.buffer.length - this.offset) throw new Error("Invalid string ("+length+" extends past end of data)")
+ var string = this.buffer.toString('utf8', this.offset, this.offset + length - 1)
+ this.offset += length
+ return string
+}
+BSONParser.prototype.readObjectId = function() {
+ return new ObjectId(this.buffer.slice(this.offset, this.offset += 12))
+}
+BSONParser.prototype.readByte = function() {
+ return this.buffer[this.offset++]
+}
+BSONParser.prototype.readBinary = function() {
+ var length = this.readInt()
+ var subtype = this.readByte()
+ var binary = new Buffer(length)
+ this.buffer.copy(binary, 0, this.offset, this.offset += length)
+ binary.subtype = subtype
+ return binary
+}
+BSONParser.prototype.readTimestamp = function() {
+ return new Timestamp(this.readInt(), this.readInt())
+}
+
+function makeFunction(code, scope) {
+ var f
+ try {
+ var args = [], funcParts = FUNCTION_MATCH.exec(code)
+ if (funcParts) {
+ args = funcParts[1].split(',').map(function(name) { return name.trim() })
+ code = funcParts[2]
+ }
+ if (scope) code = "with("+toSource(scope)+"){"+code+"}"
+ f = new Function(args, code)
+ } catch (e) {
+ f = {}
+ }
+ f.code = code
+ if (scope) f.scope = scope
+ return f
+}
+BSONParser.prototype.readCode = function() {
+ var func = this.readString()
+ return makeFunction(func)
+}
+BSONParser.prototype.readCodeWithScope = function() {
+ this.readInt()
+ var code = this.readString()
+ var scope = this.readEmbeddedObject()
+ return makeFunction(code,scope)
+}
+
+var ObjectId = exports.ObjectId = function (bytes) {
+ this.bytes = bytes
+}
+
+exports.Long = Long
+var Timestamp = exports.Timestamp = function(low, high) {
+ Long.call(this, low, high)
+}
+require('util').inherits(Timestamp, Long)
118 lib/extern/buffer_ieee754.js
@@ -0,0 +1,118 @@
+// Copyright (c) 2008, Fair Oaks Labs, Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//
+// Modifications to writeIEEE754 to support negative zeroes made by Brian White
+
+exports.readIEEE754 = function(buffer, offset, endian, mLen, nBytes) {
+ var e, m,
+ bBE = (endian === 'big'),
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ nBits = -7,
+ i = bBE ? 0 : (nBytes - 1),
+ d = bBE ? 1 : -1,
+ s = buffer[offset + i];
+
+ i += d;
+
+ e = s & ((1 << (-nBits)) - 1);
+ s >>= (-nBits);
+ nBits += eLen;
+ for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ m = e & ((1 << (-nBits)) - 1);
+ e >>= (-nBits);
+ nBits += mLen;
+ for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ if (e === 0) {
+ e = 1 - eBias;
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity);
+ } else {
+ m = m + Math.pow(2, mLen);
+ e = e - eBias;
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.writeIEEE754 = function(buffer, value, offset, endian, mLen, nBytes) {
+ var e, m, c,
+ bBE = (endian === 'big'),
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+ i = bBE ? (nBytes-1) : 0,
+ d = bBE ? -1 : 1,
+ s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+ value = Math.abs(value);
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0;
+ e = eMax;
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2);
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--;
+ c *= 2;
+ }
+ if (e+eBias >= 1) {
+ value += rt / c;
+ } else {
+ value += rt * Math.pow(2, 1 - eBias);
+ }
+ if (value * c >= 2) {
+ e++;
+ c /= 2;
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0;
+ e = eMax;
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * Math.pow(2, mLen);
+ e = e + eBias;
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+ e = 0;
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
+
+ e = (e << mLen) | m;
+ eLen += mLen;
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
+
+ buffer[offset + i - d] |= s * 128;
+};
791 lib/extern/long.js
@@ -0,0 +1,791 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Copyright 2009 Google Inc. All Rights Reserved
+
+/**
+ * @fileoverview Defines a exports.Long class for representing a 64-bit two's-complement
+ * integer value, which faithfully simulates the behavior of a Java "long". This
+ * implementation is derived from exports.LongLib in GWT.
+ *
+ */
+
+/**
+ * Constructs a 64-bit two's-complement integer, given its low and high 32-bit
+ * values as *signed* integers. See the from* functions below for more
+ * convenient ways of constructing exports.Longs.
+ *
+ * The internal representation of a long is the two given signed, 32-bit values.
+ * We use 32-bit pieces because these are the size of integers on which
+ * Javascript performs bit-operations. For operations like addition and
+ * multiplication, we split each number into 16-bit pieces, which can easily be
+ * multiplied within Javascript's floating-point representation without overflow
+ * or change in sign.
+ *
+ * In the algorithms below, we frequently reduce the negative case to the
+ * positive case by negating the input(s) and then post-processing the result.
+ * Note that we must ALWAYS check specially whether those values are MIN_VALUE
+ * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
+ * a positive number, it overflows back into a negative). Not handling this
+ * case would often result in infinite recursion.
+ *
+ * @param {number} low The low (signed) 32 bits of the long.
+ * @param {number} high The high (signed) 32 bits of the long.
+ * @constructor
+ */
+exports.Long = function(low, high) {
+ /**
+ * @type {number}
+ * @private
+ */
+ this.low_ = low | 0; // force into 32 signed bits.
+
+ /**
+ * @type {number}
+ * @private
+ */
+ this.high_ = high | 0; // force into 32 signed bits.
+};
+
+
+// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
+// from* methods on which they depend.
+
+
+/**
+ * A cache of the exports.Long representations of small integer values.
+ * @type {Object}
+ * @private
+ */
+exports.Long.INT_CACHE_ = {};
+
+
+/**
+ * Returns a exports.Long representing the given (32-bit) integer value.
+ * @param {number} value The 32-bit integer in question.
+ * @return {exports.Long} The corresponding exports.Long value.
+ */
+exports.Long.fromInt = function(value) {
+ if (-128 <= value && value < 128) {
+ var cachedObj = exports.Long.INT_CACHE_[value];
+ if (cachedObj) {
+ return cachedObj;
+ }
+ }
+
+ var obj = new exports.Long(value | 0, value < 0 ? -1 : 0);
+ if (-128 <= value && value < 128) {
+ exports.Long.INT_CACHE_[value] = obj;
+ }
+ return obj;
+};
+
+
+/**
+ * Returns a exports.Long representing the given value, provided that it is a finite
+ * number. Otherwise, zero is returned.
+ * @param {number} value The number in question.
+ * @return {exports.Long} The corresponding exports.Long value.
+ */
+exports.Long.fromNumber = function(value) {
+ if (isNaN(value) || !isFinite(value)) {
+ return exports.Long.ZERO;
+ } else if (value <= -exports.Long.TWO_PWR_63_DBL_) {
+ return exports.Long.MIN_VALUE;
+ } else if (value + 1 >= exports.Long.TWO_PWR_63_DBL_) {
+ return exports.Long.MAX_VALUE;
+ } else if (value < 0) {
+ return exports.Long.fromNumber(-value).negate();
+ } else {
+ return new exports.Long(
+ (value % exports.Long.TWO_PWR_32_DBL_) | 0,
+ (value / exports.Long.TWO_PWR_32_DBL_) | 0);
+ }
+};
+
+
+/**
+ * Returns a exports.Long representing the 64-bit integer that comes by concatenating
+ * the given high and low bits. Each is assumed to use 32 bits.
+ * @param {number} lowBits The low 32-bits.
+ * @param {number} highBits The high 32-bits.
+ * @return {exports.Long} The corresponding exports.Long value.
+ */
+exports.Long.fromBits = function(lowBits, highBits) {
+ return new exports.Long(lowBits, highBits);
+};
+
+
+/**
+ * Returns a exports.Long representation of the given string, written using the given
+ * radix.
+ * @param {string} str The textual representation of the exports.Long.
+ * @param {number} opt_radix The radix in which the text is written.
+ * @return {exports.Long} The corresponding exports.Long value.
+ */
+exports.Long.fromString = function(str, opt_radix) {
+ if (str.length == 0) {
+ throw Error('number format error: empty string');
+ }
+
+ var radix = opt_radix || 10;
+ if (radix < 2 || 36 < radix) {
+ throw Error('radix out of range: ' + radix);
+ }
+
+ if (str.charAt(0) == '-') {
+ return exports.Long.fromString(str.substring(1), radix).negate();
+ } else if (str.indexOf('-') >= 0) {
+ throw Error('number format error: interior "-" character: ' + str);
+ }
+
+ // Do several (8) digits each time through the loop, so as to
+ // minimize the calls to the very expensive emulated div.
+ var radixToPower = exports.Long.fromNumber(Math.pow(radix, 8));
+
+ var result = exports.Long.ZERO;
+ for (var i = 0; i < str.length; i += 8) {
+ var size = Math.min(8, str.length - i);
+ var value = parseInt(str.substring(i, i + size), radix);
+ if (size < 8) {
+ var power = exports.Long.fromNumber(Math.pow(radix, size));
+ result = result.multiply(power).add(exports.Long.fromNumber(value));
+ } else {
+ result = result.multiply(radixToPower);
+ result = result.add(exports.Long.fromNumber(value));
+ }
+ }
+ return result;
+};
+
+
+// NOTE: the compiler should inline these constant values below and then remove
+// these variables, so there should be no runtime penalty for these.
+
+
+/**
+ * Number used repeated below in calculations. This must appear before the
+ * first call to any from* function below.
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_16_DBL_ = 1 << 16;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_24_DBL_ = 1 << 24;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_32_DBL_ =
+ exports.Long.TWO_PWR_16_DBL_ * exports.Long.TWO_PWR_16_DBL_;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_31_DBL_ =
+ exports.Long.TWO_PWR_32_DBL_ / 2;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_48_DBL_ =
+ exports.Long.TWO_PWR_32_DBL_ * exports.Long.TWO_PWR_16_DBL_;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_64_DBL_ =
+ exports.Long.TWO_PWR_32_DBL_ * exports.Long.TWO_PWR_32_DBL_;
+
+/**
+ * @type {number}
+ * @private
+ */
+exports.Long.TWO_PWR_63_DBL_ =
+ exports.Long.TWO_PWR_64_DBL_ / 2;
+
+
+/** @type {exports.Long} */
+exports.Long.ZERO = exports.Long.fromInt(0);
+
+/** @type {exports.Long} */
+exports.Long.ONE = exports.Long.fromInt(1);
+
+/** @type {exports.Long} */
+exports.Long.NEG_ONE = exports.Long.fromInt(-1);
+
+/** @type {exports.Long} */
+exports.Long.MAX_VALUE =
+ exports.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
+
+/** @type {exports.Long} */
+exports.Long.MIN_VALUE = exports.Long.fromBits(0, 0x80000000 | 0);
+
+
+/**
+ * @type {exports.Long}
+ * @private
+ */
+exports.Long.TWO_PWR_24_ = exports.Long.fromInt(1 << 24);
+
+
+/** @return {number} The value, assuming it is a 32-bit integer. */
+exports.Long.prototype.toInt = function() {
+ return this.low_;
+};
+
+
+/** @return {number} The closest floating-point representation to this value. */
+exports.Long.prototype.toNumber = function() {
+ return this.high_ * exports.Long.TWO_PWR_32_DBL_ +
+ this.getLowBitsUnsigned();
+};
+
+/** convert code to JSON **/
+exports.Long.prototype.toJSON = function() {
+ return this.toString();
+}
+
+/**
+ * @param {number} opt_radix The radix in which the text should be written.
+ * @return {string} The textual representation of this value.
+ */
+exports.Long.prototype.toString = function(opt_radix) {
+ var radix = opt_radix || 10;
+ if (radix < 2 || 36 < radix) {
+ throw Error('radix out of range: ' + radix);
+ }
+
+ if (this.isZero()) {
+ return '0';
+ }
+
+ if (this.isNegative()) {
+ if (this.equals(exports.Long.MIN_VALUE)) {
+ // We need to change the exports.Long value before it can be negated, so we remove
+ // the bottom-most digit in this base and then recurse to do the rest.
+ var radixLong = exports.Long.fromNumber(radix);
+ var div = this.div(radixLong);
+ var rem = div.multiply(radixLong).subtract(this);
+ return div.toString(radix) + rem.toInt().toString(radix);
+ } else {
+ return '-' + this.negate().toString(radix);
+ }
+ }
+
+ // Do several (6) digits each time through the loop, so as to
+ // minimize the calls to the very expensive emulated div.
+ var radixToPower = exports.Long.fromNumber(Math.pow(radix, 6));
+
+ var rem = this;
+ var result = '';
+ while (true) {
+ var remDiv = rem.div(radixToPower);
+ var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
+ var digits = intval.toString(radix);
+
+ rem = remDiv;
+ if (rem.isZero()) {
+ return digits + result;
+ } else {
+ while (digits.length < 6) {
+ digits = '0' + digits;
+ }
+ result = '' + digits + result;
+ }
+ }
+};
+
+
+/** @return {number} The high 32-bits as a signed value. */
+exports.Long.prototype.getHighBits = function() {
+ return this.high_;
+};
+
+
+/** @return {number} The low 32-bits as a signed value. */
+exports.Long.prototype.getLowBits = function() {
+ return this.low_;
+};
+
+
+/** @return {number} The low 32-bits as an unsigned value. */
+exports.Long.prototype.getLowBitsUnsigned = function() {
+ return (this.low_ >= 0) ?
+ this.low_ : exports.Long.TWO_PWR_32_DBL_ + this.low_;
+};
+
+
+/**
+ * @return {number} Returns the number of bits needed to represent the absolute
+ * value of this exports.Long.
+ */
+exports.Long.prototype.getNumBitsAbs = function() {
+ if (this.isNegative()) {
+ if (this.equals(exports.Long.MIN_VALUE)) {
+ return 64;
+ } else {
+ return this.negate().getNumBitsAbs();
+ }
+ } else {
+ var val = this.high_ != 0 ? this.high_ : this.low_;
+ for (var bit = 31; bit > 0; bit--) {
+ if ((val & (1 << bit)) != 0) {
+ break;
+ }
+ }
+ return this.high_ != 0 ? bit + 33 : bit + 1;
+ }
+};
+
+
+/** @return {boolean} Whether this value is zero. */
+exports.Long.prototype.isZero = function() {
+ return this.high_ == 0 && this.low_ == 0;
+};
+
+
+/** @return {boolean} Whether this value is negative. */
+exports.Long.prototype.isNegative = function() {
+ return this.high_ < 0;
+};
+
+
+/** @return {boolean} Whether this value is odd. */
+exports.Long.prototype.isOdd = function() {
+ return (this.low_ & 1) == 1;
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long equals the other.
+ */
+exports.Long.prototype.equals = function(other) {
+ return (this.high_ == other.high_) && (this.low_ == other.low_);
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long does not equal the other.
+ */
+exports.Long.prototype.notEquals = function(other) {
+ return (this.high_ != other.high_) || (this.low_ != other.low_);
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long is less than the other.
+ */
+exports.Long.prototype.lessThan = function(other) {
+ return this.compare(other) < 0;
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long is less than or equal to the other.
+ */
+exports.Long.prototype.lessThanOrEqual = function(other) {
+ return this.compare(other) <= 0;
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long is greater than the other.
+ */
+exports.Long.prototype.greaterThan = function(other) {
+ return this.compare(other) > 0;
+};
+
+
+/**
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {boolean} Whether this exports.Long is greater than or equal to the other.
+ */
+exports.Long.prototype.greaterThanOrEqual = function(other) {
+ return this.compare(other) >= 0;
+};
+
+
+/**
+ * Compares this exports.Long with the given one.
+ * @param {exports.Long} other exports.Long to compare against.
+ * @return {number} 0 if they are the same, 1 if the this is greater, and -1
+ * if the given one is greater.
+ */
+exports.Long.prototype.compare = function(other) {
+ if (this.equals(other)) {
+ return 0;
+ }
+
+ var thisNeg = this.isNegative();
+ var otherNeg = other.isNegative();
+ if (thisNeg && !otherNeg) {
+ return -1;
+ }
+ if (!thisNeg && otherNeg) {
+ return 1;
+ }
+
+ // at this point, the signs are the same, so subtraction will not overflow
+ if (this.subtract(other).isNegative()) {
+ return -1;
+ } else {
+ return 1;
+ }
+};
+
+
+/** @return {exports.Long} The negation of this value. */
+exports.Long.prototype.negate = function() {
+ if (this.equals(exports.Long.MIN_VALUE)) {
+ return exports.Long.MIN_VALUE;
+ } else {
+ return this.not().add(exports.Long.ONE);
+ }
+};
+
+
+/**
+ * Returns the sum of this and the given exports.Long.
+ * @param {exports.Long} other exports.Long to add to this one.
+ * @return {exports.Long} The sum of this and the given exports.Long.
+ */
+exports.Long.prototype.add = function(other) {
+ // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
+
+ var a48 = this.high_ >>> 16;
+ var a32 = this.high_ & 0xFFFF;
+ var a16 = this.low_ >>> 16;
+ var a00 = this.low_ & 0xFFFF;
+
+ var b48 = other.high_ >>> 16;
+ var b32 = other.high_ & 0xFFFF;
+ var b16 = other.low_ >>> 16;
+ var b00 = other.low_ & 0xFFFF;
+
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 + b00;
+ c16 += c00 >>> 16;
+ c00 &= 0xFFFF;
+ c16 += a16 + b16;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c32 += a32 + b32;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c48 += a48 + b48;
+ c48 &= 0xFFFF;
+ return exports.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+};
+
+
+/**
+ * Returns the difference of this and the given exports.Long.
+ * @param {exports.Long} other exports.Long to subtract from this.
+ * @return {exports.Long} The difference of this and the given exports.Long.
+ */
+exports.Long.prototype.subtract = function(other) {
+ return this.add(other.negate());
+};
+
+
+/**
+ * Returns the product of this and the given long.
+ * @param {exports.Long} other exports.Long to multiply with this.
+ * @return {exports.Long} The product of this and the other.
+ */
+exports.Long.prototype.multiply = function(other) {
+ if (this.isZero()) {
+ return exports.Long.ZERO;
+ } else if (other.isZero()) {
+ return exports.Long.ZERO;
+ }
+
+ if (this.equals(exports.Long.MIN_VALUE)) {
+ return other.isOdd() ? exports.Long.MIN_VALUE : exports.Long.ZERO;
+ } else if (other.equals(exports.Long.MIN_VALUE)) {
+ return this.isOdd() ? exports.Long.MIN_VALUE : exports.Long.ZERO;
+ }
+
+ if (this.isNegative()) {
+ if (other.isNegative()) {
+ return this.negate().multiply(other.negate());
+ } else {
+ return this.negate().multiply(other).negate();
+ }
+ } else if (other.isNegative()) {
+ return this.multiply(other.negate()).negate();
+ }
+
+ // If both longs are small, use float multiplication
+ if (this.lessThan(exports.Long.TWO_PWR_24_) &&
+ other.lessThan(exports.Long.TWO_PWR_24_)) {
+ return exports.Long.fromNumber(this.toNumber() * other.toNumber());
+ }
+
+ // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
+ // We can skip products that would overflow.
+
+ var a48 = this.high_ >>> 16;
+ var a32 = this.high_ & 0xFFFF;
+ var a16 = this.low_ >>> 16;
+ var a00 = this.low_ & 0xFFFF;
+
+ var b48 = other.high_ >>> 16;
+ var b32 = other.high_ & 0xFFFF;
+ var b16 = other.low_ >>> 16;
+ var b00 = other.low_ & 0xFFFF;
+
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 * b00;
+ c16 += c00 >>> 16;
+ c00 &= 0xFFFF;
+ c16 += a16 * b00;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c16 += a00 * b16;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c32 += a32 * b00;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c32 += a16 * b16;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c32 += a00 * b32;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+ c48 &= 0xFFFF;
+ return exports.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+};
+
+
+/**
+ * Returns this exports.Long divided by the given one.
+ * @param {exports.Long} other exports.Long by which to divide.
+ * @return {exports.Long} This exports.Long divided by the given one.
+ */
+exports.Long.prototype.div = function(other) {
+ if (other.isZero()) {
+ throw Error('division by zero');
+ } else if (this.isZero()) {
+ return exports.Long.ZERO;
+ }
+
+ if (this.equals(exports.Long.MIN_VALUE)) {
+ if (other.equals(exports.Long.ONE) ||
+ other.equals(exports.Long.NEG_ONE)) {
+ return exports.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
+ } else if (other.equals(exports.Long.MIN_VALUE)) {
+ return exports.Long.ONE;
+ } else {
+ // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
+ var halfThis = this.shiftRight(1);
+ var approx = halfThis.div(other).shiftLeft(1);
+ if (approx.equals(exports.Long.ZERO)) {
+ return other.isNegative() ? exports.Long.ONE : exports.Long.NEG_ONE;
+ } else {
+ var rem = this.subtract(other.multiply(approx));
+ var result = approx.add(rem.div(other));
+ return result;
+ }
+ }
+ } else if (other.equals(exports.Long.MIN_VALUE)) {
+ return exports.Long.ZERO;
+ }
+
+ if (this.isNegative()) {
+ if (other.isNegative()) {
+ return this.negate().div(other.negate());
+ } else {
+ return this.negate().div(other).negate();
+ }
+ } else if (other.isNegative()) {
+ return this.div(other.negate()).negate();
+ }
+
+ // Repeat the following until the remainder is less than other: find a
+ // floating-point that approximates remainder / other *from below*, add this
+ // into the result, and subtract it from the remainder. It is critical that
+ // the approximate value is less than or equal to the real value so that the
+ // remainder never becomes negative.
+ var res = exports.Long.ZERO;
+ var rem = this;
+ while (rem.greaterThanOrEqual(other)) {
+ // Approximate the result of division. This may be a little greater or
+ // smaller than the actual value.
+ var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
+
+ // We will tweak the approximate result by changing it in the 48-th digit or
+ // the smallest non-fractional digit, whichever is larger.
+ var log2 = Math.ceil(Math.log(approx) / Math.LN2);
+ var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
+
+ // Decrease the approximation until it is smaller than the remainder. Note
+ // that if it is too large, the product overflows and is negative.
+ var approxRes = exports.Long.fromNumber(approx);
+ var approxRem = approxRes.multiply(other);
+ while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
+ approx -= delta;
+ approxRes = exports.Long.fromNumber(approx);
+ approxRem = approxRes.multiply(other);
+ }
+
+ // We know the answer can't be zero... and actually, zero would cause
+ // infinite recursion since we would make no progress.
+ if (approxRes.isZero()) {
+ approxRes = exports.Long.ONE;
+ }
+
+ res = res.add(approxRes);
+ rem = rem.subtract(approxRem);
+ }
+ return res;
+};
+
+
+/**
+ * Returns this exports.Long modulo the given one.
+ * @param {exports.Long} other exports.Long by which to mod.
+ * @return {exports.Long} This exports.Long modulo the given one.
+ */
+exports.Long.prototype.modulo = function(other) {
+ return this.subtract(this.div(other).multiply(other));
+};
+
+
+/** @return {exports.Long} The bitwise-NOT of this value. */
+exports.Long.prototype.not = function() {
+ return exports.Long.fromBits(~this.low_, ~this.high_);
+};
+
+
+/**
+ * Returns the bitwise-AND of this exports.Long and the given one.
+ * @param {exports.Long} other The exports.Long with which to AND.
+ * @return {exports.Long} The bitwise-AND of this and the other.
+ */
+exports.Long.prototype.and = function(other) {
+ return exports.Long.fromBits(this.low_ & other.low_,
+ this.high_ & other.high_);
+};
+
+
+/**
+ * Returns the bitwise-OR of this exports.Long and the given one.
+ * @param {exports.Long} other The exports.Long with which to OR.
+ * @return {exports.Long} The bitwise-OR of this and the other.
+ */
+exports.Long.prototype.or = function(other) {
+ return exports.Long.fromBits(this.low_ | other.low_,
+ this.high_ | other.high_);
+};
+
+
+/**
+ * Returns the bitwise-XOR of this exports.Long and the given one.
+ * @param {exports.Long} other The exports.Long with which to XOR.
+ * @return {exports.Long} The bitwise-XOR of this and the other.
+ */
+exports.Long.prototype.xor = function(other) {
+ return exports.Long.fromBits(this.low_ ^ other.low_,
+ this.high_ ^ other.high_);
+};
+
+
+/**
+ * Returns this exports.Long with bits shifted to the left by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {exports.Long} This shifted to the left by the given amount.
+ */
+exports.Long.prototype.shiftLeft = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var low = this.low_;
+ if (numBits < 32) {
+ var high = this.high_;
+ return exports.Long.fromBits(
+ low << numBits,
+ (high << numBits) | (low >>> (32 - numBits)));
+ } else {
+ return exports.Long.fromBits(0, low << (numBits - 32));
+ }
+ }
+};
+
+
+/**
+ * Returns this exports.Long with bits shifted to the right by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {exports.Long} This shifted to the right by the given amount.
+ */
+exports.Long.prototype.shiftRight = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var high = this.high_;
+ if (numBits < 32) {
+ var low = this.low_;
+ return exports.Long.fromBits(
+ (low >>> numBits) | (high << (32 - numBits)),
+ high >> numBits);
+ } else {
+ return exports.Long.fromBits(
+ high >> (numBits - 32),
+ high >= 0 ? 0 : -1);
+ }
+ }
+};
+
+
+/**
+ * Returns this exports.Long with bits shifted to the right by the given amount, with
+ * the new top bits matching the current sign bit.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {exports.Long} This shifted to the right by the given amount, with
+ * zeros placed into the new leading bits.
+ */
+exports.Long.prototype.shiftRightUnsigned = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var high = this.high_;
+ if (numBits < 32) {
+ var low = this.low_;
+ return exports.Long.fromBits(
+ (low >>> numBits) | (high << (32 - numBits)),
+ high >>> numBits);
+ } else if (numBits == 32) {
+ return exports.Long.fromBits(high, 0);
+ } else {
+ return exports.Long.fromBits(high >>> (numBits - 32), 0);
+ }
+ }
+};
22 package.json
@@ -0,0 +1,22 @@
+{
+ "name": "buffalo",
+ "description": "Buffalo is a lightweight BSON library for Node.js",
+ "version": "0.1.0-unstable",
+ "homepage": "https://github.com/marcello3d/node-buffalo",
+ "repository": "git://github.com/marcello3d/node-buffalo.git",
+ "author": "Marcello Bastéa-Forte <marcello@cellosoft.com> (http://marcello.cellosoft.com/)",
+ "main": "buffalo.js",
+ "keywords": ["mongo", "mongodb", "bson", "binary", "binary json"],
+ "dependencies": {
+ "tosource": "0.1.1"
+ },
+ "devDependencies": {
+ "vows": "~0.5"
+ },
+ "scripts": {
+ "test": "node_modules/.bin/vows --spec"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ }
+}
220 test/bson-test.js
@@ -0,0 +1,220 @@
+/* Mongolian DeadBeef by Marcello Bastea-Forte - zlib license */
+
+var vows = require('vows'),
+ assert = require('assert'),
+ BSON = require('../lib/bson.js'),
+ Long = BSON.Long
+
+function C(character) {
+ return character.charCodeAt(0)
+}
+
+
+var bsonSample1 = [
+ 0x16, 0x00, 0x00, 0x00,
+ 0x02,
+ C('h'), C('e'), C('l'), C('l'), C('o'), 0x00,
+ 0x06, 0x00, 0x00, 0x00, C('w'), C('o'), C('r'), C('l'), C('d'), 0x00,
+ 0x00]
+
+var bsonSample1Expected = {"hello": "world"}
+
+var bsonSample2 = [
+ 0x31, 0x00, 0x00, 0x00,
+ 0x04, C('B'), C('S'), C('O'), C('N'), 0x00,
+ 0x26, 0x00, 0x00, 0x00,
+ 0x02, C('0'), 0x00,
+ 0x08, 0x00, 0x00, 0x00, C('a'), C('w'), C('e'), C('s'), C('o'), C('m'), C('e'), 0x00,
+ 0x01, C('1'), 0x00,
+ 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x14, 0x40,
+ 0x10, C('2'), 0x00,
+ 0xc2, 0x07, 0x00, 0x00,
+ 0x00,
+ 0x00]
+
+var bsonSample2Expected = {"BSON": ["awesome", 5.05, 1986]}
+
+
+function testBackAndForth(originalObject) {
+ return {
+ topic: BSON.serialize(originalObject),
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "matches original": function(object) {
+ assert.deepEqual(object, originalObject)
+ }
+ }
+ }
+}
+
+vows.describe('BSON').addBatch({
+ "sample BSON 1": {
+ topic: BSON.parse(new Buffer(bsonSample1)),
+ "parses to {\"hello\": \"world\"}": function (object) {
+ assert.deepEqual(object, bsonSample1Expected)
+ }
+ },
+ "sample BSON 2": {
+ topic: BSON.parse(new Buffer(bsonSample2)),
+ "parses to {\"BSON\": [\"awesome\", 5.05, 1986]}": function (object) {
+ assert.deepEqual(object, bsonSample2Expected)
+ }
+ },
+ "javascript object {\"hello\": \"world\"}": {
+ topic: BSON.serialize(bsonSample1Expected),
+ "serializes correctly": function(object) {
+ assert.equal(object.toString('base64'), new Buffer(bsonSample1).toString('base64'))
+ }
+ },
+ "javascript object {\"BSON\": [\"awesome\", 5.05, 1986]}": {
+ topic: BSON.serialize(bsonSample2Expected),
+ "serializes correctly": function(object) {
+ assert.equal(object.toString('base64'), new Buffer(bsonSample2).toString('base64'))
+ }
+ },
+ "after serializing []": testBackAndForth([]),
+ "after serializing [1,2,3]": testBackAndForth([1,2,3]),
+ "after serializing ['a','b','c']": testBackAndForth(['a','b','c']),
+ "after serializing ['short','longer','even longer... Hamburger swine boudin bresaola, tongue meatball biltong rump. Strip steak pig venison tongue. Tenderloin bresaola brisket jowl ham, flank shankle drumstick tongue hamburger swine. Pastrami hamburger boudin beef ribs, sirloin jerky sausage tail bresaola strip steak pork loin corned beef. Turkey jerky jowl sirloin. Chuck pig hamburger fatback. Corned beef beef brisket swine short ribs shoulder.']": testBackAndForth(['short','longer','even longer... Hamburger swine boudin bresaola, tongue meatball biltong rump. Strip steak pig venison tongue. Tenderloin bresaola brisket jowl ham, flank shankle drumstick tongue hamburger swine. Pastrami hamburger boudin beef ribs, sirloin jerky sausage tail bresaola strip steak pork loin corned beef. Turkey jerky jowl sirloin. Chuck pig hamburger fatback. Corned beef beef brisket swine short ribs shoulder.']),
+ "after serializing [new Date]": testBackAndForth([new Date]),
+ "after serializing {}": testBackAndForth({}),
+ "after serializing {'hello':'there'}": testBackAndForth({'hello':'there'}),
+ "after serializing {level1:{level2:{level3:{level4:{level5:{level6:{level7:'tada!'}}}}}}}": testBackAndForth({level1:{level2:{level3:{level4:{level5:{level6:{level7:'tada!'}}}}}}}),
+ "after serializing [1.500343]": testBackAndForth([1.500343]),
+ "after serializing [-1.500343]": testBackAndForth([-1.500343]),
+ "after serializing [1<<20]": testBackAndForth([1<<20]),
+ "after serializing [1<<28]": testBackAndForth([1<<28]),
+ "after serializing [1<<31]": testBackAndForth([1<<31]),
+ "after serializing [1<<35]": testBackAndForth([1<<35]),
+ "after serializing [1<<40]": testBackAndForth([1<<40]),
+ "after serializing [1<<60]": testBackAndForth([1<<60]),
+ "after serializing [true]": testBackAndForth([true]),
+ "after serializing [false]": testBackAndForth([false]),
+ "after serializing [true,false,true,false,0,1]": testBackAndForth([true,false,true,false,0,1]),
+ "after serializing [null]": testBackAndForth([null]),
+ "after serializing [undefined]": testBackAndForth([undefined]),
+ "after serializing [1234567890]": testBackAndForth([1234567890]),
+ "after serializing [1234567890123456]": testBackAndForth([1234567890123456]),
+ "after serializing [12345678901234567890]": testBackAndForth([12345678901234567890]),
+ "after serializing [123456789012345678901234567890]": testBackAndForth([123456789012345678901234567890]),
+ "after serializing [1234567890123456.78901234567890]": testBackAndForth([1234567890123456.78901234567890]),
+ "after serializing [new Long(100,100)]": testBackAndForth([new Long(100,100)]),
+ "after serializing [-1234567890]": testBackAndForth([-1234567890]),
+ "after serializing [-1234567890123456]": testBackAndForth([-1234567890123456]),
+ "after serializing [-12345678901234567890]": testBackAndForth([-12345678901234567890]),
+ "after serializing [-123456789012345678901234567890]": testBackAndForth([-123456789012345678901234567890]),
+ "after serializing [-1234567890123456.78901234567890]": testBackAndForth([-1234567890123456.78901234567890]),
+ "after serializing [new Buffer(\"hello\", \"utf8\")]": testBackAndForth([new Buffer("hello", "utf8")]),
+ "after serializing [/hello/i]": {
+ topic: BSON.serialize([/hello/i]),
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "is regexp": function(object) {
+ assert.instanceOf(object[0], RegExp)
+ },
+ "regexp matches original": function(object) {
+ // Using equal with two regexps doesn't work
+ assert.equal(object[0].toString(), "/hello/i")
+ }
+ }
+ },
+ "after serializing [/hello[.]+/i]": {
+ topic: BSON.serialize([/hello[.]+/i]),
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "is regexp": function(object) {
+ assert.instanceOf(object[0], RegExp)
+ },
+ "regexp matches original": function(object) {
+ assert.equal(object[0].toString(), "/hello[.]+/i")
+ }
+ }
+ },
+ "after serializing [function(){}]": {
+ topic: BSON.serialize([function(){}]),
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "is function": function(object) {
+ assert.isFunction(object[0])
+ },
+ "function matches original": function(object) {
+ // We need a fuzzy match, since serializing jumbles the function slightly
+ assert.matches(object[0].toString().replace(/[\s\n]+/g,''),
+ /^function[^\(]*\(\){}/)
+ }
+ }
+ },
+ "after serializing [function(x,y){ return x + y }]": {
+ topic: BSON.serialize([function(x,y){
+ return x + y
+ }]),
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "is function": function(object) {
+ assert.isFunction(object[0])
+ },
+ "function matches original": function(object) {
+ assert.matches(object[0].toString().replace(/[\s\n]+/g,''),
+ /function[^(]*\(x,y\)\{returnx\+y\}/)
+ },
+ "function evaluation with arguments (4,5) returns 9": function(object) {
+ assert.equal(object[0](4,5), 9)
+ }
+ }
+ },
+ "after serializing scoped function(){ return x + y } (with x=4, y=5)": {
+ topic: function() {
+ var func = function() {
+ return x + y
+ }
+ func.scope = {
+ x:4,
+ y:5
+ }
+ return BSON.serialize([func])
+ },
+ "has length": function(bson) {
+ assert.isNotZero(bson.length)
+ },
+ "when reparsed,": {
+ topic: function(object) {
+ return BSON.parse(object)
+ },
+ "is function": function(object) {
+ assert.isFunction(object[0])
+ },
+ "function matches original": function(object) {
+ assert.matches(object[0].toString().replace(/[\s\n]+/g,''),
+ /function[^(]*\(\)\{with\({x:4,y:5}\){returnx\+y\}}/)
+ },
+ "function evaluation returns 9": function(object) {
+ assert.equal(object[0](), 9)
+ }
+ }
+ }
+}).export(module)

0 comments on commit bbc1ca0

Please sign in to comment.