Some major refactoring of pull request 113: modify ReadCString to navigate a trie at the same time it is searching for the terminating null byte. The matching node in the trie (if found) contains the information needed to deserialize an element, thus avoiding a dictionary lookup.

Author: rstam

Bson/IO/BsonBinaryReader.cs

@@ -160,10 +160,15 @@ public override bool ReadBoolean()
         /// <summary>
         /// Reads a BsonType from the reader.
         /// </summary>
+        /// <param name="bsonTrie">An optional trie to search for a value that matches the next element name.</param>
+        /// <param name="found">Set to true if a matching value was found in the trie.</param>
+        /// <param name="value">Set to the matching value found in the trie or null if no matching value was found.</param>
         /// <returns>A BsonType.</returns>
-        public override BsonType ReadBsonType(BsonTrie bsonTrie)
+        public override BsonType ReadBsonType<TValue>(BsonTrie<TValue> bsonTrie, out bool found, out TValue value)
         {
             if (Disposed) { ThrowObjectDisposedException(); }
+            found = false;
+            value = default(TValue);
             if (State == BsonReaderState.Initial || State == BsonReaderState.Done || State == BsonReaderState.ScopeDocument)
             {
                 // there is an implied type of Document for the top level and for scope documents
@@ -204,7 +209,7 @@ public override BsonType ReadBsonType(BsonTrie bsonTrie)
                         break;
                     case ContextType.Document:
                     case ContextType.ScopeDocument:
-                        CurrentName = _buffer.ReadCString(bsonTrie);
+                        CurrentName = _buffer.ReadCString(bsonTrie, out found, out value);
                         State = BsonReaderState.Name;
                         break;
                     default:
@@ -417,8 +422,8 @@ public override void ReadRegularExpression(out string pattern, out string option
         {
             if (Disposed) { ThrowObjectDisposedException(); }
             VerifyBsonType("ReadRegularExpression", BsonType.RegularExpression);
-            pattern = (string)_buffer.ReadCString(null);
-            options = (string)_buffer.ReadCString(null);
+            pattern = _buffer.ReadCString();
+            options = _buffer.ReadCString();
             State = GetNextState();
         }
 

Bson/IO/BsonBinaryReaderBookmark.cs

@@ -33,7 +33,7 @@ public class BsonBinaryReaderBookmark : BsonReaderBookmark
         internal BsonBinaryReaderBookmark(
             BsonReaderState state,
             BsonType currentBsonType,
-            object currentName,
+            string currentName,
             BsonBinaryReaderContext context,
             int position)
             : base(state, currentBsonType, currentName)

Bson/IO/BsonBuffer.cs

@@ -144,11 +144,11 @@ public int Position
         // private static methods
         private static string[] BuildAsciiStringTable()
         {
-            var asciiStringTable = new string[95]; // 95 printable ASCII characters; first 32 are control characters; 127 is the delete character
+            var asciiStringTable = new string[128];
 
-            for (var i = 0; i < asciiStringTable.Length; ++i)
+            for (int i = 0; i < 128; ++i)
             {
-                asciiStringTable[i] = new string((char)(i + 32), 1);
+                asciiStringTable[i] = new string((char)i, 1);
             }
 
             return asciiStringTable;
@@ -533,7 +533,7 @@ public string ReadString()
                 {
                     throw new FileFormatException("String is missing null terminator.");
                 }
-                value = GetSingleChunkString(length - 1); // don't decode the null terminator
+                value = DecodeUtf8String(_chunk, _chunkOffset, length - 1); // don't decode the null terminator
                 Position += length;
             }
             else
@@ -550,14 +550,29 @@ public string ReadString()
             return value;
         }
 
+        /// <summary>
+        /// Reads a BSON CString from the reader (a null terminated string).
+        /// </summary>
+        /// <returns>A string.</returns>
+        public string ReadCString()
+        {
+            bool found;
+            object value;
+            return ReadCString(null, out found, out value);
+        }
+
         /// <summary>
         /// Reads a BSON CString from the reader (a null terminated string).
         /// </summary>
         /// <param name="bsonTrie">An optional BsonTrie to use during decoding.</param>
-        /// <returns>A value decoded using the optional BsonTrie or a String if no BsonTrie was specified or no value could be decoded using the BsonTrie.</returns>
-        public object ReadCString(BsonTrie bsonTrie)
+        /// <param name="found">Set to true if the string was found in the trie.</param>
+        /// <param name="value">Set to the value found in the trie; otherwise, null.</param>
+        /// <returns>A string.</returns>
+        public string ReadCString<TValue>(BsonTrie<TValue> bsonTrie, out bool found, out TValue value)
         {
             if (_disposed) { throw new ObjectDisposedException("BsonBuffer"); }
+            found = false;
+            value = default(TValue);
             // optimize for the case where the null terminator is on the same chunk
             int partialCount;
             if (_chunkIndex < _chunks.Count - 1)
@@ -570,19 +585,23 @@ public object ReadCString(BsonTrie bsonTrie)
             }
 
             var bsonTrieNode = bsonTrie != null ? bsonTrie.Root : null;
-            var index = FindNull(
-                bsonTrie,
-                ref bsonTrieNode,
-                _chunk,
-                _chunkOffset,
-                partialCount);
+            var index = IndexOfNull(_chunk, _chunkOffset, partialCount, ref bsonTrieNode);
             if (index != -1)
             {
                 var stringLength = index - _chunkOffset;
-                var value = bsonTrieNode != null && bsonTrieNode.HasValue ?
-                    bsonTrieNode.Value : GetSingleChunkString(stringLength);
+                string cstring;
+                if (bsonTrieNode != null && bsonTrieNode.HasValue)
+                {
+                    cstring = bsonTrieNode.ElementName;
+                    value = bsonTrieNode.Value;
+                    found = true;
+                }
+                else
+                {
+                    cstring = DecodeUtf8String(_chunk, _chunkOffset, stringLength);
+                }
                 Position += stringLength + 1;
-                return value;
+                return cstring;
             }
 
             // the null terminator is not on the same chunk so keep looking starting with the next chunk
@@ -599,28 +618,25 @@ public object ReadCString(BsonTrie bsonTrie)
                 {
                     partialCount = _length - localPosition; // populated part of last chunk
                 }
-                index = FindNull(
-                    bsonTrie,
-                    ref bsonTrieNode,
-                    localChunk,
-                    0,
-                    partialCount);
+                index = IndexOfNull(localChunk, 0, partialCount, ref bsonTrieNode);
                 if (index != -1)
                 {
                     localPosition += index;
                     var stringLength = localPosition - _position;
-                    object value;
+                    string cstring;
                     if (bsonTrieNode != null && bsonTrieNode.HasValue)
                     {
+                        cstring = bsonTrieNode.ElementName;
                         value = bsonTrieNode.Value;
+                        found = true;
                         Position += stringLength + 1;
                     }
                     else
                     {
-                        value = __utf8Encoding.GetString(ReadBytes(stringLength)); // ReadBytes advances over string
+                        cstring = __utf8Encoding.GetString(ReadBytes(stringLength)); // ReadBytes advances over string
                         Position += 1; // skip over null byte at end
                     }
-                    return value;
+                    return cstring;
                 }
                 localChunkIndex++;
                 localPosition += __chunkSize;
@@ -945,6 +961,27 @@ public void WriteZero()
         }
 
         // private methods
+        private string DecodeUtf8String(byte[] buffer, int index, int count)
+        {
+            switch (count)
+            {
+                // special case empty strings
+                case 0:
+                    return "";
+
+                // special case single character strings
+                case 1:
+                    var byte1 = (int)buffer[index];
+                    if (byte1 < __asciiStringTable.Length)
+                    {
+                        return __asciiStringTable[byte1];
+                    }
+                    break;
+            }
+
+            return __utf8Encoding.GetString(buffer, index, count);
+        }
+
         private void EnsureDataAvailable(int needed)
         {
             if (_length - _position < needed)
@@ -977,63 +1014,30 @@ private void EnsureSpaceAvailable(int needed)
             }
         }
 
