Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs

 #region Copyright notice and license
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ skipping 37 matching lines @@
     /// this does not include combined "write tag and value" methods. Generated
     /// code knows the exact byte representations of the tags they're going to write,
     /// so there's no need to re-encode them each time. Manually-written code calling
     /// this class should just call one of the <c>WriteTag</c> overloads before each value.
     /// </para>
     /// <para>
     /// Repeated fields and map fields are not handled by this class; use <c>RepeatedField&lt;T&gt;</c>
     /// and <c>MapField&lt;TKey, TValue&gt;</c> to serialize such fields.
     /// </para>
     /// </remarks>
-    public sealed partial class CodedOutputStream
+    public sealed partial class CodedOutputStream : IDisposable
     {
         // "Local" copy of Encoding.UTF8, for efficiency. (Yes, it makes a difference.)
         internal static readonly Encoding Utf8Encoding = Encoding.UTF8;
 
         /// <summary>
         /// The buffer size used by CreateInstance(Stream).
         /// </summary>
         public static readonly int DefaultBufferSize = 4096;
 
+        private readonly bool leaveOpen;
         private readonly byte[] buffer;
         private readonly int limit;
         private int position;
         private readonly Stream output;
 
         #region Construction
         /// <summary>
         /// Creates a new CodedOutputStream that writes directly to the given
         /// byte array. If more bytes are written than fit in the array,
         /// OutOfSpaceException will be thrown.
         /// </summary>
         public CodedOutputStream(byte[] flatArray) : this(flatArray, 0, flatArray.Length)
         {
         }
 
         /// <summary>
         /// Creates a new CodedOutputStream that writes directly to the given
         /// byte array slice. If more bytes are written than fit in the array,
         /// OutOfSpaceException will be thrown.
         /// </summary>
         private CodedOutputStream(byte[] buffer, int offset, int length)
         {
             this.output = null;
             this.buffer = buffer;
             this.position = offset;
             this.limit = offset + length;
-        }
-
-        private CodedOutputStream(Stream output, byte[] buffer)
-        {
-            this.output = output;
+            leaveOpen = true; // Simple way of avoiding trying to dispose of a null reference
+        }
+
+        private CodedOutputStream(Stream output, byte[] buffer, bool leaveOpen)
+        {
+            this.output = ProtoPreconditions.CheckNotNull(output, nameof(output));
             this.buffer = buffer;
             this.position = 0;
             this.limit = buffer.Length;
-        }
-
-        /// <summary>
-        /// Creates a new CodedOutputStream which write to the given stream.
-        /// </summary>
-        public CodedOutputStream(Stream output) : this(output, DefaultBufferSize)
+            this.leaveOpen = leaveOpen;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="CodedOutputStream" /> which write to the given stream, and disposes of that
+        /// stream when the returned <c>CodedOutputStream</c> is disposed.
+        /// </summary>
+        /// <param name="output">The stream to write to. It will be disposed when the returned <c>CodedOutputStream is disposed.</c></param>
+        public CodedOutputStream(Stream output) : this(output, DefaultBufferSize, false)
         {
         }
 
         /// <summary>
         /// Creates a new CodedOutputStream which write to the given stream and uses
         /// the specified buffer size.
         /// </summary>
-        public CodedOutputStream(Stream output, int bufferSize) : this(output, new byte[bufferSize])
-        {
-        }    
+        /// <param name="output">The stream to write to. It will be disposed when the returned <c>CodedOutputStream is disposed.</c></param>
+        /// <param name="bufferSize">The size of buffer to use internally.</param>
+        public CodedOutputStream(Stream output, int bufferSize) : this(output, new byte[bufferSize], false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream which write to the given stream.
+        /// </summary>
+        /// <param name="output">The stream to write to.</param>
+        /// <param name="leaveOpen">If <c>true</c>, <paramref name="output"/> is left open when the returned <c>CodedOutputStream</c> is disposed;
+        /// if <c>false</c>, the provided stream is disposed as well.</param>
+        public CodedOutputStream(Stream output, bool leaveOpen) : this(output, DefaultBufferSize, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream which write to the given stream and uses
+        /// the specified buffer size.
+        /// </summary>
+        /// <param name="output">The stream to write to.</param>
+        /// <param name="bufferSize">The size of buffer to use internally.</param>
+        /// <param name="leaveOpen">If <c>true</c>, <paramref name="output"/> is left open when the returned <c>CodedOutputStream</c> is disposed;
+        /// if <c>false</c>, the provided stream is disposed as well.</param>
+        public CodedOutputStream(Stream output, int bufferSize, bool leaveOpen) : this(output, new byte[bufferSize], leaveOpen)
+        {
+        }
         #endregion
 
         /// <summary>
         /// Returns the current position in the stream, or the position in the output buffer
         /// </summary>
         public long Position
         {
             get
             {
                 if (output != null)
@@ skipping 525 matching lines @@
         /// </summary>
         public sealed class OutOfSpaceException : IOException
         {
             internal OutOfSpaceException()
                 : base("CodedOutputStream was writing to a flat byte array and ran out of space.")
             {
             }
         }
 
         /// <summary>
+        /// Flushes any buffered data and optionally closes the underlying stream, if any.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// By default, any underlying stream is closed by this method. To configure this behaviour,
+        /// use a constructor overload with a <c>leaveOpen</c> parameter. If this instance does not
+        /// have an underlying stream, this method does nothing.
+        /// </para>
+        /// <para>
+        /// For the sake of efficiency, calling this method does not prevent future write calls - but
+        /// if a later write ends up writing to a stream which has been disposed, that is likely to
+        /// fail. It is recommend that you not call any other methods after this.
+        /// </para>
+        /// </remarks>
+        public void Dispose()
+        {
+            Flush();
+            if (!leaveOpen)
+            {
+                output.Dispose();
+            }
+        }
+
+        /// <summary>
         /// Flushes any buffered data to the underlying stream (if there is one).
         /// </summary>
         public void Flush()
         {
             if (output != null)
             {
                 RefreshBuffer();
             }
         }
 
@@ skipping 25 matching lines @@
                 }
                 else
                 {
                     throw new InvalidOperationException(
                         "SpaceLeft can only be called on CodedOutputStreams that are " +
                         "writing to a flat array.");
                 }
             }
         }
     }
-}
+}