CSHARP-666: Initial implementation of lazy and raw BsonDocument and BsonArray.

Author: rstam

MongoDB.Bson/IO/BsonBinaryReader.cs

@@ -13,6 +13,7 @@
 * limitations under the License.
 */
 
+using System;
 using System.IO;
 
 namespace MongoDB.Bson.IO
@@ -35,18 +36,35 @@ public class BsonBinaryReader : BsonReader
         /// <param name="buffer">A BsonBuffer.</param>
         /// <param name="settings">A BsonBinaryReaderSettings.</param>
         public BsonBinaryReader(BsonBuffer buffer, BsonBinaryReaderSettings settings)
+            : this(buffer ?? new BsonBuffer(), buffer == null, settings)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the BsonBinaryReader class.
+        /// </summary>
+        /// <param name="buffer">A BsonBuffer.</param>
+        /// <param name="disposeBuffer">if set to <c>true</c> this BsonBinaryReader will own the buffer and when Dispose is called the buffer will be Disposed also.</param>
+        /// <param name="settings">A BsonBinaryReaderSettings.</param>
+        /// <exception cref="System.ArgumentNullException">
+        /// buffer
+        /// or
+        /// settings
+        /// </exception>
+        public BsonBinaryReader(BsonBuffer buffer, bool disposeBuffer, BsonBinaryReaderSettings settings)
             : base(settings)
         {
             if (buffer == null)
             {
-                _buffer = new BsonBuffer();
-                _disposeBuffer = true; // only call Dispose if we allocated the buffer
+                throw new ArgumentNullException("buffer");
             }
-            else
+            if (settings == null)
             {
-                _buffer = buffer;
-                _disposeBuffer = false;
+                throw new ArgumentNullException("settings");
             }
+
+            _buffer = buffer;
+            _disposeBuffer = disposeBuffer;
             _binaryReaderSettings = settings; // already frozen by base class
             _context = new BsonBinaryReaderContext(null, ContextType.TopLevel, 0, 0);
         }
@@ -316,7 +334,7 @@ public override void ReadEndDocument()
             }
 
             _context = _context.PopContext(_buffer.Position);
-            if (_context != null && _context.ContextType == ContextType.JavaScriptWithScope)
+            if (_context.ContextType == ContextType.JavaScriptWithScope)
             {
                 _context = _context.PopContext(_buffer.Position); // JavaScriptWithScope
             }
@@ -425,6 +443,64 @@ public override ObjectId ReadObjectId()
             return _buffer.ReadObjectId();
         }
 
+        /// <summary>
+        /// Reads a raw BSON array.
+        /// </summary>
+        /// <returns>
+        /// The raw BSON array.
+        /// </returns>
+        public override IByteBuffer ReadRawBsonArray()
+        {
+            if (Disposed) { ThrowObjectDisposedException(); }
+            VerifyBsonType("ReadStartArray", BsonType.Array);
+
+            var position = _buffer.Position;
+            var length = _buffer.ReadInt32();
+            var slice = _buffer.ByteBuffer.GetSlice(position, length);
+            _buffer.Position = position + length;
+
+            switch (_context.ContextType)
+            {
+                case ContextType.Array: State = BsonReaderState.Type; break;
+                case ContextType.Document: State = BsonReaderState.Type; break;
+                case ContextType.TopLevel: State = BsonReaderState.Done; break;
+                default: throw new BsonInternalException("Unexpected ContextType.");
+            }
+
+            return slice;
+        }
+
+        /// <summary>
+        /// Reads a raw BSON document.
+        /// </summary>
+        /// <returns>
+        /// The raw BSON document.
+        /// </returns>
+        public override IByteBuffer ReadRawBsonDocument()
+        {
+            if (Disposed) { ThrowObjectDisposedException(); }
+            VerifyBsonType("ReadRawBsonDocument", BsonType.Document);
+
+            var position = _buffer.Position;
+            var length = _buffer.ReadInt32();
+            var slice = _buffer.ByteBuffer.GetSlice(position, length);
+            _buffer.Position = position + length;
+
+            if (_context.ContextType == ContextType.JavaScriptWithScope)
+            {
+                _context = _context.PopContext(_buffer.Position); // JavaScriptWithScope
+            }
+            switch (_context.ContextType)
+            {
+                case ContextType.Array: State = BsonReaderState.Type; break;
+                case ContextType.Document: State = BsonReaderState.Type; break;
+                case ContextType.TopLevel: State = BsonReaderState.Done; break;
+                default: throw new BsonInternalException("Unexpected ContextType.");
+            }
+
+            return slice;
+        }
+
         /// <summary>
         /// Reads a BSON regular expression from the reader.
         /// </summary>
