CSHARP-933: Add support to JsonReader to read from a TextReader.

Author: rstam

src/MongoDB.Bson.Tests/IO/BsonBinaryReaderTests.cs

@@ -66,6 +66,34 @@ public void TestBsonAwesome()
             }
         }
 
+        [Test]
+        public void TestIsAtEndOfFileWithTwoDocuments()
+        {
+            var expected = new BsonDocument("x", 1);
+
+            byte[] bson;
+            using (var stream = new MemoryStream())
+            using (var writer = new BsonBinaryWriter(stream))
+            {
+                BsonSerializer.Serialize(writer, expected);
+                BsonSerializer.Serialize(writer, expected);
+                bson = stream.ToArray();
+            }
+
+            using (var stream = new MemoryStream(bson))
+            using (var reader = new BsonBinaryReader(stream))
+            {
+                var count = 0;
+                while (!reader.IsAtEndOfFile())
+                {
+                    var document = BsonSerializer.Deserialize<BsonDocument>(reader);
+                    Assert.AreEqual(expected, document);
+                    count++;
+                }
+                Assert.AreEqual(2, count);
+            }
+        }
+
         [Test]
         public void TestReadRawBsonArray()
         {
@@ -96,6 +124,7 @@ public void TestReadRawBsonDocument()
             }
         }
 
+        // private methods
         private static string __hexDigits = "0123456789abcdef";
 
         private byte[] DecodeByteString(string byteString)

src/MongoDB.Bson.Tests/IO/BsonDocumentReaderTests.cs

@@ -146,6 +146,24 @@ public void TestGuid()
             }
         }
 
+        [Test]
+        public void TestIsAtEndOfFile()
+        {
+            var expected = new BsonDocument("x", 1);
+
+            using (var reader = new BsonDocumentReader(expected))
+            {
+                var count = 0;
+                while (!reader.IsAtEndOfFile())
+                {
+                    var document = BsonSerializer.Deserialize<BsonDocument>(reader);
+                    Assert.AreEqual(expected, document);
+                    count++;
+                }
+                Assert.AreEqual(1, count);
+            }
+        }
+
         [Test]
         public void TestMaxKey()
         {

src/MongoDB.Bson.Tests/IO/JsonReaderTests.cs

@@ -418,6 +418,44 @@ public void TestInt64NumberLong()
             Assert.AreEqual(json, BsonSerializer.Deserialize<long>(json).ToJson());
         }
 
+        [Test]
+        public void TestIsAtEndOfFileWithTwoArrays()
+        {
+            var json = "[1,2][1,2]";
+
+            using (var jsonReader = new JsonReader(json))
+            {
+                var count = 0;
+                while (!jsonReader.IsAtEndOfFile())
+                {
+                    var array = BsonSerializer.Deserialize<BsonArray>(jsonReader);
+                    var expected = new BsonArray { 1, 2 };
+                    Assert.AreEqual(expected, array);
+                    count += 1;
+                }
+                Assert.AreEqual(2, count);
+            }
+        }
+
+        [Test]
+        public void TestIsAtEndOfFileWithTwoDocuments()
+        {
+            var json = "{x:1}{x:1}";
+
+            using (var jsonReader = new JsonReader(json))
+            {
+                var count = 0;
+                while (!jsonReader.IsAtEndOfFile())
+                {
+                    var document = BsonSerializer.Deserialize<BsonDocument>(jsonReader);
+                    var expected = new BsonDocument("x", 1);
+                    Assert.AreEqual(expected, document);
+                    count += 1;
+                }
+                Assert.AreEqual(2, count);
+            }
+        }
+
         [Test]
         public void TestJavaScript()
         {

src/MongoDB.Bson/IO/BsonBinaryReader.cs

@@ -81,6 +81,27 @@ public override BsonReaderBookmark GetBookmark()
             return new BsonBinaryReaderBookmark(State, CurrentBsonType, CurrentName, _context, (int)_streamReader.Position);
         }
 
