You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
761 lines
27 KiB
761 lines
27 KiB
#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.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|