-        private static int FindNull(
-            BsonTrie bsonTrie,
-            ref BsonTrieNode bsonTrieNode,
+        private static int IndexOfNull<TValue>(
             byte[] buffer,
             int index,
-            int count)
+            int count,
+            ref BsonTrieNode<TValue> bsonTrieNode)
         {
-            while (count > 0)
+            for (; count > 0; index++, count--)
             {
+                // bsonTrieNode might be null on entry or it might become null while navigating the trie
                 if (bsonTrieNode == null)
                 {
                     return Array.IndexOf<byte>(buffer, 0, index, count);
                 }
 
-                var c = buffer[index];
-
-                if (c == 0)
+                var keyByte = buffer[index];
+                if (keyByte == 0)
                 {
-                    if (!bsonTrieNode.HasValue)
-                    {
-                        bsonTrieNode = null;
-                    }
-
                     return index;
                 }
 
-                bsonTrieNode = bsonTrie.GetNext(
-                    bsonTrieNode,
-                    c);
-
-                ++index;
-
-                --count;
+                bsonTrieNode = bsonTrieNode.GetChild(keyByte); // might return null
             }
 
             return -1;
         }
-
-        private string GetSingleChunkString(int length)
-        {
-            switch (length)
-            {
-                // special case empty strings
-                case 0:
-                    return string.Empty;
-
-                // special case single character strings
-                case 1:
-                    int tableIndex = _chunk[_chunkOffset] - 32;
-                    if ((uint)tableIndex < __asciiStringTable.Length)
-                    {
-                        return __asciiStringTable[tableIndex];
-                    }
-                    break;
-            }
-
-            return __utf8Encoding.GetString(_chunk, _chunkOffset, length);
-        }
     }
 }

