mirror of
https://github.com/samuelclay/NewsBlur.git
synced 2025-08-05 16:58:59 +00:00
4843 lines
153 KiB
JavaScript
4843 lines
153 KiB
JavaScript
var bson = (function(){
|
|
|
|
var pkgmap = {},
|
|
global = {},
|
|
nativeRequire = typeof require != 'undefined' && require,
|
|
lib, ties, main, async;
|
|
|
|
function exports(){ return main(); };
|
|
|
|
exports.main = exports;
|
|
exports.module = module;
|
|
exports.packages = pkgmap;
|
|
exports.pkg = pkg;
|
|
exports.require = function require(uri){
|
|
return pkgmap.main.index.require(uri);
|
|
};
|
|
|
|
|
|
ties = {};
|
|
|
|
aliases = {};
|
|
|
|
|
|
return exports;
|
|
|
|
function join() {
|
|
return normalize(Array.prototype.join.call(arguments, "/"));
|
|
};
|
|
|
|
function normalize(path) {
|
|
var ret = [], parts = path.split('/'), cur, prev;
|
|
|
|
var i = 0, l = parts.length-1;
|
|
for (; i <= l; i++) {
|
|
cur = parts[i];
|
|
|
|
if (cur === "." && prev !== undefined) continue;
|
|
|
|
if (cur === ".." && ret.length && prev !== ".." && prev !== "." && prev !== undefined) {
|
|
ret.pop();
|
|
prev = ret.slice(-1)[0];
|
|
} else {
|
|
if (prev === ".") ret.pop();
|
|
ret.push(cur);
|
|
prev = cur;
|
|
}
|
|
}
|
|
|
|
return ret.join("/");
|
|
};
|
|
|
|
function dirname(path) {
|
|
return path && path.substr(0, path.lastIndexOf("/")) || ".";
|
|
};
|
|
|
|
function findModule(workingModule, uri){
|
|
var moduleId = join(dirname(workingModule.id), /\.\/$/.test(uri) ? (uri + 'index') : uri ).replace(/\.js$/, ''),
|
|
moduleIndexId = join(moduleId, 'index'),
|
|
pkg = workingModule.pkg,
|
|
module;
|
|
|
|
var i = pkg.modules.length,
|
|
id;
|
|
|
|
while(i-->0){
|
|
id = pkg.modules[i].id;
|
|
|
|
if(id==moduleId || id == moduleIndexId){
|
|
module = pkg.modules[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
return module;
|
|
}
|
|
|
|
function newRequire(callingModule){
|
|
function require(uri){
|
|
var module, pkg;
|
|
|
|
if(/^\./.test(uri)){
|
|
module = findModule(callingModule, uri);
|
|
} else if ( ties && ties.hasOwnProperty( uri ) ) {
|
|
return ties[uri];
|
|
} else if ( aliases && aliases.hasOwnProperty( uri ) ) {
|
|
return require(aliases[uri]);
|
|
} else {
|
|
pkg = pkgmap[uri];
|
|
|
|
if(!pkg && nativeRequire){
|
|
try {
|
|
pkg = nativeRequire(uri);
|
|
} catch (nativeRequireError) {}
|
|
|
|
if(pkg) return pkg;
|
|
}
|
|
|
|
if(!pkg){
|
|
throw new Error('Cannot find module "'+uri+'" @[module: '+callingModule.id+' package: '+callingModule.pkg.name+']');
|
|
}
|
|
|
|
module = pkg.index;
|
|
}
|
|
|
|
if(!module){
|
|
throw new Error('Cannot find module "'+uri+'" @[module: '+callingModule.id+' package: '+callingModule.pkg.name+']');
|
|
}
|
|
|
|
module.parent = callingModule;
|
|
return module.call();
|
|
};
|
|
|
|
|
|
return require;
|
|
}
|
|
|
|
|
|
function module(parent, id, wrapper){
|
|
var mod = { pkg: parent, id: id, wrapper: wrapper },
|
|
cached = false;
|
|
|
|
mod.exports = {};
|
|
mod.require = newRequire(mod);
|
|
|
|
mod.call = function(){
|
|
if(cached) {
|
|
return mod.exports;
|
|
}
|
|
|
|
cached = true;
|
|
|
|
global.require = mod.require;
|
|
|
|
mod.wrapper(mod, mod.exports, global, global.require);
|
|
return mod.exports;
|
|
};
|
|
|
|
if(parent.mainModuleId == mod.id){
|
|
parent.index = mod;
|
|
parent.parents.length === 0 && ( main = mod.call );
|
|
}
|
|
|
|
parent.modules.push(mod);
|
|
}
|
|
|
|
function pkg(/* [ parentId ...], wrapper */){
|
|
var wrapper = arguments[ arguments.length - 1 ],
|
|
parents = Array.prototype.slice.call(arguments, 0, arguments.length - 1),
|
|
ctx = wrapper(parents);
|
|
|
|
|
|
pkgmap[ctx.name] = ctx;
|
|
|
|
arguments.length == 1 && ( pkgmap.main = ctx );
|
|
|
|
return function(modules){
|
|
var id;
|
|
for(id in modules){
|
|
module(ctx, id, modules[id]);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
}(this));
|
|
|
|
bson.pkg(function(parents){
|
|
|
|
return {
|
|
'name' : 'bson',
|
|
'mainModuleId' : 'bson',
|
|
'modules' : [],
|
|
'parents' : parents
|
|
};
|
|
|
|
})({ 'binary': function(module, exports, global, require, undefined){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
if(typeof window === 'undefined') {
|
|
var Buffer = require('buffer').Buffer; // TODO just use global Buffer
|
|
}
|
|
|
|
// Binary default subtype
|
|
var BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var writeStringToArray = function(data) {
|
|
// Create a buffer
|
|
var buffer = typeof Uint8Array != 'undefined' ? new Uint8Array(new ArrayBuffer(data.length)) : new Array(data.length);
|
|
// Write the content to the buffer
|
|
for(var i = 0; i < data.length; i++) {
|
|
buffer[i] = data.charCodeAt(i);
|
|
}
|
|
// Write the string to the buffer
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* Convert Array ot Uint8Array to Binary String
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var convertArraytoUtf8BinaryString = function(byteArray, startIndex, endIndex) {
|
|
var result = "";
|
|
for(var i = startIndex; i < endIndex; i++) {
|
|
result = result + String.fromCharCode(byteArray[i]);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* A class representation of the BSON Binary type.
|
|
*
|
|
* Sub types
|
|
* - **BSON.BSON_BINARY_SUBTYPE_DEFAULT**, default BSON type.
|
|
* - **BSON.BSON_BINARY_SUBTYPE_FUNCTION**, BSON function type.
|
|
* - **BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY**, BSON byte array type.
|
|
* - **BSON.BSON_BINARY_SUBTYPE_UUID**, BSON uuid type.
|
|
* - **BSON.BSON_BINARY_SUBTYPE_MD5**, BSON md5 type.
|
|
* - **BSON.BSON_BINARY_SUBTYPE_USER_DEFINED**, BSON user defined type.
|
|
*
|
|
* @class Represents the Binary BSON type.
|
|
* @param {Buffer} buffer a buffer object containing the binary data.
|
|
* @param {Number} [subType] the option binary type.
|
|
* @return {Grid}
|
|
*/
|
|
function Binary(buffer, subType) {
|
|
if(!(this instanceof Binary)) return new Binary(buffer, subType);
|
|
|
|
this._bsontype = 'Binary';
|
|
|
|
if(buffer instanceof Number) {
|
|
this.sub_type = buffer;
|
|
this.position = 0;
|
|
} else {
|
|
this.sub_type = subType == null ? BSON_BINARY_SUBTYPE_DEFAULT : subType;
|
|
this.position = 0;
|
|
}
|
|
|
|
if(buffer != null && !(buffer instanceof Number)) {
|
|
// Only accept Buffer, Uint8Array or Arrays
|
|
if(typeof buffer == 'string') {
|
|
// Different ways of writing the length of the string for the different types
|
|
if(typeof Buffer != 'undefined') {
|
|
this.buffer = new Buffer(buffer);
|
|
} else if(typeof Uint8Array != 'undefined' || (Object.prototype.toString.call(buffer) == '[object Array]')) {
|
|
this.buffer = writeStringToArray(buffer);
|
|
} else {
|
|
throw new Error("only String, Buffer, Uint8Array or Array accepted");
|
|
}
|
|
} else {
|
|
this.buffer = buffer;
|
|
}
|
|
this.position = buffer.length;
|
|
} else {
|
|
if(typeof Buffer != 'undefined') {
|
|
this.buffer = new Buffer(Binary.BUFFER_SIZE);
|
|
} else if(typeof Uint8Array != 'undefined'){
|
|
this.buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE));
|
|
} else {
|
|
this.buffer = new Array(Binary.BUFFER_SIZE);
|
|
}
|
|
// Set position to start of buffer
|
|
this.position = 0;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Updates this binary with byte_value.
|
|
*
|
|
* @param {Character} byte_value a single byte we wish to write.
|
|
* @api public
|
|
*/
|
|
Binary.prototype.put = function put(byte_value) {
|
|
// If it's a string and a has more than one character throw an error
|
|
if(byte_value['length'] != null && typeof byte_value != 'number' && byte_value.length != 1) throw new Error("only accepts single character String, Uint8Array or Array");
|
|
if(typeof byte_value != 'number' && byte_value < 0 || byte_value > 255) throw new Error("only accepts number in a valid unsigned byte range 0-255");
|
|
|
|
// Decode the byte value once
|
|
var decoded_byte = null;
|
|
if(typeof byte_value == 'string') {
|
|
decoded_byte = byte_value.charCodeAt(0);
|
|
} else if(byte_value['length'] != null) {
|
|
decoded_byte = byte_value[0];
|
|
} else {
|
|
decoded_byte = byte_value;
|
|
}
|
|
|
|
if(this.buffer.length > this.position) {
|
|
this.buffer[this.position++] = decoded_byte;
|
|
} else {
|
|
if(typeof Buffer != 'undefined' && Buffer.isBuffer(this.buffer)) {
|
|
// Create additional overflow buffer
|
|
var buffer = new Buffer(Binary.BUFFER_SIZE + this.buffer.length);
|
|
// Combine the two buffers together
|
|
this.buffer.copy(buffer, 0, 0, this.buffer.length);
|
|
this.buffer = buffer;
|
|
this.buffer[this.position++] = decoded_byte;
|
|
} else {
|
|
var buffer = null;
|
|
// Create a new buffer (typed or normal array)
|
|
if(Object.prototype.toString.call(this.buffer) == '[object Uint8Array]') {
|
|
buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE + this.buffer.length));
|
|
} else {
|
|
buffer = new Array(Binary.BUFFER_SIZE + this.buffer.length);
|
|
}
|
|
|
|
// We need to copy all the content to the new array
|
|
for(var i = 0; i < this.buffer.length; i++) {
|
|
buffer[i] = this.buffer[i];
|
|
}
|
|
|
|
// Reassign the buffer
|
|
this.buffer = buffer;
|
|
// Write the byte
|
|
this.buffer[this.position++] = decoded_byte;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Writes a buffer or string to the binary.
|
|
*
|
|
* @param {Buffer|String} string a string or buffer to be written to the Binary BSON object.
|
|
* @param {Number} offset specify the binary of where to write the content.
|
|
* @api public
|
|
*/
|
|
Binary.prototype.write = function write(string, offset) {
|
|
offset = typeof offset == 'number' ? offset : this.position;
|
|
|
|
// If the buffer is to small let's extend the buffer
|
|
if(this.buffer.length < offset + string.length) {
|
|
var buffer = null;
|
|
// If we are in node.js
|
|
if(typeof Buffer != 'undefined' && Buffer.isBuffer(this.buffer)) {
|
|
buffer = new Buffer(this.buffer.length + string.length);
|
|
this.buffer.copy(buffer, 0, 0, this.buffer.length);
|
|
} else if(Object.prototype.toString.call(this.buffer) == '[object Uint8Array]') {
|
|
// Create a new buffer
|
|
buffer = new Uint8Array(new ArrayBuffer(this.buffer.length + string.length))
|
|
// Copy the content
|
|
for(var i = 0; i < this.position; i++) {
|
|
buffer[i] = this.buffer[i];
|
|
}
|
|
}
|
|
|
|
// Assign the new buffer
|
|
this.buffer = buffer;
|
|
}
|
|
|
|
if(typeof Buffer != 'undefined' && Buffer.isBuffer(string) && Buffer.isBuffer(this.buffer)) {
|
|
string.copy(this.buffer, offset, 0, string.length);
|
|
this.position = (offset + string.length) > this.position ? (offset + string.length) : this.position;
|
|
// offset = string.length
|
|
} else if(typeof Buffer != 'undefined' && typeof string == 'string' && Buffer.isBuffer(this.buffer)) {
|
|
this.buffer.write(string, 'binary', offset);
|
|
this.position = (offset + string.length) > this.position ? (offset + string.length) : this.position;
|
|
// offset = string.length;
|
|
} else if(Object.prototype.toString.call(string) == '[object Uint8Array]'
|
|
|| Object.prototype.toString.call(string) == '[object Array]' && typeof string != 'string') {
|
|
for(var i = 0; i < string.length; i++) {
|
|
this.buffer[offset++] = string[i];
|
|
}
|
|
|
|
this.position = offset > this.position ? offset : this.position;
|
|
} else if(typeof string == 'string') {
|
|
for(var i = 0; i < string.length; i++) {
|
|
this.buffer[offset++] = string.charCodeAt(i);
|
|
}
|
|
|
|
this.position = offset > this.position ? offset : this.position;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Reads **length** bytes starting at **position**.
|
|
*
|
|
* @param {Number} position read from the given position in the Binary.
|
|
* @param {Number} length the number of bytes to read.
|
|
* @return {Buffer}
|
|
* @api public
|
|
*/
|
|
Binary.prototype.read = function read(position, length) {
|
|
length = length && length > 0
|
|
? length
|
|
: this.position;
|
|
|
|
// Let's return the data based on the type we have
|
|
if(this.buffer['slice']) {
|
|
return this.buffer.slice(position, position + length);
|
|
} else {
|
|
// Create a buffer to keep the result
|
|
var buffer = typeof Uint8Array != 'undefined' ? new Uint8Array(new ArrayBuffer(length)) : new Array(length);
|
|
for(var i = 0; i < length; i++) {
|
|
buffer[i] = this.buffer[position++];
|
|
}
|
|
}
|
|
// Return the buffer
|
|
return buffer;
|
|
};
|
|
|
|
/**
|
|
* Returns the value of this binary as a string.
|
|
*
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
Binary.prototype.value = function value(asRaw) {
|
|
asRaw = asRaw == null ? false : asRaw;
|
|
|
|
// If it's a node.js buffer object
|
|
if(typeof Buffer != 'undefined' && Buffer.isBuffer(this.buffer)) {
|
|
return asRaw ? this.buffer.slice(0, this.position) : this.buffer.toString('binary', 0, this.position);
|
|
} else {
|
|
if(asRaw) {
|
|
// we support the slice command use it
|
|
if(this.buffer['slice'] != null) {
|
|
return this.buffer.slice(0, this.position);
|
|
} else {
|
|
// Create a new buffer to copy content to
|
|
var newBuffer = Object.prototype.toString.call(this.buffer) == '[object Uint8Array]' ? new Uint8Array(new ArrayBuffer(this.position)) : new Array(this.position);
|
|
// Copy content
|
|
for(var i = 0; i < this.position; i++) {
|
|
newBuffer[i] = this.buffer[i];
|
|
}
|
|
// Return the buffer
|
|
return newBuffer;
|
|
}
|
|
} else {
|
|
return convertArraytoUtf8BinaryString(this.buffer, 0, this.position);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Length.
|
|
*
|
|
* @return {Number} the length of the binary.
|
|
* @api public
|
|
*/
|
|
Binary.prototype.length = function length() {
|
|
return this.position;
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Binary.prototype.toJSON = function() {
|
|
return this.buffer != null ? this.buffer.toString('base64') : '';
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Binary.prototype.toString = function(format) {
|
|
return this.buffer != null ? this.buffer.slice(0, this.position).toString(format) : '';
|
|
}
|
|
|
|
Binary.BUFFER_SIZE = 256;
|
|
|
|
/**
|
|
* Default BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_DEFAULT = 0;
|
|
/**
|
|
* Function BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_FUNCTION = 1;
|
|
/**
|
|
* Byte Array BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_BYTE_ARRAY = 2;
|
|
/**
|
|
* OLD UUID BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_UUID_OLD = 3;
|
|
/**
|
|
* UUID BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_UUID = 4;
|
|
/**
|
|
* MD5 BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_MD5 = 5;
|
|
/**
|
|
* User BSON type
|
|
*
|
|
* @classconstant SUBTYPE_DEFAULT
|
|
**/
|
|
Binary.SUBTYPE_USER_DEFINED = 128;
|
|
|
|
/**
|
|
* Expose.
|
|
*/
|
|
exports.Binary = Binary;
|
|
|
|
|
|
},
|
|
|
|
|
|
|
|
'binary_parser': function(module, exports, global, require, undefined){
|
|
/**
|
|
* Binary Parser.
|
|
* Jonas Raoni Soares Silva
|
|
* http://jsfromhell.com/classes/binary-parser [v1.0]
|
|
*/
|
|
var chr = String.fromCharCode;
|
|
|
|
var maxBits = [];
|
|
for (var i = 0; i < 64; i++) {
|
|
maxBits[i] = Math.pow(2, i);
|
|
}
|
|
|
|
function BinaryParser (bigEndian, allowExceptions) {
|
|
if(!(this instanceof BinaryParser)) return new BinaryParser(bigEndian, allowExceptions);
|
|
|
|
this.bigEndian = bigEndian;
|
|
this.allowExceptions = allowExceptions;
|
|
};
|
|
|
|
BinaryParser.warn = function warn (msg) {
|
|
if (this.allowExceptions) {
|
|
throw new Error(msg);
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
|
|
BinaryParser.decodeFloat = function decodeFloat (data, precisionBits, exponentBits) {
|
|
var b = new this.Buffer(this.bigEndian, data);
|
|
|
|
b.checkBuffer(precisionBits + exponentBits + 1);
|
|
|
|
var bias = maxBits[exponentBits - 1] - 1
|
|
, signal = b.readBits(precisionBits + exponentBits, 1)
|
|
, exponent = b.readBits(precisionBits, exponentBits)
|
|
, significand = 0
|
|
, divisor = 2
|
|
, curByte = b.buffer.length + (-precisionBits >> 3) - 1;
|
|
|
|
do {
|
|
for (var byteValue = b.buffer[ ++curByte ], startBit = precisionBits % 8 || 8, mask = 1 << startBit; mask >>= 1; ( byteValue & mask ) && ( significand += 1 / divisor ), divisor *= 2 );
|
|
} while (precisionBits -= startBit);
|
|
|
|
return exponent == ( bias << 1 ) + 1 ? significand ? NaN : signal ? -Infinity : +Infinity : ( 1 + signal * -2 ) * ( exponent || significand ? !exponent ? Math.pow( 2, -bias + 1 ) * significand : Math.pow( 2, exponent - bias ) * ( 1 + significand ) : 0 );
|
|
};
|
|
|
|
BinaryParser.decodeInt = function decodeInt (data, bits, signed, forceBigEndian) {
|
|
var b = new this.Buffer(this.bigEndian || forceBigEndian, data)
|
|
, x = b.readBits(0, bits)
|
|
, max = maxBits[bits]; //max = Math.pow( 2, bits );
|
|
|
|
return signed && x >= max / 2
|
|
? x - max
|
|
: x;
|
|
};
|
|
|
|
BinaryParser.encodeFloat = function encodeFloat (data, precisionBits, exponentBits) {
|
|
var bias = maxBits[exponentBits - 1] - 1
|
|
, minExp = -bias + 1
|
|
, maxExp = bias
|
|
, minUnnormExp = minExp - precisionBits
|
|
, n = parseFloat(data)
|
|
, status = isNaN(n) || n == -Infinity || n == +Infinity ? n : 0
|
|
, exp = 0
|
|
, len = 2 * bias + 1 + precisionBits + 3
|
|
, bin = new Array(len)
|
|
, signal = (n = status !== 0 ? 0 : n) < 0
|
|
, intPart = Math.floor(n = Math.abs(n))
|
|
, floatPart = n - intPart
|
|
, lastBit
|
|
, rounded
|
|
, result
|
|
, i
|
|
, j;
|
|
|
|
for (i = len; i; bin[--i] = 0);
|
|
|
|
for (i = bias + 2; intPart && i; bin[--i] = intPart % 2, intPart = Math.floor(intPart / 2));
|
|
|
|
for (i = bias + 1; floatPart > 0 && i; (bin[++i] = ((floatPart *= 2) >= 1) - 0 ) && --floatPart);
|
|
|
|
for (i = -1; ++i < len && !bin[i];);
|
|
|
|
if (bin[(lastBit = precisionBits - 1 + (i = (exp = bias + 1 - i) >= minExp && exp <= maxExp ? i + 1 : bias + 1 - (exp = minExp - 1))) + 1]) {
|
|
if (!(rounded = bin[lastBit])) {
|
|
for (j = lastBit + 2; !rounded && j < len; rounded = bin[j++]);
|
|
}
|
|
|
|
for (j = lastBit + 1; rounded && --j >= 0; (bin[j] = !bin[j] - 0) && (rounded = 0));
|
|
}
|
|
|
|
for (i = i - 2 < 0 ? -1 : i - 3; ++i < len && !bin[i];);
|
|
|
|
if ((exp = bias + 1 - i) >= minExp && exp <= maxExp) {
|
|
++i;
|
|
} else if (exp < minExp) {
|
|
exp != bias + 1 - len && exp < minUnnormExp && this.warn("encodeFloat::float underflow");
|
|
i = bias + 1 - (exp = minExp - 1);
|
|
}
|
|
|
|
if (intPart || status !== 0) {
|
|
this.warn(intPart ? "encodeFloat::float overflow" : "encodeFloat::" + status);
|
|
exp = maxExp + 1;
|
|
i = bias + 2;
|
|
|
|
if (status == -Infinity) {
|
|
signal = 1;
|
|
} else if (isNaN(status)) {
|
|
bin[i] = 1;
|
|
}
|
|
}
|
|
|
|
for (n = Math.abs(exp + bias), j = exponentBits + 1, result = ""; --j; result = (n % 2) + result, n = n >>= 1);
|
|
|
|
for (n = 0, j = 0, i = (result = (signal ? "1" : "0") + result + bin.slice(i, i + precisionBits).join("")).length, r = []; i; j = (j + 1) % 8) {
|
|
n += (1 << j) * result.charAt(--i);
|
|
if (j == 7) {
|
|
r[r.length] = String.fromCharCode(n);
|
|
n = 0;
|
|
}
|
|
}
|
|
|
|
r[r.length] = n
|
|
? String.fromCharCode(n)
|
|
: "";
|
|
|
|
return (this.bigEndian ? r.reverse() : r).join("");
|
|
};
|
|
|
|
BinaryParser.encodeInt = function encodeInt (data, bits, signed, forceBigEndian) {
|
|
var max = maxBits[bits];
|
|
|
|
if (data >= max || data < -(max / 2)) {
|
|
this.warn("encodeInt::overflow");
|
|
data = 0;
|
|
}
|
|
|
|
if (data < 0) {
|
|
data += max;
|
|
}
|
|
|
|
for (var r = []; data; r[r.length] = String.fromCharCode(data % 256), data = Math.floor(data / 256));
|
|
|
|
for (bits = -(-bits >> 3) - r.length; bits--; r[r.length] = "\0");
|
|
|
|
return ((this.bigEndian || forceBigEndian) ? r.reverse() : r).join("");
|
|
};
|
|
|
|
BinaryParser.toSmall = function( data ){ return this.decodeInt( data, 8, true ); };
|
|
BinaryParser.fromSmall = function( data ){ return this.encodeInt( data, 8, true ); };
|
|
BinaryParser.toByte = function( data ){ return this.decodeInt( data, 8, false ); };
|
|
BinaryParser.fromByte = function( data ){ return this.encodeInt( data, 8, false ); };
|
|
BinaryParser.toShort = function( data ){ return this.decodeInt( data, 16, true ); };
|
|
BinaryParser.fromShort = function( data ){ return this.encodeInt( data, 16, true ); };
|
|
BinaryParser.toWord = function( data ){ return this.decodeInt( data, 16, false ); };
|
|
BinaryParser.fromWord = function( data ){ return this.encodeInt( data, 16, false ); };
|
|
BinaryParser.toInt = function( data ){ return this.decodeInt( data, 32, true ); };
|
|
BinaryParser.fromInt = function( data ){ return this.encodeInt( data, 32, true ); };
|
|
BinaryParser.toLong = function( data ){ return this.decodeInt( data, 64, true ); };
|
|
BinaryParser.fromLong = function( data ){ return this.encodeInt( data, 64, true ); };
|
|
BinaryParser.toDWord = function( data ){ return this.decodeInt( data, 32, false ); };
|
|
BinaryParser.fromDWord = function( data ){ return this.encodeInt( data, 32, false ); };
|
|
BinaryParser.toQWord = function( data ){ return this.decodeInt( data, 64, true ); };
|
|
BinaryParser.fromQWord = function( data ){ return this.encodeInt( data, 64, true ); };
|
|
BinaryParser.toFloat = function( data ){ return this.decodeFloat( data, 23, 8 ); };
|
|
BinaryParser.fromFloat = function( data ){ return this.encodeFloat( data, 23, 8 ); };
|
|
BinaryParser.toDouble = function( data ){ return this.decodeFloat( data, 52, 11 ); };
|
|
BinaryParser.fromDouble = function( data ){ return this.encodeFloat( data, 52, 11 ); };
|
|
|
|
// Factor out the encode so it can be shared by add_header and push_int32
|
|
BinaryParser.encode_int32 = function encode_int32 (number, asArray) {
|
|
var a, b, c, d, unsigned;
|
|
unsigned = (number < 0) ? (number + 0x100000000) : number;
|
|
a = Math.floor(unsigned / 0xffffff);
|
|
unsigned &= 0xffffff;
|
|
b = Math.floor(unsigned / 0xffff);
|
|
unsigned &= 0xffff;
|
|
c = Math.floor(unsigned / 0xff);
|
|
unsigned &= 0xff;
|
|
d = Math.floor(unsigned);
|
|
return asArray ? [chr(a), chr(b), chr(c), chr(d)] : chr(a) + chr(b) + chr(c) + chr(d);
|
|
};
|
|
|
|
BinaryParser.encode_int64 = function encode_int64 (number) {
|
|
var a, b, c, d, e, f, g, h, unsigned;
|
|
unsigned = (number < 0) ? (number + 0x10000000000000000) : number;
|
|
a = Math.floor(unsigned / 0xffffffffffffff);
|
|
unsigned &= 0xffffffffffffff;
|
|
b = Math.floor(unsigned / 0xffffffffffff);
|
|
unsigned &= 0xffffffffffff;
|
|
c = Math.floor(unsigned / 0xffffffffff);
|
|
unsigned &= 0xffffffffff;
|
|
d = Math.floor(unsigned / 0xffffffff);
|
|
unsigned &= 0xffffffff;
|
|
e = Math.floor(unsigned / 0xffffff);
|
|
unsigned &= 0xffffff;
|
|
f = Math.floor(unsigned / 0xffff);
|
|
unsigned &= 0xffff;
|
|
g = Math.floor(unsigned / 0xff);
|
|
unsigned &= 0xff;
|
|
h = Math.floor(unsigned);
|
|
return chr(a) + chr(b) + chr(c) + chr(d) + chr(e) + chr(f) + chr(g) + chr(h);
|
|
};
|
|
|
|
/**
|
|
* UTF8 methods
|
|
*/
|
|
|
|
// Take a raw binary string and return a utf8 string
|
|
BinaryParser.decode_utf8 = function decode_utf8 (binaryStr) {
|
|
var len = binaryStr.length
|
|
, decoded = ''
|
|
, i = 0
|
|
, c = 0
|
|
, c1 = 0
|
|
, c2 = 0
|
|
, c3;
|
|
|
|
while (i < len) {
|
|
c = binaryStr.charCodeAt(i);
|
|
if (c < 128) {
|
|
decoded += String.fromCharCode(c);
|
|
i++;
|
|
} else if ((c > 191) && (c < 224)) {
|
|
c2 = binaryStr.charCodeAt(i+1);
|
|
decoded += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
|
|
i += 2;
|
|
} else {
|
|
c2 = binaryStr.charCodeAt(i+1);
|
|
c3 = binaryStr.charCodeAt(i+2);
|
|
decoded += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
|
|
i += 3;
|
|
}
|
|
}
|
|
|
|
return decoded;
|
|
};
|
|
|
|
// Encode a cstring
|
|
BinaryParser.encode_cstring = function encode_cstring (s) {
|
|
return unescape(encodeURIComponent(s)) + BinaryParser.fromByte(0);
|
|
};
|
|
|
|
// Take a utf8 string and return a binary string
|
|
BinaryParser.encode_utf8 = function encode_utf8 (s) {
|
|
var a = ""
|
|
, c;
|
|
|
|
for (var n = 0, len = s.length; n < len; n++) {
|
|
c = s.charCodeAt(n);
|
|
|
|
if (c < 128) {
|
|
a += String.fromCharCode(c);
|
|
} else if ((c > 127) && (c < 2048)) {
|
|
a += String.fromCharCode((c>>6) | 192) ;
|
|
a += String.fromCharCode((c&63) | 128);
|
|
} else {
|
|
a += String.fromCharCode((c>>12) | 224);
|
|
a += String.fromCharCode(((c>>6) & 63) | 128);
|
|
a += String.fromCharCode((c&63) | 128);
|
|
}
|
|
}
|
|
|
|
return a;
|
|
};
|
|
|
|
BinaryParser.hprint = function hprint (s) {
|
|
var number;
|
|
|
|
for (var i = 0, len = s.length; i < len; i++) {
|
|
if (s.charCodeAt(i) < 32) {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(16)
|
|
: s.charCodeAt(i).toString(16);
|
|
process.stdout.write(number + " ")
|
|
} else {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(16)
|
|
: s.charCodeAt(i).toString(16);
|
|
process.stdout.write(number + " ")
|
|
}
|
|
}
|
|
|
|
process.stdout.write("\n\n");
|
|
};
|
|
|
|
BinaryParser.ilprint = function hprint (s) {
|
|
var number;
|
|
|
|
for (var i = 0, len = s.length; i < len; i++) {
|
|
if (s.charCodeAt(i) < 32) {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(10)
|
|
: s.charCodeAt(i).toString(10);
|
|
|
|
require('util').debug(number+' : ');
|
|
} else {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(10)
|
|
: s.charCodeAt(i).toString(10);
|
|
require('util').debug(number+' : '+ s.charAt(i));
|
|
}
|
|
}
|
|
};
|
|
|
|
BinaryParser.hlprint = function hprint (s) {
|
|
var number;
|
|
|
|
for (var i = 0, len = s.length; i < len; i++) {
|
|
if (s.charCodeAt(i) < 32) {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(16)
|
|
: s.charCodeAt(i).toString(16);
|
|
require('util').debug(number+' : ');
|
|
} else {
|
|
number = s.charCodeAt(i) <= 15
|
|
? "0" + s.charCodeAt(i).toString(16)
|
|
: s.charCodeAt(i).toString(16);
|
|
require('util').debug(number+' : '+ s.charAt(i));
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* BinaryParser buffer constructor.
|
|
*/
|
|
function BinaryParserBuffer (bigEndian, buffer) {
|
|
this.bigEndian = bigEndian || 0;
|
|
this.buffer = [];
|
|
this.setBuffer(buffer);
|
|
};
|
|
|
|
BinaryParserBuffer.prototype.setBuffer = function setBuffer (data) {
|
|
var l, i, b;
|
|
|
|
if (data) {
|
|
i = l = data.length;
|
|
b = this.buffer = new Array(l);
|
|
for (; i; b[l - i] = data.charCodeAt(--i));
|
|
this.bigEndian && b.reverse();
|
|
}
|
|
};
|
|
|
|
BinaryParserBuffer.prototype.hasNeededBits = function hasNeededBits (neededBits) {
|
|
return this.buffer.length >= -(-neededBits >> 3);
|
|
};
|
|
|
|
BinaryParserBuffer.prototype.checkBuffer = function checkBuffer (neededBits) {
|
|
if (!this.hasNeededBits(neededBits)) {
|
|
throw new Error("checkBuffer::missing bytes");
|
|
}
|
|
};
|
|
|
|
BinaryParserBuffer.prototype.readBits = function readBits (start, length) {
|
|
//shl fix: Henri Torgemane ~1996 (compressed by Jonas Raoni)
|
|
|
|
function shl (a, b) {
|
|
for (; b--; a = ((a %= 0x7fffffff + 1) & 0x40000000) == 0x40000000 ? a * 2 : (a - 0x40000000) * 2 + 0x7fffffff + 1);
|
|
return a;
|
|
}
|
|
|
|
if (start < 0 || length <= 0) {
|
|
return 0;
|
|
}
|
|
|
|
this.checkBuffer(start + length);
|
|
|
|
var offsetLeft
|
|
, offsetRight = start % 8
|
|
, curByte = this.buffer.length - ( start >> 3 ) - 1
|
|
, lastByte = this.buffer.length + ( -( start + length ) >> 3 )
|
|
, diff = curByte - lastByte
|
|
, sum = ((this.buffer[ curByte ] >> offsetRight) & ((1 << (diff ? 8 - offsetRight : length)) - 1)) + (diff && (offsetLeft = (start + length) % 8) ? (this.buffer[lastByte++] & ((1 << offsetLeft) - 1)) << (diff-- << 3) - offsetRight : 0);
|
|
|
|
for(; diff; sum += shl(this.buffer[lastByte++], (diff-- << 3) - offsetRight));
|
|
|
|
return sum;
|
|
};
|
|
|
|
/**
|
|
* Expose.
|
|
*/
|
|
BinaryParser.Buffer = BinaryParserBuffer;
|
|
|
|
exports.BinaryParser = BinaryParser;
|
|
|
|
},
|
|
|
|
|
|
|
|
'bson': function(module, exports, global, require, undefined){
|
|
var Long = require('./long').Long
|
|
, Double = require('./double').Double
|
|
, Timestamp = require('./timestamp').Timestamp
|
|
, ObjectID = require('./objectid').ObjectID
|
|
, Symbol = require('./symbol').Symbol
|
|
, Code = require('./code').Code
|
|
, MinKey = require('./min_key').MinKey
|
|
, MaxKey = require('./max_key').MaxKey
|
|
, DBRef = require('./db_ref').DBRef
|
|
, Binary = require('./binary').Binary
|
|
, BinaryParser = require('./binary_parser').BinaryParser
|
|
, writeIEEE754 = require('./float_parser').writeIEEE754
|
|
, readIEEE754 = require('./float_parser').readIEEE754
|
|
|
|
// To ensure that 0.4 of node works correctly
|
|
var isDate = function isDate(d) {
|
|
return typeof d === 'object' && Object.prototype.toString.call(d) === '[object Date]';
|
|
}
|
|
|
|
/**
|
|
* Create a new BSON instance
|
|
*
|
|
* @class Represents the BSON Parser
|
|
* @return {BSON} instance of BSON Parser.
|
|
*/
|
|
function BSON () {};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
// BSON MAX VALUES
|
|
BSON.BSON_INT32_MAX = 0x7FFFFFFF;
|
|
BSON.BSON_INT32_MIN = -0x80000000;
|
|
|
|
BSON.BSON_INT64_MAX = Math.pow(2, 63) - 1;
|
|
BSON.BSON_INT64_MIN = -Math.pow(2, 63);
|
|
|
|
// JS MAX PRECISE VALUES
|
|
BSON.JS_INT_MAX = 0x20000000000000; // Any integer up to 2^53 can be precisely represented by a double.
|
|
BSON.JS_INT_MIN = -0x20000000000000; // Any integer down to -2^53 can be precisely represented by a double.
|
|
|
|
// Internal long versions
|
|
var JS_INT_MAX_LONG = Long.fromNumber(0x20000000000000); // Any integer up to 2^53 can be precisely represented by a double.
|
|
var JS_INT_MIN_LONG = Long.fromNumber(-0x20000000000000); // Any integer down to -2^53 can be precisely represented by a double.
|
|
|
|
/**
|
|
* Number BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_NUMBER
|
|
**/
|
|
BSON.BSON_DATA_NUMBER = 1;
|
|
/**
|
|
* String BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_STRING
|
|
**/
|
|
BSON.BSON_DATA_STRING = 2;
|
|
/**
|
|
* Object BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_OBJECT
|
|
**/
|
|
BSON.BSON_DATA_OBJECT = 3;
|
|
/**
|
|
* Array BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_ARRAY
|
|
**/
|
|
BSON.BSON_DATA_ARRAY = 4;
|
|
/**
|
|
* Binary BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_BINARY
|
|
**/
|
|
BSON.BSON_DATA_BINARY = 5;
|
|
/**
|
|
* ObjectID BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_OID
|
|
**/
|
|
BSON.BSON_DATA_OID = 7;
|
|
/**
|
|
* Boolean BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_BOOLEAN
|
|
**/
|
|
BSON.BSON_DATA_BOOLEAN = 8;
|
|
/**
|
|
* Date BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_DATE
|
|
**/
|
|
BSON.BSON_DATA_DATE = 9;
|
|
/**
|
|
* null BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_NULL
|
|
**/
|
|
BSON.BSON_DATA_NULL = 10;
|
|
/**
|
|
* RegExp BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_REGEXP
|
|
**/
|
|
BSON.BSON_DATA_REGEXP = 11;
|
|
/**
|
|
* Code BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_CODE
|
|
**/
|
|
BSON.BSON_DATA_CODE = 13;
|
|
/**
|
|
* Symbol BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_SYMBOL
|
|
**/
|
|
BSON.BSON_DATA_SYMBOL = 14;
|
|
/**
|
|
* Code with Scope BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_CODE_W_SCOPE
|
|
**/
|
|
BSON.BSON_DATA_CODE_W_SCOPE = 15;
|
|
/**
|
|
* 32 bit Integer BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_INT
|
|
**/
|
|
BSON.BSON_DATA_INT = 16;
|
|
/**
|
|
* Timestamp BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_TIMESTAMP
|
|
**/
|
|
BSON.BSON_DATA_TIMESTAMP = 17;
|
|
/**
|
|
* Long BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_LONG
|
|
**/
|
|
BSON.BSON_DATA_LONG = 18;
|
|
/**
|
|
* MinKey BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_MIN_KEY
|
|
**/
|
|
BSON.BSON_DATA_MIN_KEY = 0xff;
|
|
/**
|
|
* MaxKey BSON Type
|
|
*
|
|
* @classconstant BSON_DATA_MAX_KEY
|
|
**/
|
|
BSON.BSON_DATA_MAX_KEY = 0x7f;
|
|
|
|
/**
|
|
* Binary Default Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_DEFAULT
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
|
/**
|
|
* Binary Function Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_FUNCTION
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_FUNCTION = 1;
|
|
/**
|
|
* Binary Byte Array Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
|
|
/**
|
|
* Binary UUID Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_UUID
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_UUID = 3;
|
|
/**
|
|
* Binary MD5 Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_MD5
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_MD5 = 4;
|
|
/**
|
|
* Binary User Defined Type
|
|
*
|
|
* @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED
|
|
**/
|
|
BSON.BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
|
|
|
|
/**
|
|
* Calculate the bson size for a passed in Javascript object.
|
|
*
|
|
* @param {Object} object the Javascript object to calculate the BSON byte size for.
|
|
* @param {Boolean} [serializeFunctions] serialize all functions in the object **(default:false)**.
|
|
* @return {Number} returns the number of bytes the BSON object will take up.
|
|
* @api public
|
|
*/
|
|
BSON.calculateObjectSize = function calculateObjectSize(object, serializeFunctions) {
|
|
var totalLength = (4 + 1);
|
|
|
|
if(Array.isArray(object)) {
|
|
for(var i = 0; i < object.length; i++) {
|
|
totalLength += calculateElement(i.toString(), object[i], serializeFunctions)
|
|
}
|
|
} else {
|
|
// If we have toBSON defined, override the current object
|
|
if(object.toBSON) {
|
|
object = object.toBSON();
|
|
}
|
|
|
|
// Calculate size
|
|
for(var key in object) {
|
|
totalLength += calculateElement(key, object[key], serializeFunctions)
|
|
}
|
|
}
|
|
|
|
return totalLength;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
function calculateElement(name, value, serializeFunctions) {
|
|
var isBuffer = typeof Buffer !== 'undefined';
|
|
|
|
switch(typeof value) {
|
|
case 'string':
|
|
return 1 + (!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1 + 4 + (!isBuffer ? numberOfBytes(value) : Buffer.byteLength(value, 'utf8')) + 1;
|
|
case 'number':
|
|
if(Math.floor(value) === value && value >= BSON.JS_INT_MIN && value <= BSON.JS_INT_MAX) {
|
|
if(value >= BSON.BSON_INT32_MIN && value <= BSON.BSON_INT32_MAX) { // 32 bit
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (4 + 1);
|
|
} else {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (8 + 1);
|
|
}
|
|
} else { // 64 bit
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (8 + 1);
|
|
}
|
|
case 'undefined':
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (1);
|
|
case 'boolean':
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (1 + 1);
|
|
case 'object':
|
|
if(value == null || value instanceof MinKey || value instanceof MaxKey || value['_bsontype'] == 'MinKey' || value['_bsontype'] == 'MaxKey') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (1);
|
|
} else if(value instanceof ObjectID || value['_bsontype'] == 'ObjectID') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (12 + 1);
|
|
} else if(value instanceof Date || isDate(value)) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (8 + 1);
|
|
} else if(typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (1 + 4 + 1) + value.length;
|
|
} else if(value instanceof Long || value instanceof Double || value instanceof Timestamp
|
|
|| value['_bsontype'] == 'Long' || value['_bsontype'] == 'Double' || value['_bsontype'] == 'Timestamp') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (8 + 1);
|
|
} else if(value instanceof Code || value['_bsontype'] == 'Code') {
|
|
// Calculate size depending on the availability of a scope
|
|
if(value.scope != null && Object.keys(value.scope).length > 0) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + 4 + 4 + (!isBuffer ? numberOfBytes(value.code.toString()) : Buffer.byteLength(value.code.toString(), 'utf8')) + 1 + BSON.calculateObjectSize(value.scope, serializeFunctions);
|
|
} else {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + 4 + (!isBuffer ? numberOfBytes(value.code.toString()) : Buffer.byteLength(value.code.toString(), 'utf8')) + 1;
|
|
}
|
|
} else if(value instanceof Binary || value['_bsontype'] == 'Binary') {
|
|
// Check what kind of subtype we have
|
|
if(value.sub_type == Binary.SUBTYPE_BYTE_ARRAY) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (value.position + 1 + 4 + 1 + 4);
|
|
} else {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + (value.position + 1 + 4 + 1);
|
|
}
|
|
} else if(value instanceof Symbol || value['_bsontype'] == 'Symbol') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + ((!isBuffer ? numberOfBytes(value.value) : Buffer.byteLength(value.value, 'utf8')) + 4 + 1 + 1);
|
|
} else if(value instanceof DBRef || value['_bsontype'] == 'DBRef') {
|
|
// Set up correct object for serialization
|
|
var ordered_values = {
|
|
'$ref': value.namespace
|
|
, '$id' : value.oid
|
|
};
|
|
|
|
// Add db reference if it exists
|
|
if(null != value.db) {
|
|
ordered_values['$db'] = value.db;
|
|
}
|
|
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + BSON.calculateObjectSize(ordered_values, serializeFunctions);
|
|
} else if(value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + (!isBuffer ? numberOfBytes(value.source) : Buffer.byteLength(value.source, 'utf8')) + 1
|
|
+ (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1
|
|
} else {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + BSON.calculateObjectSize(value, serializeFunctions) + 1;
|
|
}
|
|
case 'function':
|
|
// WTF for 0.4.X where typeof /someregexp/ === 'function'
|
|
if(value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]' || String.call(value) == '[object RegExp]') {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + (!isBuffer ? numberOfBytes(value.source) : Buffer.byteLength(value.source, 'utf8')) + 1
|
|
+ (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1
|
|
} else {
|
|
if(serializeFunctions && value.scope != null && Object.keys(value.scope).length > 0) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + 4 + 4 + (!isBuffer ? numberOfBytes(value.toString()) : Buffer.byteLength(value.toString(), 'utf8')) + 1 + BSON.calculateObjectSize(value.scope, serializeFunctions);
|
|
} else if(serializeFunctions) {
|
|
return (name != null ? ((!isBuffer ? numberOfBytes(name) : Buffer.byteLength(name, 'utf8')) + 1) : 0) + 1 + 4 + (!isBuffer ? numberOfBytes(value.toString()) : Buffer.byteLength(value.toString(), 'utf8')) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Serialize a Javascript object using a predefined Buffer and index into the buffer, useful when pre-allocating the space for serialization.
|
|
*
|
|
* @param {Object} object the Javascript object to serialize.
|
|
* @param {Boolean} checkKeys the serializer will check if keys are valid.
|
|
* @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.
|
|
* @param {Number} index the index in the buffer where we wish to start serializing into.
|
|
* @param {Boolean} serializeFunctions serialize the javascript functions **(default:false)**.
|
|
* @return {Number} returns the new write index in the Buffer.
|
|
* @api public
|
|
*/
|
|
BSON.serializeWithBufferAndIndex = function serializeWithBufferAndIndex(object, checkKeys, buffer, index, serializeFunctions) {
|
|
// Default setting false
|
|
serializeFunctions = serializeFunctions == null ? false : serializeFunctions;
|
|
// Write end information (length of the object)
|
|
var size = buffer.length;
|
|
// Write the size of the object
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
return serializeObject(object, checkKeys, buffer, index, serializeFunctions) - 1;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var serializeObject = function(object, checkKeys, buffer, index, serializeFunctions) {
|
|
// Process the object
|
|
if(Array.isArray(object)) {
|
|
for(var i = 0; i < object.length; i++) {
|
|
index = packElement(i.toString(), object[i], checkKeys, buffer, index, serializeFunctions);
|
|
}
|
|
} else {
|
|
// If we have toBSON defined, override the current object
|
|
if(object.toBSON) {
|
|
object = object.toBSON();
|
|
}
|
|
|
|
// Serialize the object
|
|
for(var key in object) {
|
|
// Check the key and throw error if it's illegal
|
|
if (key != '$db' && key != '$ref' && key != '$id') {
|
|
// dollars and dots ok
|
|
BSON.checkKey(key, !checkKeys);
|
|
}
|
|
|
|
// Pack the element
|
|
index = packElement(key, object[key], checkKeys, buffer, index, serializeFunctions);
|
|
}
|
|
}
|
|
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
|
|
var stringToBytes = function(str) {
|
|
var ch, st, re = [];
|
|
for (var i = 0; i < str.length; i++ ) {
|
|
ch = str.charCodeAt(i); // get char
|
|
st = []; // set up "stack"
|
|
do {
|
|
st.push( ch & 0xFF ); // push byte to stack
|
|
ch = ch >> 8; // shift value down by 1 byte
|
|
}
|
|
while ( ch );
|
|
// add stack contents to result
|
|
// done because chars have "wrong" endianness
|
|
re = re.concat( st.reverse() );
|
|
}
|
|
// return an array of bytes
|
|
return re;
|
|
}
|
|
|
|
var numberOfBytes = function(str) {
|
|
var ch, st, re = 0;
|
|
for (var i = 0; i < str.length; i++ ) {
|
|
ch = str.charCodeAt(i); // get char
|
|
st = []; // set up "stack"
|
|
do {
|
|
st.push( ch & 0xFF ); // push byte to stack
|
|
ch = ch >> 8; // shift value down by 1 byte
|
|
}
|
|
while ( ch );
|
|
// add stack contents to result
|
|
// done because chars have "wrong" endianness
|
|
re = re + st.length;
|
|
}
|
|
// return an array of bytes
|
|
return re;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var writeToTypedArray = function(buffer, string, index) {
|
|
var bytes = stringToBytes(string);
|
|
for(var i = 0; i < bytes.length; i++) {
|
|
buffer[index + i] = bytes[i];
|
|
}
|
|
return bytes.length;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var supportsBuffer = typeof Buffer != 'undefined';
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var packElement = function(name, value, checkKeys, buffer, index, serializeFunctions) {
|
|
var startIndex = index;
|
|
|
|
switch(typeof value) {
|
|
case 'string':
|
|
// Encode String type
|
|
buffer[index++] = BSON.BSON_DATA_STRING;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
|
|
// Calculate size
|
|
var size = supportsBuffer ? Buffer.byteLength(value) + 1 : numberOfBytes(value) + 1;
|
|
// Write the size of the string to buffer
|
|
buffer[index + 3] = (size >> 24) & 0xff;
|
|
buffer[index + 2] = (size >> 16) & 0xff;
|
|
buffer[index + 1] = (size >> 8) & 0xff;
|
|
buffer[index] = size & 0xff;
|
|
// Ajust the index
|
|
index = index + 4;
|
|
// Write the string
|
|
supportsBuffer ? buffer.write(value, index, 'utf8') : writeToTypedArray(buffer, value, index);
|
|
// Update index
|
|
index = index + size - 1;
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
// Return index
|
|
return index;
|
|
case 'number':
|
|
// We have an integer value
|
|
if(Math.floor(value) === value && value >= BSON.JS_INT_MIN && value <= BSON.JS_INT_MAX) {
|
|
// If the value fits in 32 bits encode as int, if it fits in a double
|
|
// encode it as a double, otherwise long
|
|
if(value >= BSON.BSON_INT32_MIN && value <= BSON.BSON_INT32_MAX) {
|
|
// Set int type 32 bits or less
|
|
buffer[index++] = BSON.BSON_DATA_INT;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Write the int value
|
|
buffer[index++] = value & 0xff;
|
|
buffer[index++] = (value >> 8) & 0xff;
|
|
buffer[index++] = (value >> 16) & 0xff;
|
|
buffer[index++] = (value >> 24) & 0xff;
|
|
} else if(value >= BSON.JS_INT_MIN && value <= BSON.JS_INT_MAX) {
|
|
// Encode as double
|
|
buffer[index++] = BSON.BSON_DATA_NUMBER;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Write float
|
|
writeIEEE754(buffer, value, index, 'little', 52, 8);
|
|
// Ajust index
|
|
index = index + 8;
|
|
} else {
|
|
// Set long type
|
|
buffer[index++] = BSON.BSON_DATA_LONG;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
var longVal = Long.fromNumber(value);
|
|
var lowBits = longVal.getLowBits();
|
|
var highBits = longVal.getHighBits();
|
|
// Encode low bits
|
|
buffer[index++] = lowBits & 0xff;
|
|
buffer[index++] = (lowBits >> 8) & 0xff;
|
|
buffer[index++] = (lowBits >> 16) & 0xff;
|
|
buffer[index++] = (lowBits >> 24) & 0xff;
|
|
// Encode high bits
|
|
buffer[index++] = highBits & 0xff;
|
|
buffer[index++] = (highBits >> 8) & 0xff;
|
|
buffer[index++] = (highBits >> 16) & 0xff;
|
|
buffer[index++] = (highBits >> 24) & 0xff;
|
|
}
|
|
} else {
|
|
// Encode as double
|
|
buffer[index++] = BSON.BSON_DATA_NUMBER;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Write float
|
|
writeIEEE754(buffer, value, index, 'little', 52, 8);
|
|
// Ajust index
|
|
index = index + 8;
|
|
}
|
|
|
|
return index;
|
|
case 'undefined':
|
|
// Set long type
|
|
buffer[index++] = BSON.BSON_DATA_NULL;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
return index;
|
|
case 'boolean':
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_BOOLEAN;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Encode the boolean value
|
|
buffer[index++] = value ? 1 : 0;
|
|
return index;
|
|
case 'object':
|
|
if(value === null || value instanceof MinKey || value instanceof MaxKey
|
|
|| value['_bsontype'] == 'MinKey' || value['_bsontype'] == 'MaxKey') {
|
|
// Write the type of either min or max key
|
|
if(value === null) {
|
|
buffer[index++] = BSON.BSON_DATA_NULL;
|
|
} else if(value instanceof MinKey) {
|
|
buffer[index++] = BSON.BSON_DATA_MIN_KEY;
|
|
} else {
|
|
buffer[index++] = BSON.BSON_DATA_MAX_KEY;
|
|
}
|
|
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
return index;
|
|
} else if(value instanceof ObjectID || value['_bsontype'] == 'ObjectID') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_OID;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
|
|
// Write objectid
|
|
supportsBuffer ? buffer.write(value.id, index, 'binary') : writeToTypedArray(buffer, value.id, index);
|
|
// Ajust index
|
|
index = index + 12;
|
|
return index;
|
|
} else if(value instanceof Date || isDate(value)) {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_DATE;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
|
|
// Write the date
|
|
var dateInMilis = Long.fromNumber(value.getTime());
|
|
var lowBits = dateInMilis.getLowBits();
|
|
var highBits = dateInMilis.getHighBits();
|
|
// Encode low bits
|
|
buffer[index++] = lowBits & 0xff;
|
|
buffer[index++] = (lowBits >> 8) & 0xff;
|
|
buffer[index++] = (lowBits >> 16) & 0xff;
|
|
buffer[index++] = (lowBits >> 24) & 0xff;
|
|
// Encode high bits
|
|
buffer[index++] = highBits & 0xff;
|
|
buffer[index++] = (highBits >> 8) & 0xff;
|
|
buffer[index++] = (highBits >> 16) & 0xff;
|
|
buffer[index++] = (highBits >> 24) & 0xff;
|
|
return index;
|
|
} else if(typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_BINARY;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Get size of the buffer (current write point)
|
|
var size = value.length;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write the default subtype
|
|
buffer[index++] = BSON.BSON_BINARY_SUBTYPE_DEFAULT;
|
|
// Copy the content form the binary field to the buffer
|
|
value.copy(buffer, index, 0, size);
|
|
// Adjust the index
|
|
index = index + size;
|
|
return index;
|
|
} else if(value instanceof Long || value instanceof Timestamp || value['_bsontype'] == 'Long' || value['_bsontype'] == 'Timestamp') {
|
|
// Write the type
|
|
buffer[index++] = value instanceof Long ? BSON.BSON_DATA_LONG : BSON.BSON_DATA_TIMESTAMP;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Write the date
|
|
var lowBits = value.getLowBits();
|
|
var highBits = value.getHighBits();
|
|
// Encode low bits
|
|
buffer[index++] = lowBits & 0xff;
|
|
buffer[index++] = (lowBits >> 8) & 0xff;
|
|
buffer[index++] = (lowBits >> 16) & 0xff;
|
|
buffer[index++] = (lowBits >> 24) & 0xff;
|
|
// Encode high bits
|
|
buffer[index++] = highBits & 0xff;
|
|
buffer[index++] = (highBits >> 8) & 0xff;
|
|
buffer[index++] = (highBits >> 16) & 0xff;
|
|
buffer[index++] = (highBits >> 24) & 0xff;
|
|
return index;
|
|
} else if(value instanceof Double || value['_bsontype'] == 'Double') {
|
|
// Encode as double
|
|
buffer[index++] = BSON.BSON_DATA_NUMBER;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Write float
|
|
writeIEEE754(buffer, value, index, 'little', 52, 8);
|
|
// Ajust index
|
|
index = index + 8;
|
|
return index;
|
|
} else if(value instanceof Code || value['_bsontype'] == 'Code') {
|
|
if(value.scope != null && Object.keys(value.scope).length > 0) {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_CODE_W_SCOPE;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Calculate the scope size
|
|
var scopeSize = BSON.calculateObjectSize(value.scope, serializeFunctions);
|
|
// Function string
|
|
var functionString = value.code.toString();
|
|
// Function Size
|
|
var codeSize = supportsBuffer ? Buffer.byteLength(functionString) + 1 : numberOfBytes(functionString) + 1;
|
|
|
|
// Calculate full size of the object
|
|
var totalSize = 4 + codeSize + scopeSize + 4;
|
|
|
|
// Write the total size of the object
|
|
buffer[index++] = totalSize & 0xff;
|
|
buffer[index++] = (totalSize >> 8) & 0xff;
|
|
buffer[index++] = (totalSize >> 16) & 0xff;
|
|
buffer[index++] = (totalSize >> 24) & 0xff;
|
|
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = codeSize & 0xff;
|
|
buffer[index++] = (codeSize >> 8) & 0xff;
|
|
buffer[index++] = (codeSize >> 16) & 0xff;
|
|
buffer[index++] = (codeSize >> 24) & 0xff;
|
|
|
|
// Write the string
|
|
supportsBuffer ? buffer.write(functionString, index, 'utf8') : writeToTypedArray(buffer, functionString, index);
|
|
// Update index
|
|
index = index + codeSize - 1;
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
// Serialize the scope object
|
|
var scopeObjectBuffer = supportsBuffer ? new Buffer(scopeSize) : new Uint8Array(new ArrayBuffer(scopeSize));
|
|
// Execute the serialization into a seperate buffer
|
|
serializeObject(value.scope, checkKeys, scopeObjectBuffer, 0, serializeFunctions);
|
|
|
|
// Adjusted scope Size (removing the header)
|
|
var scopeDocSize = scopeSize;
|
|
// Write scope object size
|
|
buffer[index++] = scopeDocSize & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 8) & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 16) & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 24) & 0xff;
|
|
|
|
// Write the scopeObject into the buffer
|
|
supportsBuffer ? scopeObjectBuffer.copy(buffer, index, 0, scopeSize) : buffer.set(scopeObjectBuffer, index);
|
|
// Adjust index, removing the empty size of the doc (5 bytes 0000000005)
|
|
index = index + scopeDocSize - 5;
|
|
// Write trailing zero
|
|
buffer[index++] = 0;
|
|
return index
|
|
} else {
|
|
buffer[index++] = BSON.BSON_DATA_CODE;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Function string
|
|
var functionString = value.code.toString();
|
|
// Function Size
|
|
var size = supportsBuffer ? Buffer.byteLength(functionString) + 1 : numberOfBytes(functionString) + 1;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write the string
|
|
supportsBuffer ? buffer.write(functionString, index, 'utf8') : writeToTypedArray(buffer, functionString, index);
|
|
// Update index
|
|
index = index + size - 1;
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
} else if(value instanceof Binary || value['_bsontype'] == 'Binary') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_BINARY;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Extract the buffer
|
|
var data = value.value(true);
|
|
// Calculate size
|
|
var size = value.position;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write the subtype to the buffer
|
|
buffer[index++] = value.sub_type;
|
|
|
|
// If we have binary type 2 the 4 first bytes are the size
|
|
if(value.sub_type == Binary.SUBTYPE_BYTE_ARRAY) {
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
}
|
|
|
|
// Write the data to the object
|
|
supportsBuffer ? data.copy(buffer, index, 0, value.position) : buffer.set(data, index);
|
|
// Ajust index
|
|
index = index + value.position;
|
|
return index;
|
|
} else if(value instanceof Symbol || value['_bsontype'] == 'Symbol') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_SYMBOL;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Calculate size
|
|
var size = supportsBuffer ? Buffer.byteLength(value.value) + 1 : numberOfBytes(value.value) + 1;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write the string
|
|
buffer.write(value.value, index, 'utf8');
|
|
// Update index
|
|
index = index + size - 1;
|
|
// Write zero
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
} else if(value instanceof DBRef || value['_bsontype'] == 'DBRef') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_OBJECT;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Set up correct object for serialization
|
|
var ordered_values = {
|
|
'$ref': value.namespace
|
|
, '$id' : value.oid
|
|
};
|
|
|
|
// Add db reference if it exists
|
|
if(null != value.db) {
|
|
ordered_values['$db'] = value.db;
|
|
}
|
|
|
|
// Message size
|
|
var size = BSON.calculateObjectSize(ordered_values, serializeFunctions);
|
|
// Serialize the object
|
|
var endIndex = BSON.serializeWithBufferAndIndex(ordered_values, checkKeys, buffer, index, serializeFunctions);
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write zero for object
|
|
buffer[endIndex++] = 0x00;
|
|
// Return the end index
|
|
return endIndex;
|
|
} else if(value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_REGEXP;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
|
|
// Write the regular expression string
|
|
supportsBuffer ? buffer.write(value.source, index, 'utf8') : writeToTypedArray(buffer, value.source, index);
|
|
// Adjust the index
|
|
index = index + (supportsBuffer ? Buffer.byteLength(value.source) : numberOfBytes(value.source));
|
|
// Write zero
|
|
buffer[index++] = 0x00;
|
|
// Write the parameters
|
|
if(value.global) buffer[index++] = 0x73; // s
|
|
if(value.ignoreCase) buffer[index++] = 0x69; // i
|
|
if(value.multiline) buffer[index++] = 0x6d; // m
|
|
// Add ending zero
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
} else {
|
|
// Write the type
|
|
buffer[index++] = Array.isArray(value) ? BSON.BSON_DATA_ARRAY : BSON.BSON_DATA_OBJECT;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Adjust the index
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
var endIndex = serializeObject(value, checkKeys, buffer, index + 4, serializeFunctions);
|
|
// Write size
|
|
var size = endIndex - index;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
return endIndex;
|
|
}
|
|
case 'function':
|
|
// WTF for 0.4.X where typeof /someregexp/ === 'function'
|
|
if(value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]' || String.call(value) == '[object RegExp]') {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_REGEXP;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
|
|
// Write the regular expression string
|
|
buffer.write(value.source, index, 'utf8');
|
|
// Adjust the index
|
|
index = index + (supportsBuffer ? Buffer.byteLength(value.source) : numberOfBytes(value.source));
|
|
// Write zero
|
|
buffer[index++] = 0x00;
|
|
// Write the parameters
|
|
if(value.global) buffer[index++] = 0x73; // s
|
|
if(value.ignoreCase) buffer[index++] = 0x69; // i
|
|
if(value.multiline) buffer[index++] = 0x6d; // m
|
|
// Add ending zero
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
} else {
|
|
if(serializeFunctions && value.scope != null && Object.keys(value.scope).length > 0) {
|
|
// Write the type
|
|
buffer[index++] = BSON.BSON_DATA_CODE_W_SCOPE;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Calculate the scope size
|
|
var scopeSize = BSON.calculateObjectSize(value.scope, serializeFunctions);
|
|
// Function string
|
|
var functionString = value.toString();
|
|
// Function Size
|
|
var codeSize = supportsBuffer ? Buffer.byteLength(functionString) + 1 : numberOfBytes(functionString) + 1;
|
|
|
|
// Calculate full size of the object
|
|
var totalSize = 4 + codeSize + scopeSize;
|
|
|
|
// Write the total size of the object
|
|
buffer[index++] = totalSize & 0xff;
|
|
buffer[index++] = (totalSize >> 8) & 0xff;
|
|
buffer[index++] = (totalSize >> 16) & 0xff;
|
|
buffer[index++] = (totalSize >> 24) & 0xff;
|
|
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = codeSize & 0xff;
|
|
buffer[index++] = (codeSize >> 8) & 0xff;
|
|
buffer[index++] = (codeSize >> 16) & 0xff;
|
|
buffer[index++] = (codeSize >> 24) & 0xff;
|
|
|
|
// Write the string
|
|
supportsBuffer ? buffer.write(functionString, index, 'utf8') : writeToTypedArray(buffer, functionString, index);
|
|
// Update index
|
|
index = index + codeSize - 1;
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
// Serialize the scope object
|
|
var scopeObjectBuffer = new Buffer(scopeSize);
|
|
// Execute the serialization into a seperate buffer
|
|
serializeObject(value.scope, checkKeys, scopeObjectBuffer, 0, serializeFunctions);
|
|
|
|
// Adjusted scope Size (removing the header)
|
|
var scopeDocSize = scopeSize - 4;
|
|
// Write scope object size
|
|
buffer[index++] = scopeDocSize & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 8) & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 16) & 0xff;
|
|
buffer[index++] = (scopeDocSize >> 24) & 0xff;
|
|
|
|
// Write the scopeObject into the buffer
|
|
scopeObjectBuffer.copy(buffer, index, 0, scopeSize);
|
|
|
|
// Adjust index, removing the empty size of the doc (5 bytes 0000000005)
|
|
index = index + scopeDocSize - 5;
|
|
// Write trailing zero
|
|
buffer[index++] = 0;
|
|
return index
|
|
} else if(serializeFunctions) {
|
|
buffer[index++] = BSON.BSON_DATA_CODE;
|
|
// Number of written bytes
|
|
var numberOfWrittenBytes = supportsBuffer ? buffer.write(name, index, 'utf8') : writeToTypedArray(buffer, name, index);
|
|
// Encode the name
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
// Function string
|
|
var functionString = value.toString();
|
|
// Function Size
|
|
var size = supportsBuffer ? Buffer.byteLength(functionString) + 1 : numberOfBytes(functionString) + 1;
|
|
// Write the size of the string to buffer
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
// Write the string
|
|
supportsBuffer ? buffer.write(functionString, index, 'utf8') : writeToTypedArray(buffer, functionString, index);
|
|
// Update index
|
|
index = index + size - 1;
|
|
// Write zero
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no value to serialize
|
|
return index;
|
|
}
|
|
|
|
/**
|
|
* Serialize a Javascript object.
|
|
*
|
|
* @param {Object} object the Javascript object to serialize.
|
|
* @param {Boolean} checkKeys the serializer will check if keys are valid.
|
|
* @param {Boolean} asBuffer return the serialized object as a Buffer object **(ignore)**.
|
|
* @param {Boolean} serializeFunctions serialize the javascript functions **(default:false)**.
|
|
* @return {Buffer} returns the Buffer object containing the serialized object.
|
|
* @api public
|
|
*/
|
|
BSON.serialize = function(object, checkKeys, asBuffer, serializeFunctions) {
|
|
// Throw error if we are trying serialize an illegal type
|
|
if(object == null || typeof object != 'object' || Array.isArray(object))
|
|
throw new Error("Only javascript objects supported");
|
|
|
|
// Emoty target buffer
|
|
var buffer = null;
|
|
// Calculate the size of the object
|
|
var size = BSON.calculateObjectSize(object, serializeFunctions);
|
|
// Fetch the best available type for storing the binary data
|
|
if(buffer = typeof Buffer != 'undefined') {
|
|
buffer = new Buffer(size);
|
|
asBuffer = true;
|
|
} else if(typeof Uint8Array != 'undefined') {
|
|
buffer = new Uint8Array(new ArrayBuffer(size));
|
|
} else {
|
|
buffer = new Array(size);
|
|
}
|
|
|
|
// If asBuffer is false use typed arrays
|
|
BSON.serializeWithBufferAndIndex(object, checkKeys, buffer, 0, serializeFunctions);
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* Contains the function cache if we have that enable to allow for avoiding the eval step on each deserialization, comparison is by md5
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var functionCache = BSON.functionCache = {};
|
|
|
|
/**
|
|
* Crc state variables shared by function
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var table = [0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D];
|
|
|
|
/**
|
|
* CRC32 hash method, Fast and enough versitility for our usage
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var crc32 = function(string, start, end) {
|
|
var crc = 0
|
|
var x = 0;
|
|
var y = 0;
|
|
crc = crc ^ (-1);
|
|
|
|
for(var i = start, iTop = end; i < iTop;i++) {
|
|
y = (crc ^ string[i]) & 0xFF;
|
|
x = table[y];
|
|
crc = (crc >>> 8) ^ x;
|
|
}
|
|
|
|
return crc ^ (-1);
|
|
}
|
|
|
|
/**
|
|
* Deserialize stream data as BSON documents.
|
|
*
|
|
* Options
|
|
* - **evalFunctions** {Boolean, default:false}, evaluate functions in the BSON document scoped to the object deserialized.
|
|
* - **cacheFunctions** {Boolean, default:false}, cache evaluated functions for reuse.
|
|
* - **cacheFunctionsCrc32** {Boolean, default:false}, use a crc32 code for caching, otherwise use the string of the function.
|
|
* - **promoteLongs** {Boolean, default:true}, when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
|
*
|
|
* @param {Buffer} data the buffer containing the serialized set of BSON documents.
|
|
* @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.
|
|
* @param {Number} numberOfDocuments number of documents to deserialize.
|
|
* @param {Array} documents an array where to store the deserialized documents.
|
|
* @param {Number} docStartIndex the index in the documents array from where to start inserting documents.
|
|
* @param {Object} [options] additional options used for the deserialization.
|
|
* @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.
|
|
* @api public
|
|
*/
|
|
BSON.deserializeStream = function(data, startIndex, numberOfDocuments, documents, docStartIndex, options) {
|
|
// if(numberOfDocuments !== documents.length) throw new Error("Number of expected results back is less than the number of documents");
|
|
options = options != null ? options : {};
|
|
var index = startIndex;
|
|
// Loop over all documents
|
|
for(var i = 0; i < numberOfDocuments; i++) {
|
|
// Find size of the document
|
|
var size = data[index] | data[index + 1] << 8 | data[index + 2] << 16 | data[index + 3] << 24;
|
|
// Update options with index
|
|
options['index'] = index;
|
|
// Parse the document at this point
|
|
documents[docStartIndex + i] = BSON.deserialize(data, options);
|
|
// Adjust index by the document size
|
|
index = index + size;
|
|
}
|
|
|
|
// Return object containing end index of parsing and list of documents
|
|
return index;
|
|
}
|
|
|
|
/**
|
|
* Ensure eval is isolated.
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var isolateEvalWithHash = function(functionCache, hash, functionString, object) {
|
|
// Contains the value we are going to set
|
|
var value = null;
|
|
|
|
// Check for cache hit, eval if missing and return cached function
|
|
if(functionCache[hash] == null) {
|
|
eval("value = " + functionString);
|
|
functionCache[hash] = value;
|
|
}
|
|
// Set the object
|
|
return functionCache[hash].bind(object);
|
|
}
|
|
|
|
/**
|
|
* Ensure eval is isolated.
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var isolateEval = function(functionString) {
|
|
// Contains the value we are going to set
|
|
var value = null;
|
|
// Eval the function
|
|
eval("value = " + functionString);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Convert Uint8Array to String
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
var convertUint8ArrayToUtf8String = function(byteArray, startIndex, endIndex) {
|
|
return BinaryParser.decode_utf8(convertArraytoUtf8BinaryString(byteArray, startIndex, endIndex));
|
|
}
|
|
|
|
var convertArraytoUtf8BinaryString = function(byteArray, startIndex, endIndex) {
|
|
var result = "";
|
|
for(var i = startIndex; i < endIndex; i++) {
|
|
result = result + String.fromCharCode(byteArray[i]);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Deserialize data as BSON.
|
|
*
|
|
* Options
|
|
* - **evalFunctions** {Boolean, default:false}, evaluate functions in the BSON document scoped to the object deserialized.
|
|
* - **cacheFunctions** {Boolean, default:false}, cache evaluated functions for reuse.
|
|
* - **cacheFunctionsCrc32** {Boolean, default:false}, use a crc32 code for caching, otherwise use the string of the function.
|
|
* - **promoteLongs** {Boolean, default:true}, when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
|
*
|
|
* @param {Buffer} buffer the buffer containing the serialized set of BSON documents.
|
|
* @param {Object} [options] additional options used for the deserialization.
|
|
* @param {Boolean} [isArray] ignore used for recursive parsing.
|
|
* @return {Object} returns the deserialized Javascript Object.
|
|
* @api public
|
|
*/
|
|
BSON.deserialize = function(buffer, options, isArray) {
|
|
// Options
|
|
options = options == null ? {} : options;
|
|
var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
|
|
var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
|
|
var cacheFunctionsCrc32 = options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];
|
|
var promoteLongs = options['promoteLongs'] || true;
|
|
|
|
// Validate that we have at least 4 bytes of buffer
|
|
if(buffer.length < 5) throw new Error("corrupt bson message < 5 bytes long");
|
|
|
|
// Set up index
|
|
var index = typeof options['index'] == 'number' ? options['index'] : 0;
|
|
// Reads in a C style string
|
|
var readCStyleString = function() {
|
|
// Get the start search index
|
|
var i = index;
|
|
// Locate the end of the c string
|
|
while(buffer[i] !== 0x00) { i++ }
|
|
// Grab utf8 encoded string
|
|
var string = supportsBuffer && Buffer.isBuffer(buffer) ? buffer.toString('utf8', index, i) : convertUint8ArrayToUtf8String(buffer, index, i);
|
|
// Update index position
|
|
index = i + 1;
|
|
// Return string
|
|
return string;
|
|
}
|
|
|
|
// Create holding object
|
|
var object = isArray ? [] : {};
|
|
|
|
// Read the document size
|
|
var size = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
|
|
// Ensure buffer is valid size
|
|
if(size < 5 || size > buffer.length) throw new Error("corrupt bson message");
|
|
|
|
// While we have more left data left keep parsing
|
|
while(true) {
|
|
// Read the type
|
|
var elementType = buffer[index++];
|
|
// If we get a zero it's the last byte, exit
|
|
if(elementType == 0) break;
|
|
// Read the name of the field
|
|
var name = readCStyleString();
|
|
// Switch on the type
|
|
switch(elementType) {
|
|
case BSON.BSON_DATA_OID:
|
|
var string = supportsBuffer && Buffer.isBuffer(buffer) ? buffer.toString('binary', index, index + 12) : convertArraytoUtf8BinaryString(buffer, index, index + 12);
|
|
// Decode the oid
|
|
object[name] = new ObjectID(string);
|
|
// Update index
|
|
index = index + 12;
|
|
break;
|
|
case BSON.BSON_DATA_STRING:
|
|
// Read the content of the field
|
|
var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Add string to object
|
|
object[name] = supportsBuffer && Buffer.isBuffer(buffer) ? buffer.toString('utf8', index, index + stringSize - 1) : convertUint8ArrayToUtf8String(buffer, index, index + stringSize - 1);
|
|
// Update parse index position
|
|
index = index + stringSize;
|
|
break;
|
|
case BSON.BSON_DATA_INT:
|
|
// Decode the 32bit value
|
|
object[name] = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
break;
|
|
case BSON.BSON_DATA_NUMBER:
|
|
// Decode the double value
|
|
object[name] = readIEEE754(buffer, index, 'little', 52, 8);
|
|
// Update the index
|
|
index = index + 8;
|
|
break;
|
|
case BSON.BSON_DATA_DATE:
|
|
// Unpack the low and high bits
|
|
var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Set date object
|
|
object[name] = new Date(new Long(lowBits, highBits).toNumber());
|
|
break;
|
|
case BSON.BSON_DATA_BOOLEAN:
|
|
// Parse the boolean value
|
|
object[name] = buffer[index++] == 1;
|
|
break;
|
|
case BSON.BSON_DATA_NULL:
|
|
// Parse the boolean value
|
|
object[name] = null;
|
|
break;
|
|
case BSON.BSON_DATA_BINARY:
|
|
// Decode the size of the binary blob
|
|
var binarySize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Decode the subtype
|
|
var subType = buffer[index++];
|
|
// Decode as raw Buffer object if options specifies it
|
|
if(buffer['slice'] != null) {
|
|
// If we have subtype 2 skip the 4 bytes for the size
|
|
if(subType == Binary.SUBTYPE_BYTE_ARRAY) {
|
|
binarySize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
}
|
|
// Slice the data
|
|
object[name] = new Binary(buffer.slice(index, index + binarySize), subType);
|
|
} else {
|
|
var _buffer = typeof Uint8Array != 'undefined' ? new Uint8Array(new ArrayBuffer(binarySize)) : new Array(binarySize);
|
|
// If we have subtype 2 skip the 4 bytes for the size
|
|
if(subType == Binary.SUBTYPE_BYTE_ARRAY) {
|
|
binarySize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
}
|
|
// Copy the data
|
|
for(var i = 0; i < binarySize; i++) {
|
|
_buffer[i] = buffer[index + i];
|
|
}
|
|
// Create the binary object
|
|
object[name] = new Binary(_buffer, subType);
|
|
}
|
|
// Update the index
|
|
index = index + binarySize;
|
|
break;
|
|
case BSON.BSON_DATA_ARRAY:
|
|
options['index'] = index;
|
|
// Decode the size of the array document
|
|
var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
|
|
// Set the array to the object
|
|
object[name] = BSON.deserialize(buffer, options, true);
|
|
// Adjust the index
|
|
index = index + objectSize;
|
|
break;
|
|
case BSON.BSON_DATA_OBJECT:
|
|
options['index'] = index;
|
|
// Decode the size of the object document
|
|
var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
|
|
// Set the array to the object
|
|
object[name] = BSON.deserialize(buffer, options, false);
|
|
// Adjust the index
|
|
index = index + objectSize;
|
|
break;
|
|
case BSON.BSON_DATA_REGEXP:
|
|
// Create the regexp
|
|
var source = readCStyleString();
|
|
var regExpOptions = readCStyleString();
|
|
// For each option add the corresponding one for javascript
|
|
var optionsArray = new Array(regExpOptions.length);
|
|
|
|
// Parse options
|
|
for(var i = 0; i < regExpOptions.length; i++) {
|
|
switch(regExpOptions[i]) {
|
|
case 'm':
|
|
optionsArray[i] = 'm';
|
|
break;
|
|
case 's':
|
|
optionsArray[i] = 'g';
|
|
break;
|
|
case 'i':
|
|
optionsArray[i] = 'i';
|
|
break;
|
|
}
|
|
}
|
|
|
|
object[name] = new RegExp(source, optionsArray.join(''));
|
|
break;
|
|
case BSON.BSON_DATA_LONG:
|
|
// Unpack the low and high bits
|
|
var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Create long object
|
|
var long = new Long(lowBits, highBits);
|
|
// Promote the long if possible
|
|
if(promoteLongs) {
|
|
object[name] = long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG) ? long.toNumber() : long;
|
|
} else {
|
|
object[name] = long;
|
|
}
|
|
break;
|
|
case BSON.BSON_DATA_SYMBOL:
|
|
// Read the content of the field
|
|
var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Add string to object
|
|
object[name] = new Symbol(buffer.toString('utf8', index, index + stringSize - 1));
|
|
// Update parse index position
|
|
index = index + stringSize;
|
|
break;
|
|
case BSON.BSON_DATA_TIMESTAMP:
|
|
// Unpack the low and high bits
|
|
var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Set the object
|
|
object[name] = new Timestamp(lowBits, highBits);
|
|
break;
|
|
case BSON.BSON_DATA_MIN_KEY:
|
|
// Parse the object
|
|
object[name] = new MinKey();
|
|
break;
|
|
case BSON.BSON_DATA_MAX_KEY:
|
|
// Parse the object
|
|
object[name] = new MaxKey();
|
|
break;
|
|
case BSON.BSON_DATA_CODE:
|
|
// Read the content of the field
|
|
var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Function string
|
|
var functionString = supportsBuffer && Buffer.isBuffer(buffer) ? buffer.toString('utf8', index, index + stringSize - 1) : convertUint8ArrayToUtf8String(buffer, index, index + stringSize - 1);
|
|
|
|
// If we are evaluating the functions
|
|
if(evalFunctions) {
|
|
// Contains the value we are going to set
|
|
var value = null;
|
|
// If we have cache enabled let's look for the md5 of the function in the cache
|
|
if(cacheFunctions) {
|
|
var hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString;
|
|
// Got to do this to avoid V8 deoptimizing the call due to finding eval
|
|
object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
|
|
} else {
|
|
// Set directly
|
|
object[name] = isolateEval(functionString);
|
|
}
|
|
} else {
|
|
object[name] = new Code(functionString, {});
|
|
}
|
|
|
|
// Update parse index position
|
|
index = index + stringSize;
|
|
break;
|
|
case BSON.BSON_DATA_CODE_W_SCOPE:
|
|
// Read the content of the field
|
|
var totalSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
|
|
// Javascript function
|
|
var functionString = supportsBuffer && Buffer.isBuffer(buffer) ? buffer.toString('utf8', index, index + stringSize - 1) : convertUint8ArrayToUtf8String(buffer, index, index + stringSize - 1);
|
|
// Update parse index position
|
|
index = index + stringSize;
|
|
// Parse the element
|
|
options['index'] = index;
|
|
// Decode the size of the object document
|
|
var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
|
|
// Decode the scope object
|
|
var scopeObject = BSON.deserialize(buffer, options, false);
|
|
// Adjust the index
|
|
index = index + objectSize;
|
|
|
|
// If we are evaluating the functions
|
|
if(evalFunctions) {
|
|
// Contains the value we are going to set
|
|
var value = null;
|
|
// If we have cache enabled let's look for the md5 of the function in the cache
|
|
if(cacheFunctions) {
|
|
var hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString;
|
|
// Got to do this to avoid V8 deoptimizing the call due to finding eval
|
|
object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
|
|
} else {
|
|
// Set directly
|
|
object[name] = isolateEval(functionString);
|
|
}
|
|
|
|
// Set the scope on the object
|
|
object[name].scope = scopeObject;
|
|
} else {
|
|
object[name] = new Code(functionString, scopeObject);
|
|
}
|
|
|
|
// Add string to object
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check if we have a db ref object
|
|
if(object['$id'] != null) object = new DBRef(object['$ref'], object['$id'], object['$db']);
|
|
|
|
// Return the final objects
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Check if key name is valid.
|
|
*
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
BSON.checkKey = function checkKey (key, dollarsAndDotsOk) {
|
|
if (!key.length) return;
|
|
// Check if we have a legal key for the object
|
|
if (!!~key.indexOf("\x00")) {
|
|
// The BSON spec doesn't allow keys with null bytes because keys are
|
|
// null-terminated.
|
|
throw Error("key " + key + " must not contain null bytes");
|
|
}
|
|
if (!dollarsAndDotsOk) {
|
|
if('$' == key[0]) {
|
|
throw Error("key " + key + " must not start with '$'");
|
|
} else if (!!~key.indexOf('.')) {
|
|
throw Error("key " + key + " must not contain '.'");
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Deserialize data as BSON.
|
|
*
|
|
* Options
|
|
* - **evalFunctions** {Boolean, default:false}, evaluate functions in the BSON document scoped to the object deserialized.
|
|
* - **cacheFunctions** {Boolean, default:false}, cache evaluated functions for reuse.
|
|
* - **cacheFunctionsCrc32** {Boolean, default:false}, use a crc32 code for caching, otherwise use the string of the function.
|
|
*
|
|
* @param {Buffer} buffer the buffer containing the serialized set of BSON documents.
|
|
* @param {Object} [options] additional options used for the deserialization.
|
|
* @param {Boolean} [isArray] ignore used for recursive parsing.
|
|
* @return {Object} returns the deserialized Javascript Object.
|
|
* @api public
|
|
*/
|
|
BSON.prototype.deserialize = function(data, options) {
|
|
return BSON.deserialize(data, options);
|
|
}
|
|
|
|
/**
|
|
* Deserialize stream data as BSON documents.
|
|
*
|
|
* Options
|
|
* - **evalFunctions** {Boolean, default:false}, evaluate functions in the BSON document scoped to the object deserialized.
|
|
* - **cacheFunctions** {Boolean, default:false}, cache evaluated functions for reuse.
|
|
* - **cacheFunctionsCrc32** {Boolean, default:false}, use a crc32 code for caching, otherwise use the string of the function.
|
|
*
|
|
* @param {Buffer} data the buffer containing the serialized set of BSON documents.
|
|
* @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.
|
|
* @param {Number} numberOfDocuments number of documents to deserialize.
|
|
* @param {Array} documents an array where to store the deserialized documents.
|
|
* @param {Number} docStartIndex the index in the documents array from where to start inserting documents.
|
|
* @param {Object} [options] additional options used for the deserialization.
|
|
* @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.
|
|
* @api public
|
|
*/
|
|
BSON.prototype.deserializeStream = function(data, startIndex, numberOfDocuments, documents, docStartIndex, options) {
|
|
return BSON.deserializeStream(data, startIndex, numberOfDocuments, documents, docStartIndex, options);
|
|
}
|
|
|
|
/**
|
|
* Serialize a Javascript object.
|
|
*
|
|
* @param {Object} object the Javascript object to serialize.
|
|
* @param {Boolean} checkKeys the serializer will check if keys are valid.
|
|
* @param {Boolean} asBuffer return the serialized object as a Buffer object **(ignore)**.
|
|
* @param {Boolean} serializeFunctions serialize the javascript functions **(default:false)**.
|
|
* @return {Buffer} returns the Buffer object containing the serialized object.
|
|
* @api public
|
|
*/
|
|
BSON.prototype.serialize = function(object, checkKeys, asBuffer, serializeFunctions) {
|
|
return BSON.serialize(object, checkKeys, asBuffer, serializeFunctions);
|
|
}
|
|
|
|
/**
|
|
* Calculate the bson size for a passed in Javascript object.
|
|
*
|
|
* @param {Object} object the Javascript object to calculate the BSON byte size for.
|
|
* @param {Boolean} [serializeFunctions] serialize all functions in the object **(default:false)**.
|
|
* @return {Number} returns the number of bytes the BSON object will take up.
|
|
* @api public
|
|
*/
|
|
BSON.prototype.calculateObjectSize = function(object, serializeFunctions) {
|
|
return BSON.calculateObjectSize(object, serializeFunctions);
|
|
}
|
|
|
|
/**
|
|
* Serialize a Javascript object using a predefined Buffer and index into the buffer, useful when pre-allocating the space for serialization.
|
|
*
|
|
* @param {Object} object the Javascript object to serialize.
|
|
* @param {Boolean} checkKeys the serializer will check if keys are valid.
|
|
* @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.
|
|
* @param {Number} index the index in the buffer where we wish to start serializing into.
|
|
* @param {Boolean} serializeFunctions serialize the javascript functions **(default:false)**.
|
|
* @return {Number} returns the new write index in the Buffer.
|
|
* @api public
|
|
*/
|
|
BSON.prototype.serializeWithBufferAndIndex = function(object, checkKeys, buffer, startIndex, serializeFunctions) {
|
|
return BSON.serializeWithBufferAndIndex(object, checkKeys, buffer, startIndex, serializeFunctions);
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
exports.Code = Code;
|
|
exports.Symbol = Symbol;
|
|
exports.BSON = BSON;
|
|
exports.DBRef = DBRef;
|
|
exports.Binary = Binary;
|
|
exports.ObjectID = ObjectID;
|
|
exports.Long = Long;
|
|
exports.Timestamp = Timestamp;
|
|
exports.Double = Double;
|
|
exports.MinKey = MinKey;
|
|
exports.MaxKey = MaxKey;
|
|
|
|
},
|
|
|
|
|
|
|
|
'code': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON Code type.
|
|
*
|
|
* @class Represents the BSON Code type.
|
|
* @param {String|Function} code a string or function.
|
|
* @param {Object} [scope] an optional scope for the function.
|
|
* @return {Code}
|
|
*/
|
|
function Code(code, scope) {
|
|
if(!(this instanceof Code)) return new Code(code, scope);
|
|
|
|
this._bsontype = 'Code';
|
|
this.code = code;
|
|
this.scope = scope == null ? {} : scope;
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Code.prototype.toJSON = function() {
|
|
return {scope:this.scope, code:this.code};
|
|
}
|
|
|
|
exports.Code = Code;
|
|
},
|
|
|
|
|
|
|
|
'db_ref': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON DBRef type.
|
|
*
|
|
* @class Represents the BSON DBRef type.
|
|
* @param {String} namespace the collection name.
|
|
* @param {ObjectID} oid the reference ObjectID.
|
|
* @param {String} [db] optional db name, if omitted the reference is local to the current db.
|
|
* @return {DBRef}
|
|
*/
|
|
function DBRef(namespace, oid, db) {
|
|
if(!(this instanceof DBRef)) return new DBRef(namespace, oid, db);
|
|
|
|
this._bsontype = 'DBRef';
|
|
this.namespace = namespace;
|
|
this.oid = oid;
|
|
this.db = db;
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
DBRef.prototype.toJSON = function() {
|
|
return {
|
|
'$ref':this.namespace,
|
|
'$id':this.oid,
|
|
'$db':this.db == null ? '' : this.db
|
|
};
|
|
}
|
|
|
|
exports.DBRef = DBRef;
|
|
},
|
|
|
|
|
|
|
|
'double': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON Double type.
|
|
*
|
|
* @class Represents the BSON Double type.
|
|
* @param {Number} value the number we want to represent as a double.
|
|
* @return {Double}
|
|
*/
|
|
function Double(value) {
|
|
if(!(this instanceof Double)) return new Double(value);
|
|
|
|
this._bsontype = 'Double';
|
|
this.value = value;
|
|
}
|
|
|
|
/**
|
|
* Access the number value.
|
|
*
|
|
* @return {Number} returns the wrapped double number.
|
|
* @api public
|
|
*/
|
|
Double.prototype.valueOf = function() {
|
|
return this.value;
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Double.prototype.toJSON = function() {
|
|
return this.value;
|
|
}
|
|
|
|
exports.Double = Double;
|
|
},
|
|
|
|
|
|
|
|
'float_parser': function(module, exports, global, require, undefined){
|
|
// 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
|
|
|
|
var 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);
|
|
};
|
|
|
|
var 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;
|
|
};
|
|
|
|
exports.readIEEE754 = readIEEE754;
|
|
exports.writeIEEE754 = writeIEEE754;
|
|
},
|
|
|
|
|
|
|
|
'index': function(module, exports, global, require, undefined){
|
|
try {
|
|
exports.BSONPure = require('./bson');
|
|
exports.BSONNative = require('../../ext');
|
|
} catch(err) {
|
|
// do nothing
|
|
}
|
|
|
|
[ './binary_parser'
|
|
, './binary'
|
|
, './code'
|
|
, './db_ref'
|
|
, './double'
|
|
, './max_key'
|
|
, './min_key'
|
|
, './objectid'
|
|
, './symbol'
|
|
, './timestamp'
|
|
, './long'].forEach(function (path) {
|
|
var module = require('./' + path);
|
|
for (var i in module) {
|
|
exports[i] = module[i];
|
|
}
|
|
});
|
|
|
|
// Exports all the classes for the NATIVE JS BSON Parser
|
|
exports.native = function() {
|
|
var classes = {};
|
|
// Map all the classes
|
|
[ './binary_parser'
|
|
, './binary'
|
|
, './code'
|
|
, './db_ref'
|
|
, './double'
|
|
, './max_key'
|
|
, './min_key'
|
|
, './objectid'
|
|
, './symbol'
|
|
, './timestamp'
|
|
, './long'
|
|
, '../../ext'
|
|
].forEach(function (path) {
|
|
var module = require('./' + path);
|
|
for (var i in module) {
|
|
classes[i] = module[i];
|
|
}
|
|
});
|
|
// Return classes list
|
|
return classes;
|
|
}
|
|
|
|
// Exports all the classes for the PURE JS BSON Parser
|
|
exports.pure = function() {
|
|
var classes = {};
|
|
// Map all the classes
|
|
[ './binary_parser'
|
|
, './binary'
|
|
, './code'
|
|
, './db_ref'
|
|
, './double'
|
|
, './max_key'
|
|
, './min_key'
|
|
, './objectid'
|
|
, './symbol'
|
|
, './timestamp'
|
|
, './long'
|
|
, '././bson'].forEach(function (path) {
|
|
var module = require('./' + path);
|
|
for (var i in module) {
|
|
classes[i] = module[i];
|
|
}
|
|
});
|
|
// Return classes list
|
|
return classes;
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
'long': function(module, exports, global, require, undefined){
|
|
// 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
|
|
|
|
/**
|
|
* Defines a 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 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 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.
|
|
*
|
|
* @class Represents the BSON Long type.
|
|
* @param {Number} low the low (signed) 32 bits of the Long.
|
|
* @param {Number} high the high (signed) 32 bits of the Long.
|
|
*/
|
|
function Long(low, high) {
|
|
if(!(this instanceof Long)) return new Long(low, high);
|
|
|
|
this._bsontype = 'Long';
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
this.low_ = low | 0; // force into 32 signed bits.
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
this.high_ = high | 0; // force into 32 signed bits.
|
|
};
|
|
|
|
/**
|
|
* Return the int value.
|
|
*
|
|
* @return {Number} the value, assuming it is a 32-bit integer.
|
|
* @api public
|
|
*/
|
|
Long.prototype.toInt = function() {
|
|
return this.low_;
|
|
};
|
|
|
|
/**
|
|
* Return the Number value.
|
|
*
|
|
* @return {Number} the closest floating-point representation to this value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.toNumber = function() {
|
|
return this.high_ * Long.TWO_PWR_32_DBL_ +
|
|
this.getLowBitsUnsigned();
|
|
};
|
|
|
|
/**
|
|
* Return the JSON value.
|
|
*
|
|
* @return {String} the JSON representation.
|
|
* @api public
|
|
*/
|
|
Long.prototype.toJSON = function() {
|
|
return this.toString();
|
|
}
|
|
|
|
/**
|
|
* Return the String value.
|
|
*
|
|
* @param {Number} [opt_radix] the radix in which the text should be written.
|
|
* @return {String} the textual representation of this value.
|
|
* @api public
|
|
*/
|
|
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(Long.MIN_VALUE)) {
|
|
// We need to change the 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 = 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 = 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 the high 32-bits value.
|
|
*
|
|
* @return {Number} the high 32-bits as a signed value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.getHighBits = function() {
|
|
return this.high_;
|
|
};
|
|
|
|
/**
|
|
* Return the low 32-bits value.
|
|
*
|
|
* @return {Number} the low 32-bits as a signed value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.getLowBits = function() {
|
|
return this.low_;
|
|
};
|
|
|
|
/**
|
|
* Return the low unsigned 32-bits value.
|
|
*
|
|
* @return {Number} the low 32-bits as an unsigned value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.getLowBitsUnsigned = function() {
|
|
return (this.low_ >= 0) ?
|
|
this.low_ : Long.TWO_PWR_32_DBL_ + this.low_;
|
|
};
|
|
|
|
/**
|
|
* Returns the number of bits needed to represent the absolute value of this Long.
|
|
*
|
|
* @return {Number} Returns the number of bits needed to represent the absolute value of this Long.
|
|
* @api public
|
|
*/
|
|
Long.prototype.getNumBitsAbs = function() {
|
|
if (this.isNegative()) {
|
|
if (this.equals(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 whether this value is zero.
|
|
*
|
|
* @return {Boolean} whether this value is zero.
|
|
* @api public
|
|
*/
|
|
Long.prototype.isZero = function() {
|
|
return this.high_ == 0 && this.low_ == 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this value is negative.
|
|
*
|
|
* @return {Boolean} whether this value is negative.
|
|
* @api public
|
|
*/
|
|
Long.prototype.isNegative = function() {
|
|
return this.high_ < 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this value is odd.
|
|
*
|
|
* @return {Boolean} whether this value is odd.
|
|
* @api public
|
|
*/
|
|
Long.prototype.isOdd = function() {
|
|
return (this.low_ & 1) == 1;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long equals the other
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long equals the other
|
|
* @api public
|
|
*/
|
|
Long.prototype.equals = function(other) {
|
|
return (this.high_ == other.high_) && (this.low_ == other.low_);
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long does not equal the other.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long does not equal the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.notEquals = function(other) {
|
|
return (this.high_ != other.high_) || (this.low_ != other.low_);
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long is less than the other.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long is less than the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.lessThan = function(other) {
|
|
return this.compare(other) < 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long is less than or equal to the other.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long is less than or equal to the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.lessThanOrEqual = function(other) {
|
|
return this.compare(other) <= 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long is greater than the other.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long is greater than the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.greaterThan = function(other) {
|
|
return this.compare(other) > 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Long is greater than or equal to the other.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} whether this Long is greater than or equal to the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.greaterThanOrEqual = function(other) {
|
|
return this.compare(other) >= 0;
|
|
};
|
|
|
|
/**
|
|
* Compares this Long with the given one.
|
|
*
|
|
* @param {Long} other Long to compare against.
|
|
* @return {Boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.
|
|
* @api public
|
|
*/
|
|
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;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The negation of this value.
|
|
*
|
|
* @return {Long} the negation of this value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.negate = function() {
|
|
if (this.equals(Long.MIN_VALUE)) {
|
|
return Long.MIN_VALUE;
|
|
} else {
|
|
return this.not().add(Long.ONE);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the sum of this and the given Long.
|
|
*
|
|
* @param {Long} other Long to add to this one.
|
|
* @return {Long} the sum of this and the given Long.
|
|
* @api public
|
|
*/
|
|
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 Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
|
};
|
|
|
|
/**
|
|
* Returns the difference of this and the given Long.
|
|
*
|
|
* @param {Long} other Long to subtract from this.
|
|
* @return {Long} the difference of this and the given Long.
|
|
* @api public
|
|
*/
|
|
Long.prototype.subtract = function(other) {
|
|
return this.add(other.negate());
|
|
};
|
|
|
|
/**
|
|
* Returns the product of this and the given Long.
|
|
*
|
|
* @param {Long} other Long to multiply with this.
|
|
* @return {Long} the product of this and the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.multiply = function(other) {
|
|
if (this.isZero()) {
|
|
return Long.ZERO;
|
|
} else if (other.isZero()) {
|
|
return Long.ZERO;
|
|
}
|
|
|
|
if (this.equals(Long.MIN_VALUE)) {
|
|
return other.isOdd() ? Long.MIN_VALUE : Long.ZERO;
|
|
} else if (other.equals(Long.MIN_VALUE)) {
|
|
return this.isOdd() ? Long.MIN_VALUE : 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(Long.TWO_PWR_24_) &&
|
|
other.lessThan(Long.TWO_PWR_24_)) {
|
|
return 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 Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
|
};
|
|
|
|
/**
|
|
* Returns this Long divided by the given one.
|
|
*
|
|
* @param {Long} other Long by which to divide.
|
|
* @return {Long} this Long divided by the given one.
|
|
* @api public
|
|
*/
|
|
Long.prototype.div = function(other) {
|
|
if (other.isZero()) {
|
|
throw Error('division by zero');
|
|
} else if (this.isZero()) {
|
|
return Long.ZERO;
|
|
}
|
|
|
|
if (this.equals(Long.MIN_VALUE)) {
|
|
if (other.equals(Long.ONE) ||
|
|
other.equals(Long.NEG_ONE)) {
|
|
return Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
|
|
} else if (other.equals(Long.MIN_VALUE)) {
|
|
return 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(Long.ZERO)) {
|
|
return other.isNegative() ? Long.ONE : Long.NEG_ONE;
|
|
} else {
|
|
var rem = this.subtract(other.multiply(approx));
|
|
var result = approx.add(rem.div(other));
|
|
return result;
|
|
}
|
|
}
|
|
} else if (other.equals(Long.MIN_VALUE)) {
|
|
return 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 = 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 = Long.fromNumber(approx);
|
|
var approxRem = approxRes.multiply(other);
|
|
while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
|
|
approx -= delta;
|
|
approxRes = 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 = Long.ONE;
|
|
}
|
|
|
|
res = res.add(approxRes);
|
|
rem = rem.subtract(approxRem);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
/**
|
|
* Returns this Long modulo the given one.
|
|
*
|
|
* @param {Long} other Long by which to mod.
|
|
* @return {Long} this Long modulo the given one.
|
|
* @api public
|
|
*/
|
|
Long.prototype.modulo = function(other) {
|
|
return this.subtract(this.div(other).multiply(other));
|
|
};
|
|
|
|
/**
|
|
* The bitwise-NOT of this value.
|
|
*
|
|
* @return {Long} the bitwise-NOT of this value.
|
|
* @api public
|
|
*/
|
|
Long.prototype.not = function() {
|
|
return Long.fromBits(~this.low_, ~this.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-AND of this Long and the given one.
|
|
*
|
|
* @param {Long} other the Long with which to AND.
|
|
* @return {Long} the bitwise-AND of this and the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.and = function(other) {
|
|
return Long.fromBits(this.low_ & other.low_, this.high_ & other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-OR of this Long and the given one.
|
|
*
|
|
* @param {Long} other the Long with which to OR.
|
|
* @return {Long} the bitwise-OR of this and the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.or = function(other) {
|
|
return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-XOR of this Long and the given one.
|
|
*
|
|
* @param {Long} other the Long with which to XOR.
|
|
* @return {Long} the bitwise-XOR of this and the other.
|
|
* @api public
|
|
*/
|
|
Long.prototype.xor = function(other) {
|
|
return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns this Long with bits shifted to the left by the given amount.
|
|
*
|
|
* @param {Number} numBits the number of bits by which to shift.
|
|
* @return {Long} this shifted to the left by the given amount.
|
|
* @api public
|
|
*/
|
|
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 Long.fromBits(
|
|
low << numBits,
|
|
(high << numBits) | (low >>> (32 - numBits)));
|
|
} else {
|
|
return Long.fromBits(0, low << (numBits - 32));
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns this Long with bits shifted to the right by the given amount.
|
|
*
|
|
* @param {Number} numBits the number of bits by which to shift.
|
|
* @return {Long} this shifted to the right by the given amount.
|
|
* @api public
|
|
*/
|
|
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 Long.fromBits(
|
|
(low >>> numBits) | (high << (32 - numBits)),
|
|
high >> numBits);
|
|
} else {
|
|
return Long.fromBits(
|
|
high >> (numBits - 32),
|
|
high >= 0 ? 0 : -1);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns this 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 {Long} this shifted to the right by the given amount, with zeros placed into the new leading bits.
|
|
* @api public
|
|
*/
|
|
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 Long.fromBits(
|
|
(low >>> numBits) | (high << (32 - numBits)),
|
|
high >>> numBits);
|
|
} else if (numBits == 32) {
|
|
return Long.fromBits(high, 0);
|
|
} else {
|
|
return Long.fromBits(high >>> (numBits - 32), 0);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns a Long representing the given (32-bit) integer value.
|
|
*
|
|
* @param {Number} value the 32-bit integer in question.
|
|
* @return {Long} the corresponding Long value.
|
|
* @api public
|
|
*/
|
|
Long.fromInt = function(value) {
|
|
if (-128 <= value && value < 128) {
|
|
var cachedObj = Long.INT_CACHE_[value];
|
|
if (cachedObj) {
|
|
return cachedObj;
|
|
}
|
|
}
|
|
|
|
var obj = new Long(value | 0, value < 0 ? -1 : 0);
|
|
if (-128 <= value && value < 128) {
|
|
Long.INT_CACHE_[value] = obj;
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
/**
|
|
* Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
|
|
*
|
|
* @param {Number} value the number in question.
|
|
* @return {Long} the corresponding Long value.
|
|
* @api public
|
|
*/
|
|
Long.fromNumber = function(value) {
|
|
if (isNaN(value) || !isFinite(value)) {
|
|
return Long.ZERO;
|
|
} else if (value <= -Long.TWO_PWR_63_DBL_) {
|
|
return Long.MIN_VALUE;
|
|
} else if (value + 1 >= Long.TWO_PWR_63_DBL_) {
|
|
return Long.MAX_VALUE;
|
|
} else if (value < 0) {
|
|
return Long.fromNumber(-value).negate();
|
|
} else {
|
|
return new Long(
|
|
(value % Long.TWO_PWR_32_DBL_) | 0,
|
|
(value / Long.TWO_PWR_32_DBL_) | 0);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns a 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 {Long} the corresponding Long value.
|
|
* @api public
|
|
*/
|
|
Long.fromBits = function(lowBits, highBits) {
|
|
return new Long(lowBits, highBits);
|
|
};
|
|
|
|
/**
|
|
* Returns a Long representation of the given string, written using the given radix.
|
|
*
|
|
* @param {String} str the textual representation of the Long.
|
|
* @param {Number} opt_radix the radix in which the text is written.
|
|
* @return {Long} the corresponding Long value.
|
|
* @api public
|
|
*/
|
|
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 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 = Long.fromNumber(Math.pow(radix, 8));
|
|
|
|
var result = 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 = Long.fromNumber(Math.pow(radix, size));
|
|
result = result.multiply(power).add(Long.fromNumber(value));
|
|
} else {
|
|
result = result.multiply(radixToPower);
|
|
result = result.add(Long.fromNumber(value));
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
|
|
// from* methods on which they depend.
|
|
|
|
|
|
/**
|
|
* A cache of the Long representations of small integer values.
|
|
* @type {Object}
|
|
* @api private
|
|
*/
|
|
Long.INT_CACHE_ = {};
|
|
|
|
// 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}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_16_DBL_ = 1 << 16;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_24_DBL_ = 1 << 24;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_32_DBL_ = Long.TWO_PWR_16_DBL_ * Long.TWO_PWR_16_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_31_DBL_ = Long.TWO_PWR_32_DBL_ / 2;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_48_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_16_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_64_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_32_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_63_DBL_ = Long.TWO_PWR_64_DBL_ / 2;
|
|
|
|
/** @type {Long} */
|
|
Long.ZERO = Long.fromInt(0);
|
|
|
|
/** @type {Long} */
|
|
Long.ONE = Long.fromInt(1);
|
|
|
|
/** @type {Long} */
|
|
Long.NEG_ONE = Long.fromInt(-1);
|
|
|
|
/** @type {Long} */
|
|
Long.MAX_VALUE =
|
|
Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
|
|
|
|
/** @type {Long} */
|
|
Long.MIN_VALUE = Long.fromBits(0, 0x80000000 | 0);
|
|
|
|
/**
|
|
* @type {Long}
|
|
* @api private
|
|
*/
|
|
Long.TWO_PWR_24_ = Long.fromInt(1 << 24);
|
|
|
|
/**
|
|
* Expose.
|
|
*/
|
|
exports.Long = Long;
|
|
},
|
|
|
|
|
|
|
|
'max_key': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON MaxKey type.
|
|
*
|
|
* @class Represents the BSON MaxKey type.
|
|
* @return {MaxKey}
|
|
*/
|
|
function MaxKey() {
|
|
if(!(this instanceof MaxKey)) return new MaxKey();
|
|
|
|
this._bsontype = 'MaxKey';
|
|
}
|
|
|
|
exports.MaxKey = MaxKey;
|
|
},
|
|
|
|
|
|
|
|
'min_key': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON MinKey type.
|
|
*
|
|
* @class Represents the BSON MinKey type.
|
|
* @return {MinKey}
|
|
*/
|
|
function MinKey() {
|
|
if(!(this instanceof MinKey)) return new MinKey();
|
|
|
|
this._bsontype = 'MinKey';
|
|
}
|
|
|
|
exports.MinKey = MinKey;
|
|
},
|
|
|
|
|
|
|
|
'objectid': function(module, exports, global, require, undefined){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
var BinaryParser = require('./binary_parser').BinaryParser;
|
|
|
|
/**
|
|
* Machine id.
|
|
*
|
|
* Create a random 3-byte value (i.e. unique for this
|
|
* process). Other drivers use a md5 of the machine id here, but
|
|
* that would mean an asyc call to gethostname, so we don't bother.
|
|
*/
|
|
var MACHINE_ID = parseInt(Math.random() * 0xFFFFFF, 10);
|
|
|
|
// Regular expression that checks for hex value
|
|
var checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$");
|
|
|
|
/**
|
|
* Create a new ObjectID instance
|
|
*
|
|
* @class Represents the BSON ObjectID type
|
|
* @param {String|Number} id Can be a 24 byte hex string, 12 byte binary string or a Number.
|
|
* @return {Object} instance of ObjectID.
|
|
*/
|
|
var ObjectID = function ObjectID(id, _hex) {
|
|
if(!(this instanceof ObjectID)) return new ObjectID(id, _hex);
|
|
|
|
this._bsontype = 'ObjectID';
|
|
var __id = null;
|
|
|
|
// Throw an error if it's not a valid setup
|
|
if(id != null && 'number' != typeof id && (id.length != 12 && id.length != 24))
|
|
throw new Error("Argument passed in must be a single String of 12 bytes or a string of 24 hex characters");
|
|
|
|
// Generate id based on the input
|
|
if(id == null || typeof id == 'number') {
|
|
// convert to 12 byte binary string
|
|
this.id = this.generate(id);
|
|
} else if(id != null && id.length === 12) {
|
|
// assume 12 byte string
|
|
this.id = id;
|
|
} else if(checkForHexRegExp.test(id)) {
|
|
return ObjectID.createFromHexString(id);
|
|
} else {
|
|
throw new Error("Value passed in is not a valid 24 character hex string");
|
|
}
|
|
|
|
if(ObjectID.cacheHexString) this.__id = this.toHexString();
|
|
};
|
|
|
|
// Allow usage of ObjectId as well as ObjectID
|
|
var ObjectId = ObjectID;
|
|
|
|
// Precomputed hex table enables speedy hex string conversion
|
|
var hexTable = [];
|
|
for (var i = 0; i < 256; i++) {
|
|
hexTable[i] = (i <= 15 ? '0' : '') + i.toString(16);
|
|
}
|
|
|
|
/**
|
|
* Return the ObjectID id as a 24 byte hex string representation
|
|
*
|
|
* @return {String} return the 24 byte hex string representation.
|
|
* @api public
|
|
*/
|
|
ObjectID.prototype.toHexString = function() {
|
|
if(ObjectID.cacheHexString && this.__id) return this.__id;
|
|
|
|
var hexString = '';
|
|
|
|
for (var i = 0; i < this.id.length; i++) {
|
|
hexString += hexTable[this.id.charCodeAt(i)];
|
|
}
|
|
|
|
if(ObjectID.cacheHexString) this.__id = hexString;
|
|
return hexString;
|
|
};
|
|
|
|
/**
|
|
* Update the ObjectID index used in generating new ObjectID's on the driver
|
|
*
|
|
* @return {Number} returns next index value.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.get_inc = function() {
|
|
return ObjectID.index = (ObjectID.index + 1) % 0xFFFFFF;
|
|
};
|
|
|
|
/**
|
|
* Update the ObjectID index used in generating new ObjectID's on the driver
|
|
*
|
|
* @return {Number} returns next index value.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.getInc = function() {
|
|
return this.get_inc();
|
|
};
|
|
|
|
/**
|
|
* Generate a 12 byte id string used in ObjectID's
|
|
*
|
|
* @param {Number} [time] optional parameter allowing to pass in a second based timestamp.
|
|
* @return {String} return the 12 byte id binary string.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.generate = function(time) {
|
|
if ('number' == typeof time) {
|
|
var time4Bytes = BinaryParser.encodeInt(time, 32, true, true);
|
|
/* for time-based ObjectID the bytes following the time will be zeroed */
|
|
var machine3Bytes = BinaryParser.encodeInt(MACHINE_ID, 24, false);
|
|
var pid2Bytes = BinaryParser.fromShort(typeof process === 'undefined' ? Math.floor(Math.random() * 100000) : process.pid);
|
|
var index3Bytes = BinaryParser.encodeInt(this.get_inc(), 24, false, true);
|
|
} else {
|
|
var unixTime = parseInt(Date.now()/1000,10);
|
|
var time4Bytes = BinaryParser.encodeInt(unixTime, 32, true, true);
|
|
var machine3Bytes = BinaryParser.encodeInt(MACHINE_ID, 24, false);
|
|
var pid2Bytes = BinaryParser.fromShort(typeof process === 'undefined' ? Math.floor(Math.random() * 100000) : process.pid);
|
|
var index3Bytes = BinaryParser.encodeInt(this.get_inc(), 24, false, true);
|
|
}
|
|
|
|
return time4Bytes + machine3Bytes + pid2Bytes + index3Bytes;
|
|
};
|
|
|
|
/**
|
|
* Converts the id into a 24 byte hex string for printing
|
|
*
|
|
* @return {String} return the 24 byte hex string representation.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.toString = function() {
|
|
return this.toHexString();
|
|
};
|
|
|
|
/**
|
|
* Converts to a string representation of this Id.
|
|
*
|
|
* @return {String} return the 24 byte hex string representation.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.inspect = ObjectID.prototype.toString;
|
|
|
|
/**
|
|
* Converts to its JSON representation.
|
|
*
|
|
* @return {String} return the 24 byte hex string representation.
|
|
* @api private
|
|
*/
|
|
ObjectID.prototype.toJSON = function() {
|
|
return this.toHexString();
|
|
};
|
|
|
|
/**
|
|
* Compares the equality of this ObjectID with `otherID`.
|
|
*
|
|
* @param {Object} otherID ObjectID instance to compare against.
|
|
* @return {Bool} the result of comparing two ObjectID's
|
|
* @api public
|
|
*/
|
|
ObjectID.prototype.equals = function equals (otherID) {
|
|
var id = (otherID instanceof ObjectID || otherID.toHexString)
|
|
? otherID.id
|
|
: ObjectID.createFromHexString(otherID).id;
|
|
|
|
return this.id === id;
|
|
}
|
|
|
|
/**
|
|
* Returns the generation date (accurate up to the second) that this ID was generated.
|
|
*
|
|
* @return {Date} the generation date
|
|
* @api public
|
|
*/
|
|
ObjectID.prototype.getTimestamp = function() {
|
|
var timestamp = new Date();
|
|
timestamp.setTime(Math.floor(BinaryParser.decodeInt(this.id.substring(0,4), 32, true, true)) * 1000);
|
|
return timestamp;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
ObjectID.index = parseInt(Math.random() * 0xFFFFFF, 10);
|
|
|
|
ObjectID.createPk = function createPk () {
|
|
return new ObjectID();
|
|
};
|
|
|
|
/**
|
|
* Creates an ObjectID from a second based number, with the rest of the ObjectID zeroed out. Used for comparisons or sorting the ObjectID.
|
|
*
|
|
* @param {Number} time an integer number representing a number of seconds.
|
|
* @return {ObjectID} return the created ObjectID
|
|
* @api public
|
|
*/
|
|
ObjectID.createFromTime = function createFromTime (time) {
|
|
var id = BinaryParser.encodeInt(time, 32, true, true) +
|
|
BinaryParser.encodeInt(0, 64, true, true);
|
|
return new ObjectID(id);
|
|
};
|
|
|
|
/**
|
|
* Creates an ObjectID from a hex string representation of an ObjectID.
|
|
*
|
|
* @param {String} hexString create a ObjectID from a passed in 24 byte hexstring.
|
|
* @return {ObjectID} return the created ObjectID
|
|
* @api public
|
|
*/
|
|
ObjectID.createFromHexString = function createFromHexString (hexString) {
|
|
// Throw an error if it's not a valid setup
|
|
if(typeof hexString === 'undefined' || hexString != null && hexString.length != 24)
|
|
throw new Error("Argument passed in must be a single String of 12 bytes or a string of 24 hex characters");
|
|
|
|
var len = hexString.length;
|
|
|
|
if(len > 12*2) {
|
|
throw new Error('Id cannot be longer than 12 bytes');
|
|
}
|
|
|
|
var result = ''
|
|
, string
|
|
, number;
|
|
|
|
for (var index = 0; index < len; index += 2) {
|
|
string = hexString.substr(index, 2);
|
|
number = parseInt(string, 16);
|
|
result += BinaryParser.fromByte(number);
|
|
}
|
|
|
|
return new ObjectID(result, hexString);
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
*/
|
|
Object.defineProperty(ObjectID.prototype, "generationTime", {
|
|
enumerable: true
|
|
, get: function () {
|
|
return Math.floor(BinaryParser.decodeInt(this.id.substring(0,4), 32, true, true));
|
|
}
|
|
, set: function (value) {
|
|
var value = BinaryParser.encodeInt(value, 32, true, true);
|
|
this.id = value + this.id.substr(4);
|
|
// delete this.__id;
|
|
this.toHexString();
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Expose.
|
|
*/
|
|
exports.ObjectID = ObjectID;
|
|
exports.ObjectId = ObjectID;
|
|
|
|
},
|
|
|
|
|
|
|
|
'symbol': function(module, exports, global, require, undefined){
|
|
/**
|
|
* A class representation of the BSON Symbol type.
|
|
*
|
|
* @class Represents the BSON Symbol type.
|
|
* @param {String} value the string representing the symbol.
|
|
* @return {Symbol}
|
|
*/
|
|
function Symbol(value) {
|
|
if(!(this instanceof Symbol)) return new Symbol(value);
|
|
this._bsontype = 'Symbol';
|
|
this.value = value;
|
|
}
|
|
|
|
/**
|
|
* Access the wrapped string value.
|
|
*
|
|
* @return {String} returns the wrapped string.
|
|
* @api public
|
|
*/
|
|
Symbol.prototype.valueOf = function() {
|
|
return this.value;
|
|
};
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Symbol.prototype.toString = function() {
|
|
return this.value;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Symbol.prototype.inspect = function() {
|
|
return this.value;
|
|
}
|
|
|
|
/**
|
|
* @ignore
|
|
* @api private
|
|
*/
|
|
Symbol.prototype.toJSON = function() {
|
|
return this.value;
|
|
}
|
|
|
|
exports.Symbol = Symbol;
|
|
},
|
|
|
|
|
|
|
|
'timestamp': function(module, exports, global, require, undefined){
|
|
// 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
|
|
|
|
/**
|
|
* Defines a Timestamp class for representing a 64-bit two's-complement
|
|
* integer value, which faithfully simulates the behavior of a Java "Timestamp". This
|
|
* implementation is derived from TimestampLib 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 Timestamps.
|
|
*
|
|
* The internal representation of a Timestamp 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.
|
|
*
|
|
* @class Represents the BSON Timestamp type.
|
|
* @param {Number} low the low (signed) 32 bits of the Timestamp.
|
|
* @param {Number} high the high (signed) 32 bits of the Timestamp.
|
|
*/
|
|
function Timestamp(low, high) {
|
|
if(!(this instanceof Timestamp)) return new Timestamp(low, high);
|
|
this._bsontype = 'Timestamp';
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
this.low_ = low | 0; // force into 32 signed bits.
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
this.high_ = high | 0; // force into 32 signed bits.
|
|
};
|
|
|
|
/**
|
|
* Return the int value.
|
|
*
|
|
* @return {Number} the value, assuming it is a 32-bit integer.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.toInt = function() {
|
|
return this.low_;
|
|
};
|
|
|
|
/**
|
|
* Return the Number value.
|
|
*
|
|
* @return {Number} the closest floating-point representation to this value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.toNumber = function() {
|
|
return this.high_ * Timestamp.TWO_PWR_32_DBL_ +
|
|
this.getLowBitsUnsigned();
|
|
};
|
|
|
|
/**
|
|
* Return the JSON value.
|
|
*
|
|
* @return {String} the JSON representation.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.toJSON = function() {
|
|
return this.toString();
|
|
}
|
|
|
|
/**
|
|
* Return the String value.
|
|
*
|
|
* @param {Number} [opt_radix] the radix in which the text should be written.
|
|
* @return {String} the textual representation of this value.
|
|
* @api public
|
|
*/
|
|
Timestamp.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(Timestamp.MIN_VALUE)) {
|
|
// We need to change the Timestamp value before it can be negated, so we remove
|
|
// the bottom-most digit in this base and then recurse to do the rest.
|
|
var radixTimestamp = Timestamp.fromNumber(radix);
|
|
var div = this.div(radixTimestamp);
|
|
var rem = div.multiply(radixTimestamp).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 = Timestamp.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 the high 32-bits value.
|
|
*
|
|
* @return {Number} the high 32-bits as a signed value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.getHighBits = function() {
|
|
return this.high_;
|
|
};
|
|
|
|
/**
|
|
* Return the low 32-bits value.
|
|
*
|
|
* @return {Number} the low 32-bits as a signed value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.getLowBits = function() {
|
|
return this.low_;
|
|
};
|
|
|
|
/**
|
|
* Return the low unsigned 32-bits value.
|
|
*
|
|
* @return {Number} the low 32-bits as an unsigned value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.getLowBitsUnsigned = function() {
|
|
return (this.low_ >= 0) ?
|
|
this.low_ : Timestamp.TWO_PWR_32_DBL_ + this.low_;
|
|
};
|
|
|
|
/**
|
|
* Returns the number of bits needed to represent the absolute value of this Timestamp.
|
|
*
|
|
* @return {Number} Returns the number of bits needed to represent the absolute value of this Timestamp.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.getNumBitsAbs = function() {
|
|
if (this.isNegative()) {
|
|
if (this.equals(Timestamp.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 whether this value is zero.
|
|
*
|
|
* @return {Boolean} whether this value is zero.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.isZero = function() {
|
|
return this.high_ == 0 && this.low_ == 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this value is negative.
|
|
*
|
|
* @return {Boolean} whether this value is negative.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.isNegative = function() {
|
|
return this.high_ < 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this value is odd.
|
|
*
|
|
* @return {Boolean} whether this value is odd.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.isOdd = function() {
|
|
return (this.low_ & 1) == 1;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp equals the other
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp equals the other
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.equals = function(other) {
|
|
return (this.high_ == other.high_) && (this.low_ == other.low_);
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp does not equal the other.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp does not equal the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.notEquals = function(other) {
|
|
return (this.high_ != other.high_) || (this.low_ != other.low_);
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp is less than the other.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp is less than the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.lessThan = function(other) {
|
|
return this.compare(other) < 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp is less than or equal to the other.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp is less than or equal to the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.lessThanOrEqual = function(other) {
|
|
return this.compare(other) <= 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp is greater than the other.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp is greater than the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.greaterThan = function(other) {
|
|
return this.compare(other) > 0;
|
|
};
|
|
|
|
/**
|
|
* Return whether this Timestamp is greater than or equal to the other.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} whether this Timestamp is greater than or equal to the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.greaterThanOrEqual = function(other) {
|
|
return this.compare(other) >= 0;
|
|
};
|
|
|
|
/**
|
|
* Compares this Timestamp with the given one.
|
|
*
|
|
* @param {Timestamp} other Timestamp to compare against.
|
|
* @return {Boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.
|
|
* @api public
|
|
*/
|
|
Timestamp.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;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The negation of this value.
|
|
*
|
|
* @return {Timestamp} the negation of this value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.negate = function() {
|
|
if (this.equals(Timestamp.MIN_VALUE)) {
|
|
return Timestamp.MIN_VALUE;
|
|
} else {
|
|
return this.not().add(Timestamp.ONE);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the sum of this and the given Timestamp.
|
|
*
|
|
* @param {Timestamp} other Timestamp to add to this one.
|
|
* @return {Timestamp} the sum of this and the given Timestamp.
|
|
* @api public
|
|
*/
|
|
Timestamp.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 Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
|
};
|
|
|
|
/**
|
|
* Returns the difference of this and the given Timestamp.
|
|
*
|
|
* @param {Timestamp} other Timestamp to subtract from this.
|
|
* @return {Timestamp} the difference of this and the given Timestamp.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.subtract = function(other) {
|
|
return this.add(other.negate());
|
|
};
|
|
|
|
/**
|
|
* Returns the product of this and the given Timestamp.
|
|
*
|
|
* @param {Timestamp} other Timestamp to multiply with this.
|
|
* @return {Timestamp} the product of this and the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.multiply = function(other) {
|
|
if (this.isZero()) {
|
|
return Timestamp.ZERO;
|
|
} else if (other.isZero()) {
|
|
return Timestamp.ZERO;
|
|
}
|
|
|
|
if (this.equals(Timestamp.MIN_VALUE)) {
|
|
return other.isOdd() ? Timestamp.MIN_VALUE : Timestamp.ZERO;
|
|
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
|
return this.isOdd() ? Timestamp.MIN_VALUE : Timestamp.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 Timestamps are small, use float multiplication
|
|
if (this.lessThan(Timestamp.TWO_PWR_24_) &&
|
|
other.lessThan(Timestamp.TWO_PWR_24_)) {
|
|
return Timestamp.fromNumber(this.toNumber() * other.toNumber());
|
|
}
|
|
|
|
// Divide each Timestamp 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 Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
|
};
|
|
|
|
/**
|
|
* Returns this Timestamp divided by the given one.
|
|
*
|
|
* @param {Timestamp} other Timestamp by which to divide.
|
|
* @return {Timestamp} this Timestamp divided by the given one.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.div = function(other) {
|
|
if (other.isZero()) {
|
|
throw Error('division by zero');
|
|
} else if (this.isZero()) {
|
|
return Timestamp.ZERO;
|
|
}
|
|
|
|
if (this.equals(Timestamp.MIN_VALUE)) {
|
|
if (other.equals(Timestamp.ONE) ||
|
|
other.equals(Timestamp.NEG_ONE)) {
|
|
return Timestamp.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
|
|
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
|
return Timestamp.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(Timestamp.ZERO)) {
|
|
return other.isNegative() ? Timestamp.ONE : Timestamp.NEG_ONE;
|
|
} else {
|
|
var rem = this.subtract(other.multiply(approx));
|
|
var result = approx.add(rem.div(other));
|
|
return result;
|
|
}
|
|
}
|
|
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
|
return Timestamp.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 = Timestamp.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 = Timestamp.fromNumber(approx);
|
|
var approxRem = approxRes.multiply(other);
|
|
while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
|
|
approx -= delta;
|
|
approxRes = Timestamp.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 = Timestamp.ONE;
|
|
}
|
|
|
|
res = res.add(approxRes);
|
|
rem = rem.subtract(approxRem);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
/**
|
|
* Returns this Timestamp modulo the given one.
|
|
*
|
|
* @param {Timestamp} other Timestamp by which to mod.
|
|
* @return {Timestamp} this Timestamp modulo the given one.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.modulo = function(other) {
|
|
return this.subtract(this.div(other).multiply(other));
|
|
};
|
|
|
|
/**
|
|
* The bitwise-NOT of this value.
|
|
*
|
|
* @return {Timestamp} the bitwise-NOT of this value.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.not = function() {
|
|
return Timestamp.fromBits(~this.low_, ~this.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-AND of this Timestamp and the given one.
|
|
*
|
|
* @param {Timestamp} other the Timestamp with which to AND.
|
|
* @return {Timestamp} the bitwise-AND of this and the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.and = function(other) {
|
|
return Timestamp.fromBits(this.low_ & other.low_, this.high_ & other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-OR of this Timestamp and the given one.
|
|
*
|
|
* @param {Timestamp} other the Timestamp with which to OR.
|
|
* @return {Timestamp} the bitwise-OR of this and the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.or = function(other) {
|
|
return Timestamp.fromBits(this.low_ | other.low_, this.high_ | other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns the bitwise-XOR of this Timestamp and the given one.
|
|
*
|
|
* @param {Timestamp} other the Timestamp with which to XOR.
|
|
* @return {Timestamp} the bitwise-XOR of this and the other.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.xor = function(other) {
|
|
return Timestamp.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
|
|
};
|
|
|
|
/**
|
|
* Returns this Timestamp with bits shifted to the left by the given amount.
|
|
*
|
|
* @param {Number} numBits the number of bits by which to shift.
|
|
* @return {Timestamp} this shifted to the left by the given amount.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.shiftLeft = function(numBits) {
|
|
numBits &= 63;
|
|
if (numBits == 0) {
|
|
return this;
|
|
} else {
|
|
var low = this.low_;
|
|
if (numBits < 32) {
|
|
var high = this.high_;
|
|
return Timestamp.fromBits(
|
|
low << numBits,
|
|
(high << numBits) | (low >>> (32 - numBits)));
|
|
} else {
|
|
return Timestamp.fromBits(0, low << (numBits - 32));
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns this Timestamp with bits shifted to the right by the given amount.
|
|
*
|
|
* @param {Number} numBits the number of bits by which to shift.
|
|
* @return {Timestamp} this shifted to the right by the given amount.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.shiftRight = function(numBits) {
|
|
numBits &= 63;
|
|
if (numBits == 0) {
|
|
return this;
|
|
} else {
|
|
var high = this.high_;
|
|
if (numBits < 32) {
|
|
var low = this.low_;
|
|
return Timestamp.fromBits(
|
|
(low >>> numBits) | (high << (32 - numBits)),
|
|
high >> numBits);
|
|
} else {
|
|
return Timestamp.fromBits(
|
|
high >> (numBits - 32),
|
|
high >= 0 ? 0 : -1);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns this Timestamp 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 {Timestamp} this shifted to the right by the given amount, with zeros placed into the new leading bits.
|
|
* @api public
|
|
*/
|
|
Timestamp.prototype.shiftRightUnsigned = function(numBits) {
|
|
numBits &= 63;
|
|
if (numBits == 0) {
|
|
return this;
|
|
} else {
|
|
var high = this.high_;
|
|
if (numBits < 32) {
|
|
var low = this.low_;
|
|
return Timestamp.fromBits(
|
|
(low >>> numBits) | (high << (32 - numBits)),
|
|
high >>> numBits);
|
|
} else if (numBits == 32) {
|
|
return Timestamp.fromBits(high, 0);
|
|
} else {
|
|
return Timestamp.fromBits(high >>> (numBits - 32), 0);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns a Timestamp representing the given (32-bit) integer value.
|
|
*
|
|
* @param {Number} value the 32-bit integer in question.
|
|
* @return {Timestamp} the corresponding Timestamp value.
|
|
* @api public
|
|
*/
|
|
Timestamp.fromInt = function(value) {
|
|
if (-128 <= value && value < 128) {
|
|
var cachedObj = Timestamp.INT_CACHE_[value];
|
|
if (cachedObj) {
|
|
return cachedObj;
|
|
}
|
|
}
|
|
|
|
var obj = new Timestamp(value | 0, value < 0 ? -1 : 0);
|
|
if (-128 <= value && value < 128) {
|
|
Timestamp.INT_CACHE_[value] = obj;
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
/**
|
|
* Returns a Timestamp representing the given value, provided that it is a finite number. Otherwise, zero is returned.
|
|
*
|
|
* @param {Number} value the number in question.
|
|
* @return {Timestamp} the corresponding Timestamp value.
|
|
* @api public
|
|
*/
|
|
Timestamp.fromNumber = function(value) {
|
|
if (isNaN(value) || !isFinite(value)) {
|
|
return Timestamp.ZERO;
|
|
} else if (value <= -Timestamp.TWO_PWR_63_DBL_) {
|
|
return Timestamp.MIN_VALUE;
|
|
} else if (value + 1 >= Timestamp.TWO_PWR_63_DBL_) {
|
|
return Timestamp.MAX_VALUE;
|
|
} else if (value < 0) {
|
|
return Timestamp.fromNumber(-value).negate();
|
|
} else {
|
|
return new Timestamp(
|
|
(value % Timestamp.TWO_PWR_32_DBL_) | 0,
|
|
(value / Timestamp.TWO_PWR_32_DBL_) | 0);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns a Timestamp 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 {Timestamp} the corresponding Timestamp value.
|
|
* @api public
|
|
*/
|
|
Timestamp.fromBits = function(lowBits, highBits) {
|
|
return new Timestamp(lowBits, highBits);
|
|
};
|
|
|
|
/**
|
|
* Returns a Timestamp representation of the given string, written using the given radix.
|
|
*
|
|
* @param {String} str the textual representation of the Timestamp.
|
|
* @param {Number} opt_radix the radix in which the text is written.
|
|
* @return {Timestamp} the corresponding Timestamp value.
|
|
* @api public
|
|
*/
|
|
Timestamp.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 Timestamp.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 = Timestamp.fromNumber(Math.pow(radix, 8));
|
|
|
|
var result = Timestamp.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 = Timestamp.fromNumber(Math.pow(radix, size));
|
|
result = result.multiply(power).add(Timestamp.fromNumber(value));
|
|
} else {
|
|
result = result.multiply(radixToPower);
|
|
result = result.add(Timestamp.fromNumber(value));
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
|
|
// from* methods on which they depend.
|
|
|
|
|
|
/**
|
|
* A cache of the Timestamp representations of small integer values.
|
|
* @type {Object}
|
|
* @api private
|
|
*/
|
|
Timestamp.INT_CACHE_ = {};
|
|
|
|
// 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}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_16_DBL_ = 1 << 16;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_24_DBL_ = 1 << 24;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_32_DBL_ = Timestamp.TWO_PWR_16_DBL_ * Timestamp.TWO_PWR_16_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_31_DBL_ = Timestamp.TWO_PWR_32_DBL_ / 2;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_48_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_16_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_64_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_32_DBL_;
|
|
|
|
/**
|
|
* @type {number}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_63_DBL_ = Timestamp.TWO_PWR_64_DBL_ / 2;
|
|
|
|
/** @type {Timestamp} */
|
|
Timestamp.ZERO = Timestamp.fromInt(0);
|
|
|
|
/** @type {Timestamp} */
|
|
Timestamp.ONE = Timestamp.fromInt(1);
|
|
|
|
/** @type {Timestamp} */
|
|
Timestamp.NEG_ONE = Timestamp.fromInt(-1);
|
|
|
|
/** @type {Timestamp} */
|
|
Timestamp.MAX_VALUE =
|
|
Timestamp.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
|
|
|
|
/** @type {Timestamp} */
|
|
Timestamp.MIN_VALUE = Timestamp.fromBits(0, 0x80000000 | 0);
|
|
|
|
/**
|
|
* @type {Timestamp}
|
|
* @api private
|
|
*/
|
|
Timestamp.TWO_PWR_24_ = Timestamp.fromInt(1 << 24);
|
|
|
|
/**
|
|
* Expose.
|
|
*/
|
|
exports.Timestamp = Timestamp;
|
|
},
|
|
|
|
});
|
|
|
|
|
|
if(typeof module != 'undefined' && module.exports ){
|
|
module.exports = bson;
|
|
|
|
if( !module.parent ){
|
|
bson();
|
|
}
|
|
}
|
|
|
|
if(typeof window != 'undefined' && typeof require == 'undefined'){
|
|
window.require = bson.require;
|
|
}
|