+        /// <summary>
+        /// Determines whether this reader is at end of file.
+        /// </summary>
+        /// <returns>
+        /// Whether this reader is at end of file.
+        /// </returns>
+        public override bool IsAtEndOfFile()
+        {
+            var stream = _streamReader.BaseStream;
+            var c = stream.ReadByte();
+            if (c == -1)
+            {
+                return true;
+            }
+            else
+            {
+                stream.Seek(-1, SeekOrigin.Current);
+                return false;
+            }
+        }
+
         /// <summary>
         /// Reads BSON binary data from the reader.
         /// </summary>

src/MongoDB.Bson/IO/BsonDocumentReader.cs

@@ -75,6 +75,17 @@ public override BsonReaderBookmark GetBookmark()
             return new BsonDocumentReaderBookmark(State, CurrentBsonType, CurrentName, _context, _currentValue);
         }
 
+        /// <summary>
+        /// Determines whether this reader is at end of file.
+        /// </summary>
+        /// <returns>
+        /// Whether this reader is at end of file.
+        /// </returns>
+        public override bool IsAtEndOfFile()
+        {
+            return State == BsonReaderState.Done;
+        }
+
         /// <summary>
         /// Reads BSON binary data from the reader.
         /// </summary>

src/MongoDB.Bson/IO/BsonReader.cs

@@ -193,6 +193,14 @@ public BsonType GetCurrentBsonType()
             return _currentBsonType;
         }
 
+        /// <summary>
+        /// Determines whether this reader is at end of file.
+        /// </summary>
+        /// <returns>
+        /// Whether this reader is at end of file.
+        /// </returns>
+        public abstract bool IsAtEndOfFile();
+
         /// <summary>
         /// Reads BSON binary data from the reader.
         /// </summary>

src/MongoDB.Bson/IO/JsonBuffer.cs

@@ -13,87 +13,192 @@
 * limitations under the License.
 */
 
