CSHARP-1067: Use slightly smaller internal representation for ObjectId.

Author: rstam

src/MongoDB.Bson/IO/ByteBufferStream.cs

@@ -659,7 +659,7 @@ public override void WriteObjectId(ObjectId value)
             var segment = _buffer.AccessBackingBytes(_position);
             if (segment.Count >= 12)
             {
-                value.GetBytes(segment.Array, segment.Offset);
+                value.ToByteArray(segment.Array, segment.Offset);
             }
             else
             {

src/MongoDB.Bson/IO/JsonWriter.cs

@@ -467,7 +467,7 @@ public override void WriteObjectId(ObjectId objectId)
                 ThrowInvalidState("WriteObjectId", BsonWriterState.Value, BsonWriterState.Initial);
             }
 
-            var bytes = ObjectId.Pack(objectId.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment);
+            var bytes = objectId.ToByteArray();
 
             WriteNameHelper(Name);
             switch (_jsonWriterSettings.OutputMode)

src/MongoDB.Bson/ObjectModel/ObjectId.cs

@@ -36,13 +36,9 @@ public struct ObjectId : IComparable<ObjectId>, IEquatable<ObjectId>, IConvertib
         private static int __staticIncrement; // high byte will be masked out when generating new ObjectId
 
         // private fields
-        // we're using 14 bytes instead of 12 to hold the ObjectId in memory but unlike a byte[] there is no additional object on the heap
-        // the extra two bytes are not visible to anyone outside of this class and they buy us considerable simplification
-        // an additional advantage of this representation is that it will serialize to JSON without any 64 bit overflow problems
-        private int _timestamp;
-        private int _machine;
-        private short _pid;
-        private int _increment;
+        private int _a;
+        private int _b;
+        private int _c;
 
         // static constructor
         static ObjectId()
@@ -71,7 +67,10 @@ public ObjectId(byte[] bytes)
             {
                 throw new ArgumentNullException("bytes");
             }
-            Unpack(bytes, out _timestamp, out _machine, out _pid, out _increment);
+
+            _a = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
+            _b = (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7];
+            _c = (bytes[8] << 24) | (bytes[9] << 16) | (bytes[10] << 8) | bytes[11];
         }
 
         /// <summary>
@@ -81,10 +80,9 @@ public ObjectId(byte[] bytes)
         /// <param name="index">The index into the byte array where the ObjectId starts.</param>
         internal ObjectId(byte[] bytes, int index)
         {
-            _timestamp = (bytes[index] << 24) | (bytes[index + 1] << 16) | (bytes[index + 2] << 8) | bytes[index + 3];
-            _machine = (bytes[index + 4] << 16) | (bytes[index + 5] << 8) | bytes[index + 6];
-            _pid = (short)((bytes[index + 7] << 8) | bytes[index + 8]);
-            _increment = (bytes[index + 9] << 16) | (bytes[index + 10] << 8) | bytes[index + 11];
+            _a = (bytes[index] << 24) | (bytes[index + 1] << 16) | (bytes[index + 2] << 8) | bytes[index + 3];
+            _b = (bytes[index + 4] << 24) | (bytes[index + 5] << 16) | (bytes[index + 6] << 8) | bytes[index + 7];
+            _c = (bytes[index + 8] << 24) | (bytes[index + 9] << 16) | (bytes[index + 10] << 8) | bytes[index + 11];
         }
 
         /// <summary>
@@ -117,10 +115,9 @@ public ObjectId(int timestamp, int machine, short pid, int increment)
                 throw new ArgumentOutOfRangeException("increment", "The increment value must be between 0 and 16777215 (it must fit in 3 bytes).");
             }
 
-            _timestamp = timestamp;
-            _machine = machine;
-            _pid = pid;
-            _increment = increment;
+            _a = timestamp;
+            _b = (machine << 8)| (((int)pid >> 8) & 0xff);
+            _c = ((int)pid << 24) | increment;
         }
 
         /// <summary>
