757 lines
31 KiB
C#
757 lines
31 KiB
C#
|
#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 System;
|
|||
|
|
using System.Buffers.Binary;
|
|||
|
|
using System.Diagnostics;
|
|||
|
|
using System.Runtime.CompilerServices;
|
|||
|
|
using System.Runtime.InteropServices;
|
|||
|
|
#if GOOGLE_PROTOBUF_SIMD
|
|||
|
|
using System.Runtime.Intrinsics;
|
|||
|
|
using System.Runtime.Intrinsics.Arm;
|
|||
|
|
using System.Runtime.Intrinsics.X86;
|
|||
|
|
#endif
|
|||
|
|
using System.Security;
|
|||
|
|
using System.Text;
|
|||
|
|
|
|||
|
|
namespace LC.Google.Protobuf
|
|||
|
|
{
|
|||
|
|
/// <summary>
|
|||
|
|
/// Primitives for encoding protobuf wire format.
|
|||
|
|
/// </summary>
|
|||
|
|
[SecuritySafeCritical]
|
|||
|
|
internal static class WritingPrimitives
|
|||
|
|
{
|
|||
|
|
#if NET5_0
|
|||
|
|
internal static Encoding Utf8Encoding => Encoding.UTF8; // allows JIT to devirtualize
|
|||
|
|
#else
|
|||
|
|
internal static readonly Encoding Utf8Encoding = Encoding.UTF8; // "Local" copy of Encoding.UTF8, for efficiency. (Yes, it makes a difference.)
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#region Writing of values (not including tags)
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a double field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteDouble(ref Span<byte> buffer, ref WriterInternalState state, double value)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian64(ref buffer, ref state, (ulong)BitConverter.DoubleToInt64Bits(value));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a float field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static unsafe void WriteFloat(ref Span<byte> buffer, ref WriterInternalState state, float value)
|
|||
|
|
{
|
|||
|
|
const int length = sizeof(float);
|
|||
|
|
if (buffer.Length - state.position >= length)
|
|||
|
|
{
|
|||
|
|
// if there's enough space in the buffer, write the float directly into the buffer
|
|||
|
|
var floatSpan = buffer.Slice(state.position, length);
|
|||
|
|
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
|
|||
|
|
|
|||
|
|
if (!BitConverter.IsLittleEndian)
|
|||
|
|
{
|
|||
|
|
floatSpan.Reverse();
|
|||
|
|
}
|
|||
|
|
state.position += length;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
WriteFloatSlowPath(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
private static unsafe void WriteFloatSlowPath(ref Span<byte> buffer, ref WriterInternalState state, float value)
|
|||
|
|
{
|
|||
|
|
const int length = sizeof(float);
|
|||
|
|
|
|||
|
|
// TODO(jtattermusch): deduplicate the code. Populating the span is the same as for the fastpath.
|
|||
|
|
Span<byte> floatSpan = stackalloc byte[length];
|
|||
|
|
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
|
|||
|
|
if (!BitConverter.IsLittleEndian)
|
|||
|
|
{
|
|||
|
|
floatSpan.Reverse();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
WriteRawByte(ref buffer, ref state, floatSpan[0]);
|
|||
|
|
WriteRawByte(ref buffer, ref state, floatSpan[1]);
|
|||
|
|
WriteRawByte(ref buffer, ref state, floatSpan[2]);
|
|||
|
|
WriteRawByte(ref buffer, ref state, floatSpan[3]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a uint64 field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteUInt64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint64(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an int64 field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint64(ref buffer, ref state, (ulong)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an int32 field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
|
|||
|
|
{
|
|||
|
|
if (value >= 0)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, (uint)value);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Must sign-extend.
|
|||
|
|
WriteRawVarint64(ref buffer, ref state, (ulong)value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a fixed64 field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteFixed64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian64(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a fixed32 field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteFixed32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian32(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a bool field value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteBool(ref Span<byte> buffer, ref WriterInternalState state, bool value)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, value ? (byte)1 : (byte)0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a string field value, without a tag, to the stream.
|
|||
|
|
/// The data is length-prefixed.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteString(ref Span<byte> buffer, ref WriterInternalState state, string value)
|
|||
|
|
{
|
|||
|
|
const int MaxBytesPerChar = 3;
|
|||
|
|
const int MaxSmallStringLength = 128 / MaxBytesPerChar;
|
|||
|
|
|
|||
|
|
// The string is small enough that the length will always be a 1 byte varint.
|
|||
|
|
// Also there is enough space to write length + bytes to buffer.
|
|||
|
|
// Write string directly to the buffer, and then write length.
|
|||
|
|
// This saves calling GetByteCount on the string. We get the string length from GetBytes.
|
|||
|
|
if (value.Length <= MaxSmallStringLength && buffer.Length - state.position - 1 >= value.Length * MaxBytesPerChar)
|
|||
|
|
{
|
|||
|
|
int indexOfLengthDelimiter = state.position++;
|
|||
|
|
buffer[indexOfLengthDelimiter] = (byte)WriteStringToBuffer(buffer, ref state, value);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int length = Utf8Encoding.GetByteCount(value);
|
|||
|
|
WriteLength(ref buffer, ref state, length);
|
|||
|
|
|
|||
|
|
// Optimise the case where we have enough space to write
|
|||
|
|
// the string directly to the buffer, which should be common.
|
|||
|
|
if (buffer.Length - state.position >= length)
|
|||
|
|
{
|
|||
|
|
if (length == value.Length) // Must be all ASCII...
|
|||
|
|
{
|
|||
|
|
WriteAsciiStringToBuffer(buffer, ref state, value, length);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
WriteStringToBuffer(buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Opportunity for future optimization:
|
|||
|
|
// Large strings that don't fit into the current buffer segment
|
|||
|
|
// can probably be optimized by using Utf8Encoding.GetEncoder()
|
|||
|
|
// but more benchmarks would need to be added as evidence.
|
|||
|
|
byte[] bytes = Utf8Encoding.GetBytes(value);
|
|||
|
|
WriteRawBytes(ref buffer, ref state, bytes);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Calling this method with non-ASCII content will break.
|
|||
|
|
// Content must be verified to be all ASCII before using this method.
|
|||
|
|
private static void WriteAsciiStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value, int length)
|
|||
|
|
{
|
|||
|
|
ref char sourceChars = ref MemoryMarshal.GetReference(value.AsSpan());
|
|||
|
|
ref byte destinationBytes = ref MemoryMarshal.GetReference(buffer.Slice(state.position));
|
|||
|
|
|
|||
|
|
int currentIndex = 0;
|
|||
|
|
// If 64bit, process 4 chars at a time.
|
|||
|
|
// The logic inside this check will be elided by JIT in 32bit programs.
|
|||
|
|
if (IntPtr.Size == 8)
|
|||
|
|
{
|
|||
|
|
// Need at least 4 chars available to use this optimization.
|
|||
|
|
if (length >= 4)
|
|||
|
|
{
|
|||
|
|
ref byte sourceBytes = ref Unsafe.As<char, byte>(ref sourceChars);
|
|||
|
|
|
|||
|
|
// Process 4 chars at a time until there are less than 4 remaining.
|
|||
|
|
// We already know all characters are ASCII so there is no need to validate the source.
|
|||
|
|
int lastIndexWhereCanReadFourChars = value.Length - 4;
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
NarrowFourUtf16CharsToAsciiAndWriteToBuffer(
|
|||
|
|
ref Unsafe.AddByteOffset(ref destinationBytes, (IntPtr)currentIndex),
|
|||
|
|
Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref sourceBytes, (IntPtr)(currentIndex * 2))));
|
|||
|
|
|
|||
|
|
} while ((currentIndex += 4) <= lastIndexWhereCanReadFourChars);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Process any remaining, 1 char at a time.
|
|||
|
|
// Avoid bounds checking with ref + Unsafe
|
|||
|
|
for (; currentIndex < length; currentIndex++)
|
|||
|
|
{
|
|||
|
|
Unsafe.AddByteOffset(ref destinationBytes, (IntPtr)currentIndex) = (byte)Unsafe.AddByteOffset(ref sourceChars, (IntPtr)(currentIndex * 2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
state.position += length;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Copied with permission from https://github.com/dotnet/runtime/blob/1cdafd27e4afd2c916af5df949c13f8b373c4335/src/libraries/System.Private.CoreLib/src/System/Text/ASCIIUtility.cs#L1119-L1171
|
|||
|
|
//
|
|||
|
|
/// <summary>
|
|||
|
|
/// Given a QWORD which represents a buffer of 4 ASCII chars in machine-endian order,
|
|||
|
|
/// narrows each WORD to a BYTE, then writes the 4-byte result to the output buffer
|
|||
|
|
/// also in machine-endian order.
|
|||
|
|
/// </summary>
|
|||
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|||
|
|
private static void NarrowFourUtf16CharsToAsciiAndWriteToBuffer(ref byte outputBuffer, ulong value)
|
|||
|
|
{
|
|||
|
|
#if GOOGLE_PROTOBUF_SIMD
|
|||
|
|
if (Sse2.X64.IsSupported)
|
|||
|
|
{
|
|||
|
|
// Narrows a vector of words [ w0 w1 w2 w3 ] to a vector of bytes
|
|||
|
|
// [ b0 b1 b2 b3 b0 b1 b2 b3 ], then writes 4 bytes (32 bits) to the destination.
|
|||
|
|
|
|||
|
|
Vector128<short> vecWide = Sse2.X64.ConvertScalarToVector128UInt64(value).AsInt16();
|
|||
|
|
Vector128<uint> vecNarrow = Sse2.PackUnsignedSaturate(vecWide, vecWide).AsUInt32();
|
|||
|
|
Unsafe.WriteUnaligned<uint>(ref outputBuffer, Sse2.ConvertToUInt32(vecNarrow));
|
|||
|
|
}
|
|||
|
|
else if (AdvSimd.IsSupported)
|
|||
|
|
{
|
|||
|
|
// Narrows a vector of words [ w0 w1 w2 w3 ] to a vector of bytes
|
|||
|
|
// [ b0 b1 b2 b3 * * * * ], then writes 4 bytes (32 bits) to the destination.
|
|||
|
|
|
|||
|
|
Vector128<short> vecWide = Vector128.CreateScalarUnsafe(value).AsInt16();
|
|||
|
|
Vector64<byte> lower = AdvSimd.ExtractNarrowingSaturateUnsignedLower(vecWide);
|
|||
|
|
Unsafe.WriteUnaligned<uint>(ref outputBuffer, lower.AsUInt32().ToScalar());
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
// Fallback to non-SIMD approach when SIMD is not available.
|
|||
|
|
// This could happen either because the APIs are not available, or hardware doesn't support it.
|
|||
|
|
// Processing 4 chars at a time in this fallback is still faster than casting one char at a time.
|
|||
|
|
if (BitConverter.IsLittleEndian)
|
|||
|
|
{
|
|||
|
|
outputBuffer = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
Unsafe.Add(ref outputBuffer, 1) = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
Unsafe.Add(ref outputBuffer, 2) = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
Unsafe.Add(ref outputBuffer, 3) = (byte)value;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Unsafe.Add(ref outputBuffer, 3) = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
Unsafe.Add(ref outputBuffer, 2) = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
Unsafe.Add(ref outputBuffer, 1) = (byte)value;
|
|||
|
|
value >>= 16;
|
|||
|
|
outputBuffer = (byte)value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static int WriteStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value)
|
|||
|
|
{
|
|||
|
|
#if NETSTANDARD1_1
|
|||
|
|
// slowpath when Encoding.GetBytes(Char*, Int32, Byte*, Int32) is not available
|
|||
|
|
byte[] bytes = Utf8Encoding.GetBytes(value);
|
|||
|
|
WriteRawBytes(ref buffer, ref state, bytes);
|
|||
|
|
return bytes.Length;
|
|||
|
|
#else
|
|||
|
|
ReadOnlySpan<char> source = value.AsSpan();
|
|||
|
|
int bytesUsed;
|
|||
|
|
unsafe
|
|||
|
|
{
|
|||
|
|
fixed (char* sourceChars = &MemoryMarshal.GetReference(source))
|
|||
|
|
fixed (byte* destinationBytes = &MemoryMarshal.GetReference(buffer))
|
|||
|
|
{
|
|||
|
|
bytesUsed = Utf8Encoding.GetBytes(
|
|||
|
|
sourceChars,
|
|||
|
|
source.Length,
|
|||
|
|
destinationBytes + state.position,
|
|||
|
|
buffer.Length - state.position);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
state.position += bytesUsed;
|
|||
|
|
return bytesUsed;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Write a byte string, without a tag, to the stream.
|
|||
|
|
/// The data is length-prefixed.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteBytes(ref Span<byte> buffer, ref WriterInternalState state, ByteString value)
|
|||
|
|
{
|
|||
|
|
WriteLength(ref buffer, ref state, value.Length);
|
|||
|
|
WriteRawBytes(ref buffer, ref state, value.Span);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes a uint32 value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteUInt32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an enum value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteEnum(ref Span<byte> buffer, ref WriterInternalState state, int value)
|
|||
|
|
{
|
|||
|
|
WriteInt32(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an sfixed32 value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteSFixed32(ref Span<byte> buffer, ref WriterInternalState state, int value)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian32(ref buffer, ref state, (uint)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an sfixed64 value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteSFixed64(ref Span<byte> buffer, ref WriterInternalState state, long value)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian64(ref buffer, ref state, (ulong)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an sint32 value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteSInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, EncodeZigZag32(value));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an sint64 value, without a tag, to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteSInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint64(ref buffer, ref state, 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>
|
|||
|
|
public static void WriteLength(ref Span<byte> buffer, ref WriterInternalState state, int length)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, (uint)length);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region 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>
|
|||
|
|
public static void WriteRawVarint32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
|
|||
|
|
{
|
|||
|
|
// Optimize for the common case of a single byte value
|
|||
|
|
if (value < 128 && state.position < buffer.Length)
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)value;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Fast path when capacity is available
|
|||
|
|
while (state.position < buffer.Length)
|
|||
|
|
{
|
|||
|
|
if (value > 127)
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
|
|||
|
|
value >>= 7;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)value;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (value > 127)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
|
|||
|
|
value >>= 7;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static void WriteRawVarint64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
|
|||
|
|
{
|
|||
|
|
// Optimize for the common case of a single byte value
|
|||
|
|
if (value < 128 && state.position < buffer.Length)
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)value;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Fast path when capacity is available
|
|||
|
|
while (state.position < buffer.Length)
|
|||
|
|
{
|
|||
|
|
if (value > 127)
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
|
|||
|
|
value >>= 7;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = (byte)value;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (value > 127)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
|
|||
|
|
value >>= 7;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static void WriteRawLittleEndian32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
|
|||
|
|
{
|
|||
|
|
const int length = sizeof(uint);
|
|||
|
|
if (state.position + length > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian32SlowPath(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(state.position), value);
|
|||
|
|
state.position += length;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
private static void WriteRawLittleEndian32SlowPath(ref Span<byte> buffer, ref WriterInternalState state, uint value)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)value);
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static void WriteRawLittleEndian64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
|
|||
|
|
{
|
|||
|
|
const int length = sizeof(ulong);
|
|||
|
|
if (state.position + length > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawLittleEndian64SlowPath(ref buffer, ref state, value);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(state.position), value);
|
|||
|
|
state.position += length;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
public static void WriteRawLittleEndian64SlowPath(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)value);
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 32));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 40));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 48));
|
|||
|
|
WriteRawByte(ref buffer, ref state, (byte)(value >> 56));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static void WriteRawByte(ref Span<byte> buffer, ref WriterInternalState state, byte value)
|
|||
|
|
{
|
|||
|
|
if (state.position == buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
buffer[state.position++] = value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes out an array of bytes.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value)
|
|||
|
|
{
|
|||
|
|
WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes out part of an array of bytes.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value, int offset, int length)
|
|||
|
|
{
|
|||
|
|
WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value, offset, length));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes out part of an array of bytes.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, ReadOnlySpan<byte> value)
|
|||
|
|
{
|
|||
|
|
if (buffer.Length - state.position >= value.Length)
|
|||
|
|
{
|
|||
|
|
// We have room in the current buffer.
|
|||
|
|
value.CopyTo(buffer.Slice(state.position, value.Length));
|
|||
|
|
state.position += value.Length;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// When writing to a CodedOutputStream backed by a Stream, we could avoid
|
|||
|
|
// copying the data twice (first copying to the current buffer and
|
|||
|
|
// and later writing from the current buffer to the underlying Stream)
|
|||
|
|
// in some circumstances by writing the data directly to the underlying Stream.
|
|||
|
|
// Current this is not being done to avoid specialcasing the code for
|
|||
|
|
// CodedOutputStream vs IBufferWriter<byte>.
|
|||
|
|
int bytesWritten = 0;
|
|||
|
|
while (buffer.Length - state.position < value.Length - bytesWritten)
|
|||
|
|
{
|
|||
|
|
int length = buffer.Length - state.position;
|
|||
|
|
value.Slice(bytesWritten, length).CopyTo(buffer.Slice(state.position, length));
|
|||
|
|
bytesWritten += length;
|
|||
|
|
state.position += length;
|
|||
|
|
WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// copy the remaining data
|
|||
|
|
int remainderLength = value.Length - bytesWritten;
|
|||
|
|
value.Slice(bytesWritten, remainderLength).CopyTo(buffer.Slice(state.position, remainderLength));
|
|||
|
|
state.position += remainderLength;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Raw tag writing
|
|||
|
|
/// <summary>
|
|||
|
|
/// Encodes and writes a tag.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, int fieldNumber, WireFormat.WireType type)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, WireFormat.MakeTag(fieldNumber, type));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes an already-encoded tag.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, uint tag)
|
|||
|
|
{
|
|||
|
|
WriteRawVarint32(ref buffer, ref state, tag);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes the given single-byte tag directly to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, b1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes the given two-byte tag directly to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
|
|||
|
|
{
|
|||
|
|
if (state.position + 2 > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawTagSlowPath(ref buffer, ref state, b1, b2);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = b1;
|
|||
|
|
buffer[state.position++] = b2;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, b1);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes the given three-byte tag directly to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
|
|||
|
|
{
|
|||
|
|
if (state.position + 3 > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = b1;
|
|||
|
|
buffer[state.position++] = b2;
|
|||
|
|
buffer[state.position++] = b3;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, b1);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b2);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b3);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes the given four-byte tag directly to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
|
|||
|
|
{
|
|||
|
|
if (state.position + 4 > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = b1;
|
|||
|
|
buffer[state.position++] = b2;
|
|||
|
|
buffer[state.position++] = b3;
|
|||
|
|
buffer[state.position++] = b4;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
|
|||
|
|
private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, b1);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b2);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b3);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Writes the given five-byte tag directly to the stream.
|
|||
|
|
/// </summary>
|
|||
|
|
public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
|
|||
|
|
{
|
|||
|
|
if (state.position + 5 > buffer.Length)
|
|||
|
|
{
|
|||
|
|
WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4, b5);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
buffer[state.position++] = b1;
|
|||
|
|
buffer[state.position++] = b2;
|
|||
|
|
buffer[state.position++] = b3;
|
|||
|
|
buffer[state.position++] = b4;
|
|||
|
|
buffer[state.position++] = b5;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|||
|
|
private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
|
|||
|
|
{
|
|||
|
|
WriteRawByte(ref buffer, ref state, b1);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b2);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b3);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b4);
|
|||
|
|
WriteRawByte(ref buffer, ref state, b5);
|
|||
|
|
}
|
|||
|
|
#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>
|
|||
|
|
public 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>
|
|||
|
|
public static ulong EncodeZigZag64(long n)
|
|||
|
|
{
|
|||
|
|
return (ulong)((n << 1) ^ (n >> 63));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|