You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1574 lines
65 KiB
1574 lines
65 KiB
var Long = require('../lib/bson/long').Long |
|
, Double = require('../lib/bson/double').Double |
|
, Timestamp = require('../lib/bson/timestamp').Timestamp |
|
, ObjectID = require('../lib/bson/objectid').ObjectID |
|
, Symbol = require('../lib/bson/symbol').Symbol |
|
, Code = require('../lib/bson/code').Code |
|
, MinKey = require('../lib/bson/min_key').MinKey |
|
, MaxKey = require('../lib/bson/max_key').MaxKey |
|
, DBRef = require('../lib/bson/db_ref').DBRef |
|
, Binary = require('../lib/bson/binary').Binary |
|
, BinaryParser = require('../lib/bson/binary_parser').BinaryParser |
|
, writeIEEE754 = require('../lib/bson/float_parser').writeIEEE754 |
|
, readIEEE754 = require('../lib/bson/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 |
|
* @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; |
|
/** |
|
* Binary BSON Type |
|
* |
|
* @classconstant BSON_DATA_UNDEFINED |
|
**/ |
|
BSON.BSON_DATA_UNDEFINED = 6; |
|
/** |
|
* 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'; |
|
|
|
// If we have toBSON defined, override the current object |
|
if(value && value.toBSON){ |
|
value = value.toBSON(); |
|
} |
|
|
|
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) { |
|
if(object.toBSON) { |
|
if(typeof object.toBSON != 'function') throw new Error("toBSON is not a function"); |
|
object = object.toBSON(); |
|
if(object != null && typeof object != 'object') throw new Error("toBSON function did not return an object"); |
|
} |
|
|
|
// 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) { |
|
|
|
// If we have toBSON defined, override the current object |
|
if(value && value.toBSON){ |
|
value = value.toBSON(); |
|
} |
|
|
|
var startIndex = index; |
|
|
|
switch(typeof value) { |
|
case 'string': |
|
// console.log("+++++++++++ index string:: " + index) |
|
// 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; |
|
// console.log("====== key :: " + name + " size ::" + size) |
|
// 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') { |
|
// console.log("+++++++++++ index OBJECTID:: " + index) |
|
// 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 || value['_bsontype'] == '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); |
|
// console.log("++++++++++++++++++++++++++++++++++++ OLDJS :: " + buffer.length) |
|
// console.log(buffer.toString('hex')) |
|
// console.log(buffer.toString('ascii')) |
|
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'] == null ? true : options['promoteLongs']; |
|
|
|
// 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 < buffer.length) { |
|
i++ |
|
} |
|
// If are at the end of the buffer there is a problem with the document |
|
if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString") |
|
// 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_UNDEFINED: |
|
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 |
|
*/ |
|
module.exports = BSON; |
|
module.exports.Code = Code; |
|
module.exports.Symbol = Symbol; |
|
module.exports.BSON = BSON; |
|
module.exports.DBRef = DBRef; |
|
module.exports.Binary = Binary; |
|
module.exports.ObjectID = ObjectID; |
|
module.exports.Long = Long; |
|
module.exports.Timestamp = Timestamp; |
|
module.exports.Double = Double; |
|
module.exports.MinKey = MinKey; |
|
module.exports.MaxKey = MaxKey;
|
|
|