@@ -133,7 +130,11 @@ public ObjectId(string value)
             {
                 throw new ArgumentNullException("value");
             }
-            Unpack(BsonUtils.ParseHexString(value), out _timestamp, out _machine, out _pid, out _increment);
+
+            var bytes = BsonUtils.ParseHexString(value);
+            _a = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
+            _b = (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7];
+            _c = (bytes[8] << 24) | (bytes[9] << 16) | (bytes[10] << 8) | bytes[11];
         }
 
         // public static properties
@@ -151,39 +152,39 @@ public static ObjectId Empty
         /// </summary>
         public int Timestamp
         {
-            get { return _timestamp; }
+            get { return _a; }
         }
 
         /// <summary>
         /// Gets the machine.
         /// </summary>
         public int Machine
         {
-            get { return _machine; }
+            get { return (_b >> 8) & 0xffffff; }
         }
 
         /// <summary>
         /// Gets the PID.
         /// </summary>
         public short Pid
         {
-            get { return _pid; }
+            get { return (short)(((_b << 8) & 0xff00) | ((_c >> 24) & 0x00ff)); }
         }
 
         /// <summary>
         /// Gets the increment.
         /// </summary>
         public int Increment
         {
-            get { return _increment; }
+            get { return _c & 0xffffff; }
         }
 
         /// <summary>
         /// Gets the creation time (derived from the timestamp).
         /// </summary>
         public DateTime CreationTime
         {
-            get { return BsonConstants.UnixEpoch.AddSeconds(_timestamp); }
+            get { return BsonConstants.UnixEpoch.AddSeconds(Timestamp); }
         }
 
         // public operators
@@ -330,6 +331,7 @@ public static ObjectId Parse(string s)
             {
                 throw new ArgumentNullException("s");
             }
