couchdb-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gar...@apache.org
Subject [24/51] [abbrv] [partial] couchdb-nmo git commit: Remove node_modules from repo
Date Mon, 30 Nov 2015 09:37:06 GMT
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/node_modules/bson/alternate_parsers/faster_bson.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/node_modules/bson/alternate_parsers/faster_bson.js
b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/node_modules/bson/alternate_parsers/faster_bson.js
deleted file mode 100644
index f19e44f..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/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;


Mime
View raw message