+using System;
+using System.IO;
+using System.Text;
+
 namespace MongoDB.Bson.IO
 {
     /// <summary>
-    /// This class represents a JSON string buffer.
+    /// Represents a wrapper around a TextReader to provide some buffering functionality.
     /// </summary>
-    public class JsonBuffer
+    internal class JsonBuffer
     {
         // private fields
-        private string _buffer;
+        private readonly StringBuilder _buffer;
         private int _position;
+        private readonly TextReader _reader;
 
         // constructors
         /// <summary>
-        /// Initializes a new instance of the JsonBuffer class.
+        /// Initializes a new instance of the <see cref="JsonBuffer"/> class.
         /// </summary>
-        /// <param name="buffer">The string.</param>
-        public JsonBuffer(string buffer)
+        /// <param name="json">The json.</param>
+        public JsonBuffer(string json)
         {
-            _buffer = buffer;
-            _position = 0;
+            if (json == null)
+            {
+                throw new ArgumentNullException("json");
+            }
+            _buffer = new StringBuilder(json);
         }
 
-        // internal properties
         /// <summary>
-        /// Gets the length of the JSON string.
+        /// Initializes a new instance of the <see cref="JsonBuffer" /> class.
         /// </summary>
-        public int Length
+        /// <param name="reader">The reader.</param>
+        public JsonBuffer(TextReader reader)
         {
-            get { return _buffer.Length; }
+            if (reader == null)
+            {
+                throw new ArgumentNullException("reader");
+            }
+            _buffer = new StringBuilder(256); // start out with a reasonable initial capacity
+            _reader = reader;
         }
 
+        // public properties
         /// <summary>
         /// Gets or sets the current position.
         /// </summary>
         public int Position
         {
             get { return _position; }
-            set { _position = value; }
+            set
+            {
+                if (value < 0 || value > _buffer.Length)
+                {
+                    var message = string.Format("Invalid position: {0}.", value);
+                    throw new ArgumentOutOfRangeException("value", message);
+                }
+                _position = value;
+            }
         }
 
         // public methods
         /// <summary>
-        /// Reads a character from the buffer.
+        /// Gets a snippet of a maximum length from the buffer (usually to include in an error message).
         /// </summary>
-        /// <returns>The next character (or -1 if at the end of the buffer).</returns>
-        public int Read()
+        /// <param name="start">The start.</param>
+        /// <param name="maxLength">The maximum length.</param>
+        /// <returns>The snippet.</returns>
+        public string GetSnippet(int start, int maxLength)
         {
-            return (_position >= _buffer.Length) ? -1 : _buffer[_position++];
+            if (start < 0)
+            {
+                throw new ArgumentOutOfRangeException("start", "Start cannot be negative.");
+            }
+            if (maxLength < 0)
+            {
+                throw new ArgumentOutOfRangeException("maxLength", "MaxLength cannot be negative.");
+            }
+            if (start > _position)
+            {
+                throw new ArgumentOutOfRangeException("start", "Start is beyond current position.");
+            }
+            var availableCount = _position - start;
+            var count = Math.Min(availableCount, maxLength);
+            return _buffer.ToString(start, count);
         }
 
         /// <summary>
-        /// Reads a substring from the buffer.
+        /// Gets a substring from the buffer.
         /// </summary>
-        /// <param name="start">The zero based index of the start of the substring.</param>
+        /// <param name="start">The start.</param>
+        /// <param name="count">The count.</param>
         /// <returns>The substring.</returns>
-        public string Substring(int start)
+        public string GetSubstring(int start, int count)
+        {
+            if (start < 0)
+            {
+                throw new ArgumentOutOfRangeException("start", "Start cannot be negative.");
+            }
+            if (count < 0)
+            {
+                throw new ArgumentOutOfRangeException("count", "Count cannot be negative.");
+            }
+            if (start > _position)
+            {
+                throw new ArgumentOutOfRangeException("start", "Start is beyond current position.");
+            }
+            if (start + count > _position)
+            {
+                throw new ArgumentOutOfRangeException("start", "End of substring is beyond current position.");
+            }
+            return _buffer.ToString(start, count);
+        }
+
+        /// <summary>
+        /// Reads the next character from the text reader and advances the character position by one character.
+        /// </summary>
+        /// <returns>
+        /// The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1.
+        /// </returns>
+        public int Read()
         {
-            return _buffer.Substring(start);
+            ReadMoreIfAtEndOfBuffer();
+            return _position >= _buffer.Length ? -1 : _buffer[_position++];
         }
 
         /// <summary>
-        /// Reads a substring from the buffer.
+        /// Resets the buffer (clears everything up to the current position).
         /// </summary>
-        /// <param name="start">The zero based index of the start of the substring.</param>
-        /// <param name="count">The number of characters in the substring.</param>
-        /// <returns>The substring.</returns>
-        public string Substring(int start, int count)
+        public void ResetBuffer()
         {
-            return _buffer.Substring(start, count);
+            // only trim the buffer if enough space will be reclaimed to make it worthwhile
+            var minimumTrimCount = 256; // TODO: make configurable?
+            if (_position >= minimumTrimCount)
+            {
+                _buffer.Remove(0, _position);
+                _position = 0;
+            }
         }
 
         /// <summary>
-        /// Returns one character to the buffer (if the character matches the one at the current position the current position is moved back by one).
+        /// Unreads one character (moving the current Position back one position).
         /// </summary>
-        /// <param name="c">The character to return.</param>
+        /// <param name="c">The character.</param>
         public void UnRead(int c)
         {
-            if (c != -1 && _buffer[_position - 1] == c)
+            if (_position == 0)
             {
+                throw new InvalidOperationException("Unread called when nothing has been read.");
+            }
+
+            if (c == -1)
+            {
+                if (_position != _buffer.Length)
+                {
+                    throw new InvalidOperationException("Unread called with -1 when position is not at the end of the buffer.");
+                }
+            }
+            else
+            {
+                if (_buffer[_position - 1] != c)
+                {
+                    throw new InvalidOperationException("Unread called with a character that does not match what is in the buffer.");
+                }
                 _position -= 1;
             }
         }
+
+        // private methods
+        private void ReadMoreIfAtEndOfBuffer()
+        {
+            if (_position >= _buffer.Length)
+            {
+                if (_reader != null)
+                {
+                    var blockSize = 1024; // TODO: make configurable?
+                    var block = new char[blockSize];
+                    var actualCount = _reader.ReadBlock(block, 0, blockSize);
+
+                    if (actualCount > 0)
+                    {
+                        _buffer.Append(block, 0, actualCount);
+                    }
+                }
+            }
+        }
     }
 }