Index: third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs |
diff --git a/third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs b/third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs |
index 827f0398cf8466700873411413a5adfbc9d59a78..6211aac32cb173712656f587705b4036a2140775 100644 |
--- a/third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs |
+++ b/third_party/protobuf/csharp/src/Google.Protobuf/CodedOutputStream.cs |
@@ -1,761 +1,761 @@ |
-#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 |
-// notice, this list of conditions and the following disclaimer. |
-// * Redistributions in binary form must reproduce the above |
-// copyright notice, this list of conditions and the following disclaimer |
-// in the documentation and/or other materials provided with the |
-// distribution. |
-// * Neither the name of Google Inc. nor the names of its |
-// contributors may be used to endorse or promote products derived from |
-// this software without specific prior written permission. |
-// |
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
-#endregion |
- |
-using Google.Protobuf.Collections; |
-using System; |
-using System.IO; |
-using System.Text; |
- |
-namespace Google.Protobuf |
-{ |
- /// <summary> |
- /// Encodes and writes protocol message fields. |
- /// </summary> |
- /// <remarks> |
- /// <para> |
- /// This class is generally used by generated code to write appropriate |
- /// primitives to the stream. It effectively encapsulates the lowest |
- /// levels of protocol buffer format. Unlike some other implementations, |
- /// 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<T></c> |
- /// and <c>MapField<TKey, TValue></c> to serialize such fields. |
- /// </para> |
- /// </remarks> |
- 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; |
- 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; |
- 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> |
- /// <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) |
- { |
- return output.Position + position; |
- } |
- return position; |
- } |
- } |
- |
- #region Writing of values (not including tags) |
- |
- /// <summary> |
- /// Writes a double field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteDouble(double value) |
- { |
- WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value)); |
- } |
- |
- /// <summary> |
- /// Writes a float field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteFloat(float value) |
- { |
- byte[] rawBytes = BitConverter.GetBytes(value); |
- if (!BitConverter.IsLittleEndian) |
- { |
- ByteArray.Reverse(rawBytes); |
- } |
- |
- if (limit - position >= 4) |
- { |
- buffer[position++] = rawBytes[0]; |
- buffer[position++] = rawBytes[1]; |
- buffer[position++] = rawBytes[2]; |
- buffer[position++] = rawBytes[3]; |
- } |
- else |
- { |
- WriteRawBytes(rawBytes, 0, 4); |
- } |
- } |
- |
- /// <summary> |
- /// Writes a uint64 field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteUInt64(ulong value) |
- { |
- WriteRawVarint64(value); |
- } |
- |
- /// <summary> |
- /// Writes an int64 field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteInt64(long value) |
- { |
- WriteRawVarint64((ulong) value); |
- } |
- |
- /// <summary> |
- /// Writes an int32 field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteInt32(int value) |
- { |
- if (value >= 0) |
- { |
- WriteRawVarint32((uint) value); |
- } |
- else |
- { |
- // Must sign-extend. |
- WriteRawVarint64((ulong) value); |
- } |
- } |
- |
- /// <summary> |
- /// Writes a fixed64 field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteFixed64(ulong value) |
- { |
- WriteRawLittleEndian64(value); |
- } |
- |
- /// <summary> |
- /// Writes a fixed32 field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteFixed32(uint value) |
- { |
- WriteRawLittleEndian32(value); |
- } |
- |
- /// <summary> |
- /// Writes a bool field value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteBool(bool value) |
- { |
- WriteRawByte(value ? (byte) 1 : (byte) 0); |
- } |
- |
- /// <summary> |
- /// Writes a string field value, without a tag, to the stream. |
- /// The data is length-prefixed. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteString(string value) |
- { |
- // Optimise the case where we have enough space to write |
- // the string directly to the buffer, which should be common. |
- int length = Utf8Encoding.GetByteCount(value); |
- WriteLength(length); |
- if (limit - position >= length) |
- { |
- if (length == value.Length) // Must be all ASCII... |
- { |
- for (int i = 0; i < length; i++) |
- { |
- buffer[position + i] = (byte)value[i]; |
- } |
- } |
- else |
- { |
- Utf8Encoding.GetBytes(value, 0, value.Length, buffer, position); |
- } |
- position += length; |
- } |
- else |
- { |
- byte[] bytes = Utf8Encoding.GetBytes(value); |
- WriteRawBytes(bytes); |
- } |
- } |
- |
- /// <summary> |
- /// Writes a message, without a tag, to the stream. |
- /// The data is length-prefixed. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteMessage(IMessage value) |
- { |
- WriteLength(value.CalculateSize()); |
- value.WriteTo(this); |
- } |
- |
- /// <summary> |
- /// Write a byte string, without a tag, to the stream. |
- /// The data is length-prefixed. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteBytes(ByteString value) |
- { |
- WriteLength(value.Length); |
- value.WriteRawBytesTo(this); |
- } |
- |
- /// <summary> |
- /// Writes a uint32 value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteUInt32(uint value) |
- { |
- WriteRawVarint32(value); |
- } |
- |
- /// <summary> |
- /// Writes an enum value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteEnum(int value) |
- { |
- WriteInt32(value); |
- } |
- |
- /// <summary> |
- /// Writes an sfixed32 value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write.</param> |
- public void WriteSFixed32(int value) |
- { |
- WriteRawLittleEndian32((uint) value); |
- } |
- |
- /// <summary> |
- /// Writes an sfixed64 value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteSFixed64(long value) |
- { |
- WriteRawLittleEndian64((ulong) value); |
- } |
- |
- /// <summary> |
- /// Writes an sint32 value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteSInt32(int value) |
- { |
- WriteRawVarint32(EncodeZigZag32(value)); |
- } |
- |
- /// <summary> |
- /// Writes an sint64 value, without a tag, to the stream. |
- /// </summary> |
- /// <param name="value">The value to write</param> |
- public void WriteSInt64(long value) |
- { |
- WriteRawVarint64(EncodeZigZag64(value)); |
- } |
- |
- /// <summary> |
- /// Writes a length (in bytes) for length-delimited data. |
- /// </summary> |
- /// <remarks> |
- /// This method simply writes a rawint, but exists for clarity in calling code. |
- /// </remarks> |
- /// <param name="length">Length value, in bytes.</param> |
- public void WriteLength(int length) |
- { |
- WriteRawVarint32((uint) length); |
- } |
- |
- #endregion |
- |
- #region Raw tag writing |
- /// <summary> |
- /// Encodes and writes a tag. |
- /// </summary> |
- /// <param name="fieldNumber">The number of the field to write the tag for</param> |
- /// <param name="type">The wire format type of the tag to write</param> |
- public void WriteTag(int fieldNumber, WireFormat.WireType type) |
- { |
- WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type)); |
- } |
- |
- /// <summary> |
- /// Writes an already-encoded tag. |
- /// </summary> |
- /// <param name="tag">The encoded tag</param> |
- public void WriteTag(uint tag) |
- { |
- WriteRawVarint32(tag); |
- } |
- |
- /// <summary> |
- /// Writes the given single-byte tag directly to the stream. |
- /// </summary> |
- /// <param name="b1">The encoded tag</param> |
- public void WriteRawTag(byte b1) |
- { |
- WriteRawByte(b1); |
- } |
- |
- /// <summary> |
- /// Writes the given two-byte tag directly to the stream. |
- /// </summary> |
- /// <param name="b1">The first byte of the encoded tag</param> |
- /// <param name="b2">The second byte of the encoded tag</param> |
- public void WriteRawTag(byte b1, byte b2) |
- { |
- WriteRawByte(b1); |
- WriteRawByte(b2); |
- } |
- |
- /// <summary> |
- /// Writes the given three-byte tag directly to the stream. |
- /// </summary> |
- /// <param name="b1">The first byte of the encoded tag</param> |
- /// <param name="b2">The second byte of the encoded tag</param> |
- /// <param name="b3">The third byte of the encoded tag</param> |
- public void WriteRawTag(byte b1, byte b2, byte b3) |
- { |
- WriteRawByte(b1); |
- WriteRawByte(b2); |
- WriteRawByte(b3); |
- } |
- |
- /// <summary> |
- /// Writes the given four-byte tag directly to the stream. |
- /// </summary> |
- /// <param name="b1">The first byte of the encoded tag</param> |
- /// <param name="b2">The second byte of the encoded tag</param> |
- /// <param name="b3">The third byte of the encoded tag</param> |
- /// <param name="b4">The fourth byte of the encoded tag</param> |
- public void WriteRawTag(byte b1, byte b2, byte b3, byte b4) |
- { |
- WriteRawByte(b1); |
- WriteRawByte(b2); |
- WriteRawByte(b3); |
- WriteRawByte(b4); |
- } |
- |
- /// <summary> |
- /// Writes the given five-byte tag directly to the stream. |
- /// </summary> |
- /// <param name="b1">The first byte of the encoded tag</param> |
- /// <param name="b2">The second byte of the encoded tag</param> |
- /// <param name="b3">The third byte of the encoded tag</param> |
- /// <param name="b4">The fourth byte of the encoded tag</param> |
- /// <param name="b5">The fifth byte of the encoded tag</param> |
- public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5) |
- { |
- WriteRawByte(b1); |
- WriteRawByte(b2); |
- WriteRawByte(b3); |
- WriteRawByte(b4); |
- WriteRawByte(b5); |
- } |
- #endregion |
- |
- #region Underlying writing primitives |
- /// <summary> |
- /// Writes a 32 bit value as a varint. The fast route is taken when |
- /// there's enough buffer space left to whizz through without checking |
- /// for each byte; otherwise, we resort to calling WriteRawByte each time. |
- /// </summary> |
- internal void WriteRawVarint32(uint value) |
- { |
- // Optimize for the common case of a single byte value |
- if (value < 128 && position < limit) |
- { |
- buffer[position++] = (byte)value; |
- return; |
- } |
- |
- while (value > 127 && position < limit) |
- { |
- buffer[position++] = (byte) ((value & 0x7F) | 0x80); |
- value >>= 7; |
- } |
- while (value > 127) |
- { |
- WriteRawByte((byte) ((value & 0x7F) | 0x80)); |
- value >>= 7; |
- } |
- if (position < limit) |
- { |
- buffer[position++] = (byte) value; |
- } |
- else |
- { |
- WriteRawByte((byte) value); |
- } |
- } |
- |
- internal void WriteRawVarint64(ulong value) |
- { |
- while (value > 127 && position < limit) |
- { |
- buffer[position++] = (byte) ((value & 0x7F) | 0x80); |
- value >>= 7; |
- } |
- while (value > 127) |
- { |
- WriteRawByte((byte) ((value & 0x7F) | 0x80)); |
- value >>= 7; |
- } |
- if (position < limit) |
- { |
- buffer[position++] = (byte) value; |
- } |
- else |
- { |
- WriteRawByte((byte) value); |
- } |
- } |
- |
- internal void WriteRawLittleEndian32(uint value) |
- { |
- if (position + 4 > limit) |
- { |
- WriteRawByte((byte) value); |
- WriteRawByte((byte) (value >> 8)); |
- WriteRawByte((byte) (value >> 16)); |
- WriteRawByte((byte) (value >> 24)); |
- } |
- else |
- { |
- buffer[position++] = ((byte) value); |
- buffer[position++] = ((byte) (value >> 8)); |
- buffer[position++] = ((byte) (value >> 16)); |
- buffer[position++] = ((byte) (value >> 24)); |
- } |
- } |
- |
- internal void WriteRawLittleEndian64(ulong value) |
- { |
- if (position + 8 > limit) |
- { |
- WriteRawByte((byte) value); |
- WriteRawByte((byte) (value >> 8)); |
- WriteRawByte((byte) (value >> 16)); |
- WriteRawByte((byte) (value >> 24)); |
- WriteRawByte((byte) (value >> 32)); |
- WriteRawByte((byte) (value >> 40)); |
- WriteRawByte((byte) (value >> 48)); |
- WriteRawByte((byte) (value >> 56)); |
- } |
- else |
- { |
- buffer[position++] = ((byte) value); |
- buffer[position++] = ((byte) (value >> 8)); |
- buffer[position++] = ((byte) (value >> 16)); |
- buffer[position++] = ((byte) (value >> 24)); |
- buffer[position++] = ((byte) (value >> 32)); |
- buffer[position++] = ((byte) (value >> 40)); |
- buffer[position++] = ((byte) (value >> 48)); |
- buffer[position++] = ((byte) (value >> 56)); |
- } |
- } |
- |
- internal void WriteRawByte(byte value) |
- { |
- if (position == limit) |
- { |
- RefreshBuffer(); |
- } |
- |
- buffer[position++] = value; |
- } |
- |
- internal void WriteRawByte(uint value) |
- { |
- WriteRawByte((byte) value); |
- } |
- |
- /// <summary> |
- /// Writes out an array of bytes. |
- /// </summary> |
- internal void WriteRawBytes(byte[] value) |
- { |
- WriteRawBytes(value, 0, value.Length); |
- } |
- |
- /// <summary> |
- /// Writes out part of an array of bytes. |
- /// </summary> |
- internal void WriteRawBytes(byte[] value, int offset, int length) |
- { |
- if (limit - position >= length) |
- { |
- ByteArray.Copy(value, offset, buffer, position, length); |
- // We have room in the current buffer. |
- position += length; |
- } |
- else |
- { |
- // Write extends past current buffer. Fill the rest of this buffer and |
- // flush. |
- int bytesWritten = limit - position; |
- ByteArray.Copy(value, offset, buffer, position, bytesWritten); |
- offset += bytesWritten; |
- length -= bytesWritten; |
- position = limit; |
- RefreshBuffer(); |
- |
- // Now deal with the rest. |
- // Since we have an output stream, this is our buffer |
- // and buffer offset == 0 |
- if (length <= limit) |
- { |
- // Fits in new buffer. |
- ByteArray.Copy(value, offset, buffer, 0, length); |
- position = length; |
- } |
- else |
- { |
- // Write is very big. Let's do it all at once. |
- output.Write(value, offset, length); |
- } |
- } |
- } |
- |
- #endregion |
- |
- /// <summary> |
- /// Encode a 32-bit value with ZigZag encoding. |
- /// </summary> |
- /// <remarks> |
- /// ZigZag encodes signed integers into values that can be efficiently |
- /// encoded with varint. (Otherwise, negative values must be |
- /// sign-extended to 64 bits to be varint encoded, thus always taking |
- /// 10 bytes on the wire.) |
- /// </remarks> |
- internal static uint EncodeZigZag32(int n) |
- { |
- // Note: the right-shift must be arithmetic |
- return (uint) ((n << 1) ^ (n >> 31)); |
- } |
- |
- /// <summary> |
- /// Encode a 64-bit value with ZigZag encoding. |
- /// </summary> |
- /// <remarks> |
- /// ZigZag encodes signed integers into values that can be efficiently |
- /// encoded with varint. (Otherwise, negative values must be |
- /// sign-extended to 64 bits to be varint encoded, thus always taking |
- /// 10 bytes on the wire.) |
- /// </remarks> |
- internal static ulong EncodeZigZag64(long n) |
- { |
- return (ulong) ((n << 1) ^ (n >> 63)); |
- } |
- |
- private void RefreshBuffer() |
- { |
- if (output == null) |
- { |
- // We're writing to a single buffer. |
- throw new OutOfSpaceException(); |
- } |
- |
- // Since we have an output stream, this is our buffer |
- // and buffer offset == 0 |
- output.Write(buffer, 0, position); |
- position = 0; |
- } |
- |
- /// <summary> |
- /// Indicates that a CodedOutputStream wrapping a flat byte array |
- /// ran out of space. |
- /// </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(); |
- } |
- } |
- |
- /// <summary> |
- /// Verifies that SpaceLeft returns zero. It's common to create a byte array |
- /// that is exactly big enough to hold a message, then write to it with |
- /// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that |
- /// the message was actually as big as expected, which can help bugs. |
- /// </summary> |
- public void CheckNoSpaceLeft() |
- { |
- if (SpaceLeft != 0) |
- { |
- throw new InvalidOperationException("Did not write as much data as expected."); |
- } |
- } |
- |
- /// <summary> |
- /// If writing to a flat array, returns the space left in the array. Otherwise, |
- /// throws an InvalidOperationException. |
- /// </summary> |
- public int SpaceLeft |
- { |
- get |
- { |
- if (output == null) |
- { |
- return limit - position; |
- } |
- else |
- { |
- throw new InvalidOperationException( |
- "SpaceLeft can only be called on CodedOutputStreams that are " + |
- "writing to a flat array."); |
- } |
- } |
- } |
- } |
-} |
+#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 |
+// notice, this list of conditions and the following disclaimer. |
+// * Redistributions in binary form must reproduce the above |
+// copyright notice, this list of conditions and the following disclaimer |
+// in the documentation and/or other materials provided with the |
+// distribution. |
+// * Neither the name of Google Inc. nor the names of its |
+// contributors may be used to endorse or promote products derived from |
+// this software without specific prior written permission. |
+// |
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
+#endregion |
+ |
+using Google.Protobuf.Collections; |
+using System; |
+using System.IO; |
+using System.Text; |
+ |
+namespace Google.Protobuf |
+{ |
+ /// <summary> |
+ /// Encodes and writes protocol message fields. |
+ /// </summary> |
+ /// <remarks> |
+ /// <para> |
+ /// This class is generally used by generated code to write appropriate |
+ /// primitives to the stream. It effectively encapsulates the lowest |
+ /// levels of protocol buffer format. Unlike some other implementations, |
+ /// 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<T></c> |
+ /// and <c>MapField<TKey, TValue></c> to serialize such fields. |
+ /// </para> |
+ /// </remarks> |
+ 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; |
+ 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; |
+ 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> |
+ /// <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) |
+ { |
+ return output.Position + position; |
+ } |
+ return position; |
+ } |
+ } |
+ |
+ #region Writing of values (not including tags) |
+ |
+ /// <summary> |
+ /// Writes a double field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteDouble(double value) |
+ { |
+ WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value)); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a float field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteFloat(float value) |
+ { |
+ byte[] rawBytes = BitConverter.GetBytes(value); |
+ if (!BitConverter.IsLittleEndian) |
+ { |
+ ByteArray.Reverse(rawBytes); |
+ } |
+ |
+ if (limit - position >= 4) |
+ { |
+ buffer[position++] = rawBytes[0]; |
+ buffer[position++] = rawBytes[1]; |
+ buffer[position++] = rawBytes[2]; |
+ buffer[position++] = rawBytes[3]; |
+ } |
+ else |
+ { |
+ WriteRawBytes(rawBytes, 0, 4); |
+ } |
+ } |
+ |
+ /// <summary> |
+ /// Writes a uint64 field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteUInt64(ulong value) |
+ { |
+ WriteRawVarint64(value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an int64 field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteInt64(long value) |
+ { |
+ WriteRawVarint64((ulong) value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an int32 field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteInt32(int value) |
+ { |
+ if (value >= 0) |
+ { |
+ WriteRawVarint32((uint) value); |
+ } |
+ else |
+ { |
+ // Must sign-extend. |
+ WriteRawVarint64((ulong) value); |
+ } |
+ } |
+ |
+ /// <summary> |
+ /// Writes a fixed64 field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteFixed64(ulong value) |
+ { |
+ WriteRawLittleEndian64(value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a fixed32 field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteFixed32(uint value) |
+ { |
+ WriteRawLittleEndian32(value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a bool field value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteBool(bool value) |
+ { |
+ WriteRawByte(value ? (byte) 1 : (byte) 0); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a string field value, without a tag, to the stream. |
+ /// The data is length-prefixed. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteString(string value) |
+ { |
+ // Optimise the case where we have enough space to write |
+ // the string directly to the buffer, which should be common. |
+ int length = Utf8Encoding.GetByteCount(value); |
+ WriteLength(length); |
+ if (limit - position >= length) |
+ { |
+ if (length == value.Length) // Must be all ASCII... |
+ { |
+ for (int i = 0; i < length; i++) |
+ { |
+ buffer[position + i] = (byte)value[i]; |
+ } |
+ } |
+ else |
+ { |
+ Utf8Encoding.GetBytes(value, 0, value.Length, buffer, position); |
+ } |
+ position += length; |
+ } |
+ else |
+ { |
+ byte[] bytes = Utf8Encoding.GetBytes(value); |
+ WriteRawBytes(bytes); |
+ } |
+ } |
+ |
+ /// <summary> |
+ /// Writes a message, without a tag, to the stream. |
+ /// The data is length-prefixed. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteMessage(IMessage value) |
+ { |
+ WriteLength(value.CalculateSize()); |
+ value.WriteTo(this); |
+ } |
+ |
+ /// <summary> |
+ /// Write a byte string, without a tag, to the stream. |
+ /// The data is length-prefixed. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteBytes(ByteString value) |
+ { |
+ WriteLength(value.Length); |
+ value.WriteRawBytesTo(this); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a uint32 value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteUInt32(uint value) |
+ { |
+ WriteRawVarint32(value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an enum value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteEnum(int value) |
+ { |
+ WriteInt32(value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an sfixed32 value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write.</param> |
+ public void WriteSFixed32(int value) |
+ { |
+ WriteRawLittleEndian32((uint) value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an sfixed64 value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteSFixed64(long value) |
+ { |
+ WriteRawLittleEndian64((ulong) value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an sint32 value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteSInt32(int value) |
+ { |
+ WriteRawVarint32(EncodeZigZag32(value)); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an sint64 value, without a tag, to the stream. |
+ /// </summary> |
+ /// <param name="value">The value to write</param> |
+ public void WriteSInt64(long value) |
+ { |
+ WriteRawVarint64(EncodeZigZag64(value)); |
+ } |
+ |
+ /// <summary> |
+ /// Writes a length (in bytes) for length-delimited data. |
+ /// </summary> |
+ /// <remarks> |
+ /// This method simply writes a rawint, but exists for clarity in calling code. |
+ /// </remarks> |
+ /// <param name="length">Length value, in bytes.</param> |
+ public void WriteLength(int length) |
+ { |
+ WriteRawVarint32((uint) length); |
+ } |
+ |
+ #endregion |
+ |
+ #region Raw tag writing |
+ /// <summary> |
+ /// Encodes and writes a tag. |
+ /// </summary> |
+ /// <param name="fieldNumber">The number of the field to write the tag for</param> |
+ /// <param name="type">The wire format type of the tag to write</param> |
+ public void WriteTag(int fieldNumber, WireFormat.WireType type) |
+ { |
+ WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type)); |
+ } |
+ |
+ /// <summary> |
+ /// Writes an already-encoded tag. |
+ /// </summary> |
+ /// <param name="tag">The encoded tag</param> |
+ public void WriteTag(uint tag) |
+ { |
+ WriteRawVarint32(tag); |
+ } |
+ |
+ /// <summary> |
+ /// Writes the given single-byte tag directly to the stream. |
+ /// </summary> |
+ /// <param name="b1">The encoded tag</param> |
+ public void WriteRawTag(byte b1) |
+ { |
+ WriteRawByte(b1); |
+ } |
+ |
+ /// <summary> |
+ /// Writes the given two-byte tag directly to the stream. |
+ /// </summary> |
+ /// <param name="b1">The first byte of the encoded tag</param> |
+ /// <param name="b2">The second byte of the encoded tag</param> |
+ public void WriteRawTag(byte b1, byte b2) |
+ { |
+ WriteRawByte(b1); |
+ WriteRawByte(b2); |
+ } |
+ |
+ /// <summary> |
+ /// Writes the given three-byte tag directly to the stream. |
+ /// </summary> |
+ /// <param name="b1">The first byte of the encoded tag</param> |
+ /// <param name="b2">The second byte of the encoded tag</param> |
+ /// <param name="b3">The third byte of the encoded tag</param> |
+ public void WriteRawTag(byte b1, byte b2, byte b3) |
+ { |
+ WriteRawByte(b1); |
+ WriteRawByte(b2); |
+ WriteRawByte(b3); |
+ } |
+ |
+ /// <summary> |
+ /// Writes the given four-byte tag directly to the stream. |
+ /// </summary> |
+ /// <param name="b1">The first byte of the encoded tag</param> |
+ /// <param name="b2">The second byte of the encoded tag</param> |
+ /// <param name="b3">The third byte of the encoded tag</param> |
+ /// <param name="b4">The fourth byte of the encoded tag</param> |
+ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4) |
+ { |
+ WriteRawByte(b1); |
+ WriteRawByte(b2); |
+ WriteRawByte(b3); |
+ WriteRawByte(b4); |
+ } |
+ |
+ /// <summary> |
+ /// Writes the given five-byte tag directly to the stream. |
+ /// </summary> |
+ /// <param name="b1">The first byte of the encoded tag</param> |
+ /// <param name="b2">The second byte of the encoded tag</param> |
+ /// <param name="b3">The third byte of the encoded tag</param> |
+ /// <param name="b4">The fourth byte of the encoded tag</param> |
+ /// <param name="b5">The fifth byte of the encoded tag</param> |
+ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5) |
+ { |
+ WriteRawByte(b1); |
+ WriteRawByte(b2); |
+ WriteRawByte(b3); |
+ WriteRawByte(b4); |
+ WriteRawByte(b5); |
+ } |
+ #endregion |
+ |
+ #region Underlying writing primitives |
+ /// <summary> |
+ /// Writes a 32 bit value as a varint. The fast route is taken when |
+ /// there's enough buffer space left to whizz through without checking |
+ /// for each byte; otherwise, we resort to calling WriteRawByte each time. |
+ /// </summary> |
+ internal void WriteRawVarint32(uint value) |
+ { |
+ // Optimize for the common case of a single byte value |
+ if (value < 128 && position < limit) |
+ { |
+ buffer[position++] = (byte)value; |
+ return; |
+ } |
+ |
+ while (value > 127 && position < limit) |
+ { |
+ buffer[position++] = (byte) ((value & 0x7F) | 0x80); |
+ value >>= 7; |
+ } |
+ while (value > 127) |
+ { |
+ WriteRawByte((byte) ((value & 0x7F) | 0x80)); |
+ value >>= 7; |
+ } |
+ if (position < limit) |
+ { |
+ buffer[position++] = (byte) value; |
+ } |
+ else |
+ { |
+ WriteRawByte((byte) value); |
+ } |
+ } |
+ |
+ internal void WriteRawVarint64(ulong value) |
+ { |
+ while (value > 127 && position < limit) |
+ { |
+ buffer[position++] = (byte) ((value & 0x7F) | 0x80); |
+ value >>= 7; |
+ } |
+ while (value > 127) |
+ { |
+ WriteRawByte((byte) ((value & 0x7F) | 0x80)); |
+ value >>= 7; |
+ } |
+ if (position < limit) |
+ { |
+ buffer[position++] = (byte) value; |
+ } |
+ else |
+ { |
+ WriteRawByte((byte) value); |
+ } |
+ } |
+ |
+ internal void WriteRawLittleEndian32(uint value) |
+ { |
+ if (position + 4 > limit) |
+ { |
+ WriteRawByte((byte) value); |
+ WriteRawByte((byte) (value >> 8)); |
+ WriteRawByte((byte) (value >> 16)); |
+ WriteRawByte((byte) (value >> 24)); |
+ } |
+ else |
+ { |
+ buffer[position++] = ((byte) value); |
+ buffer[position++] = ((byte) (value >> 8)); |
+ buffer[position++] = ((byte) (value >> 16)); |
+ buffer[position++] = ((byte) (value >> 24)); |
+ } |
+ } |
+ |
+ internal void WriteRawLittleEndian64(ulong value) |
+ { |
+ if (position + 8 > limit) |
+ { |
+ WriteRawByte((byte) value); |
+ WriteRawByte((byte) (value >> 8)); |
+ WriteRawByte((byte) (value >> 16)); |
+ WriteRawByte((byte) (value >> 24)); |
+ WriteRawByte((byte) (value >> 32)); |
+ WriteRawByte((byte) (value >> 40)); |
+ WriteRawByte((byte) (value >> 48)); |
+ WriteRawByte((byte) (value >> 56)); |
+ } |
+ else |
+ { |
+ buffer[position++] = ((byte) value); |
+ buffer[position++] = ((byte) (value >> 8)); |
+ buffer[position++] = ((byte) (value >> 16)); |
+ buffer[position++] = ((byte) (value >> 24)); |
+ buffer[position++] = ((byte) (value >> 32)); |
+ buffer[position++] = ((byte) (value >> 40)); |
+ buffer[position++] = ((byte) (value >> 48)); |
+ buffer[position++] = ((byte) (value >> 56)); |
+ } |
+ } |
+ |
+ internal void WriteRawByte(byte value) |
+ { |
+ if (position == limit) |
+ { |
+ RefreshBuffer(); |
+ } |
+ |
+ buffer[position++] = value; |
+ } |
+ |
+ internal void WriteRawByte(uint value) |
+ { |
+ WriteRawByte((byte) value); |
+ } |
+ |
+ /// <summary> |
+ /// Writes out an array of bytes. |
+ /// </summary> |
+ internal void WriteRawBytes(byte[] value) |
+ { |
+ WriteRawBytes(value, 0, value.Length); |
+ } |
+ |
+ /// <summary> |
+ /// Writes out part of an array of bytes. |
+ /// </summary> |
+ internal void WriteRawBytes(byte[] value, int offset, int length) |
+ { |
+ if (limit - position >= length) |
+ { |
+ ByteArray.Copy(value, offset, buffer, position, length); |
+ // We have room in the current buffer. |
+ position += length; |
+ } |
+ else |
+ { |
+ // Write extends past current buffer. Fill the rest of this buffer and |
+ // flush. |
+ int bytesWritten = limit - position; |
+ ByteArray.Copy(value, offset, buffer, position, bytesWritten); |
+ offset += bytesWritten; |
+ length -= bytesWritten; |
+ position = limit; |
+ RefreshBuffer(); |
+ |
+ // Now deal with the rest. |
+ // Since we have an output stream, this is our buffer |
+ // and buffer offset == 0 |
+ if (length <= limit) |
+ { |
+ // Fits in new buffer. |
+ ByteArray.Copy(value, offset, buffer, 0, length); |
+ position = length; |
+ } |
+ else |
+ { |
+ // Write is very big. Let's do it all at once. |
+ output.Write(value, offset, length); |
+ } |
+ } |
+ } |
+ |
+ #endregion |
+ |
+ /// <summary> |
+ /// Encode a 32-bit value with ZigZag encoding. |
+ /// </summary> |
+ /// <remarks> |
+ /// ZigZag encodes signed integers into values that can be efficiently |
+ /// encoded with varint. (Otherwise, negative values must be |
+ /// sign-extended to 64 bits to be varint encoded, thus always taking |
+ /// 10 bytes on the wire.) |
+ /// </remarks> |
+ internal static uint EncodeZigZag32(int n) |
+ { |
+ // Note: the right-shift must be arithmetic |
+ return (uint) ((n << 1) ^ (n >> 31)); |
+ } |
+ |
+ /// <summary> |
+ /// Encode a 64-bit value with ZigZag encoding. |
+ /// </summary> |
+ /// <remarks> |
+ /// ZigZag encodes signed integers into values that can be efficiently |
+ /// encoded with varint. (Otherwise, negative values must be |
+ /// sign-extended to 64 bits to be varint encoded, thus always taking |
+ /// 10 bytes on the wire.) |
+ /// </remarks> |
+ internal static ulong EncodeZigZag64(long n) |
+ { |
+ return (ulong) ((n << 1) ^ (n >> 63)); |
+ } |
+ |
+ private void RefreshBuffer() |
+ { |
+ if (output == null) |
+ { |
+ // We're writing to a single buffer. |
+ throw new OutOfSpaceException(); |
+ } |
+ |
+ // Since we have an output stream, this is our buffer |
+ // and buffer offset == 0 |
+ output.Write(buffer, 0, position); |
+ position = 0; |
+ } |
+ |
+ /// <summary> |
+ /// Indicates that a CodedOutputStream wrapping a flat byte array |
+ /// ran out of space. |
+ /// </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(); |
+ } |
+ } |
+ |
+ /// <summary> |
+ /// Verifies that SpaceLeft returns zero. It's common to create a byte array |
+ /// that is exactly big enough to hold a message, then write to it with |
+ /// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that |
+ /// the message was actually as big as expected, which can help bugs. |
+ /// </summary> |
+ public void CheckNoSpaceLeft() |
+ { |
+ if (SpaceLeft != 0) |
+ { |
+ throw new InvalidOperationException("Did not write as much data as expected."); |
+ } |
+ } |
+ |
+ /// <summary> |
+ /// If writing to a flat array, returns the space left in the array. Otherwise, |
+ /// throws an InvalidOperationException. |
+ /// </summary> |
+ public int SpaceLeft |
+ { |
+ get |
+ { |
+ if (output == null) |
+ { |
+ return limit - position; |
+ } |
+ else |
+ { |
+ throw new InvalidOperationException( |
+ "SpaceLeft can only be called on CodedOutputStreams that are " + |
+ "writing to a flat array."); |
+ } |
+ } |
+ } |
+ } |
+} |