Bson/IO/BsonDocumentReader.cs

@@ -103,10 +103,15 @@ public override bool ReadBoolean()
         /// <summary>
         /// Reads a BsonType from the reader.
         /// </summary>
+        /// <param name="bsonTrie">An optional trie to search for a value that matches the next element name.</param>
+        /// <param name="found">Set to true if a matching value was found in the trie.</param>
+        /// <param name="value">Set to the matching value found in the trie or null if no matching value was found.</param>
         /// <returns>A BsonType.</returns>
-        public override BsonType ReadBsonType(BsonTrie bsonTrie)
+        public override BsonType ReadBsonType<TValue>(BsonTrie<TValue> bsonTrie, out bool found, out TValue value)
         {
             if (Disposed) { ThrowObjectDisposedException(); }
+            found = false;
+            value = default(TValue);
             if (State == BsonReaderState.Initial || State == BsonReaderState.ScopeDocument)
             {
                 // there is an implied type of Document for the top level and for scope documents
@@ -137,16 +142,11 @@ public override BsonType ReadBsonType(BsonTrie bsonTrie)
                         State = BsonReaderState.EndOfDocument;
                         return BsonType.EndOfDocument;
                     }
-                    object currentName;
-                    if (bsonTrie != null &&
-                        bsonTrie.TryGetValue(currentElement.Name, out currentName))
+                    if (bsonTrie != null)
                     {
-                        CurrentName = currentName;
-                    }
-                    else
-                    {
-                        CurrentName = currentElement.Name;
+                        found = bsonTrie.TryGetValue(currentElement.Name, out value);
                     }
+                    CurrentName = currentElement.Name;
                     _currentValue = currentElement.Value;
                     State = BsonReaderState.Name;
                     break;

Bson/IO/BsonDocumentReaderBookmark.cs

@@ -33,7 +33,7 @@ public class BsonDocumentReaderBookmark : BsonReaderBookmark
         internal BsonDocumentReaderBookmark(
             BsonReaderState state,
             BsonType currentBsonType,
-            object currentName,
+            string currentName,
             BsonDocumentReaderContext context,
             BsonValue currentValue)
             : base(state, currentBsonType, currentName)

Bson/IO/BsonReader.cs

@@ -31,7 +31,7 @@ public abstract class BsonReader : IDisposable
         private BsonReaderSettings _settings;
         private BsonReaderState _state;
         private BsonType _currentBsonType;
-        private object _currentName;
+        private string _currentName;
 
         // constructors
         /// <summary>
@@ -54,15 +54,6 @@ public BsonType CurrentBsonType
             protected set { _currentBsonType = value; }
         }
 
-        /// <summary>
-        /// Gets the current name.
-        /// </summary>
-        public object CurrentName
-        {
-            get { return _currentName; }
-            protected set { _currentName = value; }
-        }
-
         /// <summary>
         /// Gets the settings of the reader.
         /// </summary>
@@ -81,6 +72,15 @@ public BsonReaderState State
         }
 
         // protected properties
+        /// <summary>
+        /// Gets the current name.
+        /// </summary>
+        protected string CurrentName
+        {
+            get { return _currentName; }
+            set { _currentName = value; }
+        }
+
         /// <summary>
         /// Gets whether the BsonReader has been disposed.
         /// </summary>
@@ -364,17 +364,25 @@ public bool ReadBoolean(string name)
             return ReadBoolean();
         }
 
+        /// <summary>
+        /// Reads a BsonType from the reader.
+        /// </summary>
         /// <returns>A BsonType.</returns>
         public BsonType ReadBsonType()
         {
-            return this.ReadBsonType(null);
+            bool found;
+            object value;
+            return ReadBsonType(null, out found, out value);
         }
 
         /// <summary>
         /// Reads a BsonType from the reader.
         /// </summary>
+        /// <param name="bsonTrie">An optional trie to search for a value that matches the next element name.</param>
+        /// <param name="found">Set to true if a matching value was found in the trie.</param>
+        /// <param name="value">Set to the matching value found in the trie or null if no matching value was found.</param>
         /// <returns>A BsonType.</returns>
-        public abstract BsonType ReadBsonType(BsonTrie bsonTrie);
+        public abstract BsonType ReadBsonType<TValue>(BsonTrie<TValue> bsonTrie, out bool found, out TValue value);
 
         /// <summary>
         /// Reads a BSON DateTime from the reader.
@@ -535,7 +543,7 @@ public string ReadName()
             }
 
             _state = BsonReaderState.Value;
-            return _currentName as string;
+            return _currentName;
         }
 
         /// <summary>