summaryrefslogtreecommitdiffstats
path: root/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js
diff options
context:
space:
mode:
Diffstat (limited to 'common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js')
-rw-r--r--common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js429
1 files changed, 0 insertions, 429 deletions
diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js
deleted file mode 100644
index f19e44f..0000000
--- a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/node_modules/bson/alternate_parsers/faster_bson.js
+++ /dev/null
@@ -1,429 +0,0 @@
-/// reduced to ~ 410 LOCs (parser only 300 vs. 1400+) with (some, needed) BSON classes "inlined".
-/// Compare ~ 4,300 (22KB vs. 157KB) in browser build at: https://github.com/mongodb/js-bson/blob/master/browser_build/bson.js
-
-module.exports.calculateObjectSize = calculateObjectSize;
-
-function calculateObjectSize(object) {
- var totalLength = (4 + 1); /// handles the obj.length prefix + terminating '0' ?!
- for(var key in object) { /// looks like it handles arrays under the same for...in loop!?
- totalLength += calculateElement(key, object[key])
- }
- return totalLength;
-}
-
-function calculateElement(name, value) {
- var len = 1; /// always starting with 1 for the data type byte!
- if (name) len += Buffer.byteLength(name, 'utf8') + 1; /// cstring: name + '0' termination
-
- if (value === undefined || value === null) return len; /// just the type byte plus name cstring
- switch( value.constructor ) { /// removed all checks 'isBuffer' if Node.js Buffer class is present!?
-
- case ObjectID: /// we want these sorted from most common case to least common/deprecated;
- return len + 12;
- case String:
- return len + 4 + Buffer.byteLength(value, 'utf8') +1; ///
- case Number:
- if (Math.floor(value) === value) { /// case: integer; pos.# more common, '&&' stops if 1st fails!
- if ( value <= 2147483647 && value >= -2147483647 ) // 32 bit
- return len + 4;
- else return len + 8; /// covers Long-ish JS integers as Longs!
- } else return len + 8; /// 8+1 --- covers Double & std. float
- case Boolean:
- return len + 1;
-
- case Array:
- case Object:
- return len + calculateObjectSize(value);
-
- case Buffer: /// replaces the entire Binary class!
- return len + 4 + value.length + 1;
-
- case Regex: /// these are handled as strings by serializeFast() later, hence 'gim' opts = 3 + 1 chars
- return len + Buffer.byteLength(value.source, 'utf8') + 1
- + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) +1;
- case Date:
- case Long:
- case Timestamp:
- case Double:
- return len + 8;
-
- case MinKey:
- case MaxKey:
- return len; /// these two return the type byte and name cstring only!
- }
- return 0;
-}
-
-module.exports.serializeFast = serializeFast;
-module.exports.serialize = function(object, checkKeys, asBuffer, serializeFunctions, index) {
- var buffer = new Buffer(calculateObjectSize(object));
- return serializeFast(object, checkKeys, buffer, 0);
-}
-
-function serializeFast(object, checkKeys, buffer, i) { /// set checkKeys = false in query(..., options object to save performance IFF you're certain your keys are safe/system-set!
- var size = buffer.length;
- buffer[i++] = size & 0xff; buffer[i++] = (size >> 8) & 0xff; /// these get overwritten later!
- buffer[i++] = (size >> 16) & 0xff; buffer[i++] = (size >> 24) & 0xff;
-
- if (object.constructor === Array) { /// any need to checkKeys here?!? since we're doing for rather than for...in, should be safe from extra (non-numeric) keys added to the array?!
- for(var j = 0; j < object.length; j++) {
- i = packElement(j.toString(), object[j], checkKeys, buffer, i);
- }
- } else { /// checkKeys is needed if any suspicion of end-user key tampering/"injection" (a la SQL)
- for(var key in object) { /// mostly there should never be direct access to them!?
- if (checkKeys && (key.indexOf('\x00') >= 0 || key === '$where') ) { /// = "no script"?!; could add back key.indexOf('$') or maybe check for 'eval'?!
-/// took out: || key.indexOf('.') >= 0... Don't we allow dot notation queries?!
- console.log('checkKeys error: ');
- return new Error('Illegal object key!');
- }
- i = packElement(key, object[key], checkKeys, buffer, i); /// checkKeys pass needed for recursion!
- }
- }
- buffer[i++] = 0; /// write terminating zero; !we do NOT -1 the index increase here as original does!
- return i;
-}
-
-function packElement(name, value, checkKeys, buffer, i) { /// serializeFunctions removed! checkKeys needed for Array & Object cases pass through (calling serializeFast recursively!)
- if (value === undefined || value === null){
- buffer[i++] = 10; /// = BSON.BSON_DATA_NULL;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0; /// buffer.write(...) returns bytesWritten!
- return i;
- }
- switch(value.constructor) {
-
- case ObjectID:
- buffer[i++] = 7; /// = BSON.BSON_DATA_OID;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
-/// i += buffer.write(value.id, i, 'binary'); /// OLD: writes a String to a Buffer; 'binary' deprecated!!
- value.id.copy(buffer, i); /// NEW ObjectID version has this.id = Buffer at the ready!
- return i += 12;
-
- case String:
- buffer[i++] = 2; /// = BSON.BSON_DATA_STRING;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
-
- var size = Buffer.byteLength(value) + 1; /// includes the terminating '0'!?
- buffer[i++] = size & 0xff; buffer[i++] = (size >> 8) & 0xff;
- buffer[i++] = (size >> 16) & 0xff; buffer[i++] = (size >> 24) & 0xff;
-
- i += buffer.write(value, i, 'utf8'); buffer[i++] = 0;
- return i;
-
- case Number:
- if ( ~~(value) === value) { /// double-Tilde is equiv. to Math.floor(value)
- if ( value <= 2147483647 && value >= -2147483647){ /// = BSON.BSON_INT32_MAX / MIN asf.
- buffer[i++] = 16; /// = BSON.BSON_DATA_INT;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- buffer[i++] = value & 0xff; buffer[i++] = (value >> 8) & 0xff;
- buffer[i++] = (value >> 16) & 0xff; buffer[i++] = (value >> 24) & 0xff;
-
-// Else large-ish JS int!? to Long!?
- } else { /// if (value <= BSON.JS_INT_MAX && value >= BSON.JS_INT_MIN){ /// 9007199254740992 asf.
- buffer[i++] = 18; /// = BSON.BSON_DATA_LONG;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- var lowBits = ( value % 4294967296 ) | 0, highBits = ( value / 4294967296 ) | 0;
-
- buffer[i++] = lowBits & 0xff; buffer[i++] = (lowBits >> 8) & 0xff;
- buffer[i++] = (lowBits >> 16) & 0xff; buffer[i++] = (lowBits >> 24) & 0xff;
- buffer[i++] = highBits & 0xff; buffer[i++] = (highBits >> 8) & 0xff;
- buffer[i++] = (highBits >> 16) & 0xff; buffer[i++] = (highBits >> 24) & 0xff;
- }
- } else { /// we have a float / Double
- buffer[i++] = 1; /// = BSON.BSON_DATA_NUMBER;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
-/// OLD: writeIEEE754(buffer, value, i, 'little', 52, 8);
- buffer.writeDoubleLE(value, i); i += 8;
- }
- return i;
-
- case Boolean:
- buffer[i++] = 8; /// = BSON.BSON_DATA_BOOLEAN;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- buffer[i++] = value ? 1 : 0;
- return i;
-
- case Array:
- case Object:
- buffer[i++] = value.constructor === Array ? 4 : 3; /// = BSON.BSON_DATA_ARRAY / _OBJECT;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
-
- var endIndex = serializeFast(value, checkKeys, buffer, i); /// + 4); no longer needed b/c serializeFast writes a temp 4 bytes for length
- var size = endIndex - i;
- buffer[i++] = size & 0xff; buffer[i++] = (size >> 8) & 0xff;
- buffer[i++] = (size >> 16) & 0xff; buffer[i++] = (size >> 24) & 0xff;
- return endIndex;
-
- /// case Binary: /// is basically identical unless special/deprecated options!
- case Buffer: /// solves ALL of our Binary needs without the BSON.Binary class!?
- buffer[i++] = 5; /// = BSON.BSON_DATA_BINARY;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- var size = value.length;
- buffer[i++] = size & 0xff; buffer[i++] = (size >> 8) & 0xff;
- buffer[i++] = (size >> 16) & 0xff; buffer[i++] = (size >> 24) & 0xff;
-
- buffer[i++] = 0; /// write BSON.BSON_BINARY_SUBTYPE_DEFAULT;
- value.copy(buffer, i); ///, 0, size); << defaults to sourceStart=0, sourceEnd=sourceBuffer.length);
- i += size;
- return i;
-
- case RegExp:
- buffer[i++] = 11; /// = BSON.BSON_DATA_REGEXP;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- i += buffer.write(value.source, i, 'utf8'); buffer[i++] = 0x00;
-
- if (value.global) buffer[i++] = 0x73; // s = 'g' for JS Regex!
- if (value.ignoreCase) buffer[i++] = 0x69; // i
- if (value.multiline) buffer[i++] = 0x6d; // m
- buffer[i++] = 0x00;
- return i;
-
- case Date:
- buffer[i++] = 9; /// = BSON.BSON_DATA_DATE;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- var millis = value.getTime();
- var lowBits = ( millis % 4294967296 ) | 0, highBits = ( millis / 4294967296 ) | 0;
-
- buffer[i++] = lowBits & 0xff; buffer[i++] = (lowBits >> 8) & 0xff;
- buffer[i++] = (lowBits >> 16) & 0xff; buffer[i++] = (lowBits >> 24) & 0xff;
- buffer[i++] = highBits & 0xff; buffer[i++] = (highBits >> 8) & 0xff;
- buffer[i++] = (highBits >> 16) & 0xff; buffer[i++] = (highBits >> 24) & 0xff;
- return i;
-
- case Long:
- case Timestamp:
- buffer[i++] = value.constructor === Long ? 18 : 17; /// = BSON.BSON_DATA_LONG / _TIMESTAMP
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- var lowBits = value.getLowBits(), highBits = value.getHighBits();
-
- buffer[i++] = lowBits & 0xff; buffer[i++] = (lowBits >> 8) & 0xff;
- buffer[i++] = (lowBits >> 16) & 0xff; buffer[i++] = (lowBits >> 24) & 0xff;
- buffer[i++] = highBits & 0xff; buffer[i++] = (highBits >> 8) & 0xff;
- buffer[i++] = (highBits >> 16) & 0xff; buffer[i++] = (highBits >> 24) & 0xff;
- return i;
-
- case Double:
- buffer[i++] = 1; /// = BSON.BSON_DATA_NUMBER;
- i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
-/// OLD: writeIEEE754(buffer, value, i, 'little', 52, 8); i += 8;
- buffer.writeDoubleLE(value, i); i += 8;
- return i
-
- case MinKey: /// = BSON.BSON_DATA_MINKEY;
- buffer[i++] = 127; i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- return i;
- case MaxKey: /// = BSON.BSON_DATA_MAXKEY;
- buffer[i++] = 255; i += buffer.write(name, i, 'utf8'); buffer[i++] = 0;
- return i;
-
- } /// end of switch
- return i; /// ?! If no value to serialize
-}
-
-
-module.exports.deserializeFast = deserializeFast;
-
-function deserializeFast(buffer, i, isArray){ //// , options, isArray) { //// no more options!
- if (buffer.length < 5) return new Error('Corrupt bson message < 5 bytes long'); /// from 'throw'
- var elementType, tempindex = 0, name;
- var string, low, high; /// = lowBits / highBits
- /// using 'i' as the index to keep the lines shorter:
- i || ( i = 0 ); /// for parseResponse it's 0; set to running index in deserialize(object/array) recursion
- var object = isArray ? [] : {}; /// needed for type ARRAY recursion later!
- var size = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- if(size < 5 || size > buffer.length) return new Error('Corrupt BSON message');
-/// 'size' var was not used by anything after this, so we can reuse it
-
- while(true) { // While we have more left data left keep parsing
- elementType = buffer[i++]; // Read the type
- if (elementType === 0) break; // If we get a zero it's the last byte, exit
-
- tempindex = i; /// inlined readCStyleString & removed extra i<buffer.length check slowing EACH loop!
- while( buffer[tempindex] !== 0x00 ) tempindex++; /// read ahead w/out changing main 'i' index
- if (tempindex >= buffer.length) return new Error('Corrupt BSON document: illegal CString')
- name = buffer.toString('utf8', i, tempindex);
- i = tempindex + 1; /// Update index position to after the string + '0' termination
-
- switch(elementType) {
-
- case 7: /// = BSON.BSON_DATA_OID:
- var buf = new Buffer(12);
- buffer.copy(buf, 0, i, i += 12 ); /// copy 12 bytes from the current 'i' offset into fresh Buffer
- object[name] = new ObjectID(buf); ///... & attach to the new ObjectID instance
- break;
-
- case 2: /// = BSON.BSON_DATA_STRING:
- size = buffer[i++] | buffer[i++] <<8 | buffer[i++] <<16 | buffer[i++] <<24;
- object[name] = buffer.toString('utf8', i, i += size -1 );
- i++; break; /// need to get the '0' index "tick-forward" back!
-
- case 16: /// = BSON.BSON_DATA_INT: // Decode the 32bit value
- object[name] = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24; break;
-
- case 1: /// = BSON.BSON_DATA_NUMBER: // Decode the double value
- object[name] = buffer.readDoubleLE(i); /// slightly faster depending on dec.points; a LOT cleaner
- /// OLD: object[name] = readIEEE754(buffer, i, 'little', 52, 8);
- i += 8; break;
-
- case 8: /// = BSON.BSON_DATA_BOOLEAN:
- object[name] = buffer[i++] == 1; break;
-
- case 6: /// = BSON.BSON_DATA_UNDEFINED: /// deprecated
- case 10: /// = BSON.BSON_DATA_NULL:
- object[name] = null; break;
-
- case 4: /// = BSON.BSON_DATA_ARRAY
- size = buffer[i] | buffer[i+1] <<8 | buffer[i+2] <<16 | buffer[i+3] <<24; /// NO 'i' increment since the size bytes are reread during the recursion!
- object[name] = deserializeFast(buffer, i, true ); /// pass current index & set isArray = true
- i += size; break;
- case 3: /// = BSON.BSON_DATA_OBJECT:
- size = buffer[i] | buffer[i+1] <<8 | buffer[i+2] <<16 | buffer[i+3] <<24;
- object[name] = deserializeFast(buffer, i, false ); /// isArray = false => Object
- i += size; break;
-
- case 5: /// = BSON.BSON_DATA_BINARY: // Decode the size of the binary blob
- size = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- buffer[i++]; /// Skip, as we assume always default subtype, i.e. 0!
- object[name] = buffer.slice(i, i += size); /// creates a new Buffer "slice" view of the same memory!
- break;
-
- case 9: /// = BSON.BSON_DATA_DATE: /// SEE notes below on the Date type vs. other options...
- low = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- high = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- object[name] = new Date( high * 4294967296 + (low < 0 ? low + 4294967296 : low) ); break;
-
- case 18: /// = BSON.BSON_DATA_LONG: /// usage should be somewhat rare beyond parseResponse() -> cursorId, where it is handled inline, NOT as part of deserializeFast(returnedObjects); get lowBits, highBits:
- low = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- high = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
-
- size = high * 4294967296 + (low < 0 ? low + 4294967296 : low); /// from long.toNumber()
- if (size < JS_INT_MAX && size > JS_INT_MIN) object[name] = size; /// positive # more likely!
- else object[name] = new Long(low, high); break;
-
- case 127: /// = BSON.BSON_DATA_MIN_KEY: /// do we EVER actually get these BACK from MongoDB server?!
- object[name] = new MinKey(); break;
- case 255: /// = BSON.BSON_DATA_MAX_KEY:
- object[name] = new MaxKey(); break;
-
- case 17: /// = BSON.BSON_DATA_TIMESTAMP: /// somewhat obscure internal BSON type; MongoDB uses it for (pseudo) high-res time timestamp (past millisecs precision is just a counter!) in the Oplog ts: field, etc.
- low = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- high = buffer[i++] | buffer[i++] << 8 | buffer[i++] << 16 | buffer[i++] << 24;
- object[name] = new Timestamp(low, high); break;
-
-/// case 11: /// = RegExp is skipped; we should NEVER be getting any from the MongoDB server!?
- } /// end of switch(elementType)
- } /// end of while(1)
- return object; // Return the finalized object
-}
-
-
-function MinKey() { this._bsontype = 'MinKey'; } /// these are merely placeholders/stubs to signify the type!?
-
-function MaxKey() { this._bsontype = 'MaxKey'; }
-
-function Long(low, high) {
- this._bsontype = 'Long';
- this.low_ = low | 0; this.high_ = high | 0; /// force into 32 signed bits.
-}
-Long.prototype.getLowBits = function(){ return this.low_; }
-Long.prototype.getHighBits = function(){ return this.high_; }
-
-Long.prototype.toNumber = function(){
- return this.high_ * 4294967296 + (this.low_ < 0 ? this.low_ + 4294967296 : this.low_);
-}
-Long.fromNumber = function(num){
- return new Long(num % 4294967296, num / 4294967296); /// |0 is forced in the constructor!
-}
-function Double(value) {
- this._bsontype = 'Double';
- this.value = value;
-}
-function Timestamp(low, high) {
- this._bsontype = 'Timestamp';
- this.low_ = low | 0; this.high_ = high | 0; /// force into 32 signed bits.
-}
-Timestamp.prototype.getLowBits = function(){ return this.low_; }
-Timestamp.prototype.getHighBits = function(){ return this.high_; }
-
-/////////////////////////////// ObjectID /////////////////////////////////
-/// machine & proc IDs stored as 1 string, b/c Buffer shouldn't be held for long periods (could use SlowBuffer?!)
-
-var MACHINE = parseInt(Math.random() * 0xFFFFFF, 10);
-var PROCESS = process.pid % 0xFFFF;
-var MACHINE_AND_PROC = encodeIntBE(MACHINE, 3) + encodeIntBE(PROCESS, 2); /// keep as ONE string, ready to go.
-
-function encodeIntBE(data, bytes){ /// encode the bytes to a string
- var result = '';
- if (bytes >= 4){ result += String.fromCharCode(Math.floor(data / 0x1000000)); data %= 0x1000000; }
- if (bytes >= 3){ result += String.fromCharCode(Math.floor(data / 0x10000)); data %= 0x10000; }
- if (bytes >= 2){ result += String.fromCharCode(Math.floor(data / 0x100)); data %= 0x100; }
- result += String.fromCharCode(Math.floor(data));
- return result;
-}
-var _counter = ~~(Math.random() * 0xFFFFFF); /// double-tilde is equivalent to Math.floor()
-var checkForHex = new RegExp('^[0-9a-fA-F]{24}$');
-
-function ObjectID(id) {
- this._bsontype = 'ObjectID';
- if (!id){ this.id = createFromScratch(); /// base case, DONE.
- } else {
- if (id.constructor === Buffer){
- this.id = id; /// case of
- } else if (id.constructor === String) {
- if ( id.length === 24 && checkForHex.test(id) ) {
- this.id = new Buffer(id, 'hex');
- } else {
- this.id = new Error('Illegal/faulty Hexadecimal string supplied!'); /// changed from 'throw'
- }
- } else if (id.constructor === Number) {
- this.id = createFromTime(id); /// this is what should be the only interface for this!?
- }
- }
-}
-function createFromScratch() {
- var buf = new Buffer(12), i = 0;
- var ts = ~~(Date.now()/1000); /// 4 bytes timestamp in seconds, BigEndian notation!
- buf[i++] = (ts >> 24) & 0xFF; buf[i++] = (ts >> 16) & 0xFF;
- buf[i++] = (ts >> 8) & 0xFF; buf[i++] = (ts) & 0xFF;
-
- buf.write(MACHINE_AND_PROC, i, 5, 'utf8'); i += 5; /// write 3 bytes + 2 bytes MACHINE_ID and PROCESS_ID
- _counter = ++_counter % 0xFFFFFF; /// 3 bytes internal _counter for subsecond resolution; BigEndian
- buf[i++] = (_counter >> 16) & 0xFF;
- buf[i++] = (_counter >> 8) & 0xFF;
- buf[i++] = (_counter) & 0xFF;
- return buf;
-}
-function createFromTime(ts) {
- ts || ( ts = ~~(Date.now()/1000) ); /// 4 bytes timestamp in seconds only
- var buf = new Buffer(12), i = 0;
- buf[i++] = (ts >> 24) & 0xFF; buf[i++] = (ts >> 16) & 0xFF;
- buf[i++] = (ts >> 8) & 0xFF; buf[i++] = (ts) & 0xFF;
-
- for (;i < 12; ++i) buf[i] = 0x00; /// indeces 4 through 11 (8 bytes) get filled up with nulls
- return buf;
-}
-ObjectID.prototype.toHexString = function toHexString() {
- return this.id.toString('hex');
-}
-ObjectID.prototype.getTimestamp = function getTimestamp() {
- return this.id.readUIntBE(0, 4);
-}
-ObjectID.prototype.getTimestampDate = function getTimestampDate() {
- var ts = new Date();
- ts.setTime(this.id.readUIntBE(0, 4) * 1000);
- return ts;
-}
-ObjectID.createPk = function createPk () { ///?override if a PrivateKey factory w/ unique factors is warranted?!
- return new ObjectID();
-}
-ObjectID.prototype.toJSON = function toJSON() {
- return "ObjectID('" +this.id.toString('hex')+ "')";
-}
-
-/// module.exports.BSON = BSON; /// not needed anymore!? exports.Binary = Binary;
-module.exports.ObjectID = ObjectID;
-module.exports.MinKey = MinKey;
-module.exports.MaxKey = MaxKey;
-module.exports.Long = Long; /// ?! we really don't want to do the complicated Long math anywhere for now!?
-
-//module.exports.Double = Double;
-//module.exports.Timestamp = Timestamp;