@@ -597,8 +673,8 @@ protected override void Dispose(bool disposing)
                     if (_disposeBuffer)
                     {
                         _buffer.Dispose();
-                        _buffer = null;
                     }
+                    _buffer = null;
                 }
                 catch { } // ignore exceptions
             }

MongoDB.Bson/IO/BsonBinaryWriter.cs

@@ -38,19 +38,36 @@ public class BsonBinaryWriter : BsonWriter
         /// <param name="buffer">A BsonBuffer.</param>
         /// <param name="settings">Optional BsonBinaryWriter settings.</param>
         public BsonBinaryWriter(Stream stream, BsonBuffer buffer, BsonBinaryWriterSettings settings)
-            : base(settings)
+            : this(buffer ?? new BsonBuffer(), buffer == null, settings)
         {
             _stream = stream;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the BsonBinaryWriter class.
+        /// </summary>
+        /// <param name="buffer">A BsonBuffer.</param>
+        /// <param name="disposeBuffer">if set to <c>true</c> this BsonBinaryReader will own the buffer and when Dispose is called the buffer will be Disposed also.</param>
+        /// <param name="settings">Optional BsonBinaryWriter settings.</param>
+        /// <exception cref="System.ArgumentNullException">
+        /// encoder
+        /// or
+        /// settings
+        /// </exception>
+        public BsonBinaryWriter(BsonBuffer buffer, bool disposeBuffer, BsonBinaryWriterSettings settings)
+            : base(settings)
+        {
             if (buffer == null)
             {
-                _buffer = new BsonBuffer();
-                _disposeBuffer = true; // only call Dispose if we allocated the buffer
+                throw new ArgumentNullException("encoder");
             }
-            else
+            if (settings == null)
             {
-                _buffer = buffer;
-                _disposeBuffer = false;
+                throw new ArgumentNullException("settings");
             }
+
+            _buffer = buffer;
+            _disposeBuffer = disposeBuffer;
             _binaryWriterSettings = settings; // already frozen by base class
 
             _context = null;
@@ -461,6 +478,60 @@ public override void WriteObjectId(ObjectId objectId)
             State = GetNextState();
         }
 
+        /// <summary>
+        /// Writes a raw BSON array.
+        /// </summary>
+        /// <param name="slice">The byte buffer containing the raw BSON array.</param>
+        /// <exception cref="System.NotImplementedException"></exception>
+        public override void WriteRawBsonArray(IByteBuffer slice)
+        {
+            if (Disposed) { throw new ObjectDisposedException("BsonBinaryWriter"); }
+            if (State != BsonWriterState.Value)
+            {
+                ThrowInvalidState("WriteRawBsonArray", BsonWriterState.Value);
+            }
+
+            _buffer.WriteByte((byte)BsonType.Array);
+            WriteNameHelper();
+            _buffer.ByteBuffer.WriteBytes(slice); // assumes byteBuffer is a valid raw BSON document
+
+            State = GetNextState();
+        }
+
+        /// <summary>
+        /// Writes a raw BSON document.
+        /// </summary>
+        /// <param name="slice">The byte buffer containing the raw BSON document.</param>
+        public override void WriteRawBsonDocument(IByteBuffer slice)
+        {
+            if (Disposed) { throw new ObjectDisposedException("BsonBinaryWriter"); }
+            if (State != BsonWriterState.Initial && State != BsonWriterState.Value && State != BsonWriterState.ScopeDocument && State != BsonWriterState.Done)
+            {
+                ThrowInvalidState("WriteRawBsonDocument", BsonWriterState.Initial, BsonWriterState.Value, BsonWriterState.ScopeDocument, BsonWriterState.Done);
+            }
+
+            if (State == BsonWriterState.Value)
+            {
+                _buffer.WriteByte((byte)BsonType.Document);
+                WriteNameHelper();
+            }
+            _buffer.ByteBuffer.WriteBytes(slice); // assumes byteBuffer is a valid raw BSON document
+
+            if (_context == null)
+            {
+                State = BsonWriterState.Done;
+            }
+            else
+            {
+                if (_context.ContextType == ContextType.JavaScriptWithScope)
+                {
+                    BackpatchSize(); // size of the JavaScript with scope value
+                    _context = _context.ParentContext;
+                }
+                State = GetNextState();
+            }
+        }
+
         /// <summary>
         /// Writes a BSON regular expression to the writer.
         /// </summary>
@@ -612,9 +683,10 @@ protected override void Dispose(bool disposing)
                 if (_disposeBuffer)
                 {
                     _buffer.Dispose();
-                    _buffer = null;
                 }
+                _buffer = null;
             }
+            base.Dispose(disposing);
         }
 
         // private methods