+
             ObjectId objectId;
             if (TryParse(s, out objectId))
             {
@@ -383,6 +385,7 @@ public static void Unpack(byte[] bytes, out int timestamp, out int machine, out
             {
                 throw new ArgumentOutOfRangeException("bytes", "Byte array must be 12 bytes long.");
             }
+
             timestamp = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3];
             machine = (bytes[4] << 16) + (bytes[5] << 8) + bytes[6];
             pid = (short)((bytes[7] << 8) + bytes[8]);
@@ -425,13 +428,11 @@ private static int GetTimestampFromDateTime(DateTime timestamp)
         /// <returns>A 32-bit signed integer that indicates whether this ObjectId is less than, equal to, or greather than the other.</returns>
         public int CompareTo(ObjectId other)
         {
-            int r = _timestamp.CompareTo(other._timestamp);
-            if (r != 0) { return r; }
-            r = _machine.CompareTo(other._machine);
-            if (r != 0) { return r; }
-            r = _pid.CompareTo(other._pid);
-            if (r != 0) { return r; }
-            return _increment.CompareTo(other._increment);
+            int result = ((uint)_a).CompareTo((uint)other._a);
+            if (result != 0) { return result; }
+            result = ((uint)_b).CompareTo((uint)other._b);
+            if (result != 0) { return result; }
+            return ((uint)_c).CompareTo((uint)other._c);
         }
 
         /// <summary>
@@ -442,10 +443,9 @@ public int CompareTo(ObjectId other)
         public bool Equals(ObjectId rhs)
         {
             return
-                _timestamp == rhs._timestamp &&
-                _machine == rhs._machine &&
-                _pid == rhs._pid &&
-                _increment == rhs._increment;
+                _a == rhs._a &&
+                _b == rhs._b &&
+                _c == rhs._c;
         }
 
         /// <summary>
@@ -472,10 +472,9 @@ public override bool Equals(object obj)
         public override int GetHashCode()
         {
             int hash = 17;
-            hash = 37 * hash + _timestamp.GetHashCode();
-            hash = 37 * hash + _machine.GetHashCode();
-            hash = 37 * hash + _pid.GetHashCode();
-            hash = 37 * hash + _increment.GetHashCode();
+            hash = 37 * hash + _a.GetHashCode();
+            hash = 37 * hash + _b.GetHashCode();
+            hash = 37 * hash + _c.GetHashCode();
             return hash;
         }
 
@@ -485,7 +484,20 @@ public override int GetHashCode()
         /// <returns>A byte array.</returns>
         public byte[] ToByteArray()
         {
-            return Pack(_timestamp, _machine, _pid, _increment);
+            var bytes = new byte[12];
+            bytes[0] = (byte)(_a >> 24);
+            bytes[1] = (byte)(_a >> 16);
+            bytes[2] = (byte)(_a >> 8);
+            bytes[3] = (byte)(_a);
+            bytes[4] = (byte)(_b >> 24);
+            bytes[5] = (byte)(_b >> 16);
+            bytes[6] = (byte)(_b >> 8);
+            bytes[7] = (byte)(_b);
+            bytes[8] = (byte)(_c >> 24);
+            bytes[9] = (byte)(_c >> 16);
+            bytes[10] = (byte)(_c >> 8);
+            bytes[11] = (byte)(_c);
+            return bytes;
         }
 
         /// <summary>
@@ -495,18 +507,18 @@ public byte[] ToByteArray()
         /// <param name="offset">The offset.</param>
         public void ToByteArray(byte[] destination, int offset)
         {
-            destination[offset + 0] = (byte)(_timestamp >> 24);
-            destination[offset + 1] = (byte)(_timestamp >> 16);
-            destination[offset + 2] = (byte)(_timestamp >> 8);
-            destination[offset + 3] = (byte)(_timestamp);
-            destination[offset + 4] = (byte)(_machine >> 16);
-            destination[offset + 5] = (byte)(_machine >> 8);
-            destination[offset + 6] = (byte)(_machine);
-            destination[offset + 7] = (byte)(_pid >> 8);
-            destination[offset + 8] = (byte)(_pid);
-            destination[offset + 9] = (byte)(_increment >> 16);
-            destination[offset + 10] = (byte)(_increment >> 8);
-            destination[offset + 11] = (byte)(_increment);
+            destination[offset + 0] = (byte)(_a >> 24);
+            destination[offset + 1] = (byte)(_a >> 16);
+            destination[offset + 2] = (byte)(_a >> 8);
+            destination[offset + 3] = (byte)(_a);
+            destination[offset + 4] = (byte)(_b >> 24);
+            destination[offset + 5] = (byte)(_b >> 16);
+            destination[offset + 6] = (byte)(_b >> 8);
+            destination[offset + 7] = (byte)(_b);
+            destination[offset + 8] = (byte)(_c >> 24);
+            destination[offset + 9] = (byte)(_c >> 16);
+            destination[offset + 10] = (byte)(_c >> 8);
+            destination[offset + 11] = (byte)(_c);
         }
 
         /// <summary>
@@ -515,24 +527,7 @@ public void ToByteArray(byte[] destination, int offset)
         /// <returns>A string representation of the value.</returns>
         public override string ToString()
         {
-            return BsonUtils.ToHexString(Pack(_timestamp, _machine, _pid, _increment));
-        }
-
-        // internal methods
-        internal void GetBytes(byte[] bytes, int index)
-        {
-            bytes[index] = (byte)(_timestamp >> 24);
-            bytes[1 + index] = (byte)(_timestamp >> 16);
-            bytes[2 + index] = (byte)(_timestamp >> 8);
-            bytes[3 + index] = (byte)(_timestamp);
-            bytes[4 + index] = (byte)(_machine >> 16);
-            bytes[5 + index] = (byte)(_machine >> 8);
-            bytes[6 + index] = (byte)(_machine);
-            bytes[7 + index] = (byte)(_pid >> 8);
-            bytes[8 + index] = (byte)(_pid);
-            bytes[9 + index] = (byte)(_increment >> 16);
-            bytes[10 + index] = (byte)(_increment >> 8);
-            bytes[11 + index] = (byte)(_increment);
+            return BsonUtils.ToHexString(ToByteArray());
         }
 
         // explicit IConvertible implementation