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 CheckNoSpaceLeft(ref WriterInternalState state) { if (GetSpaceLeft(ref state) != 0) { throw new InvalidOperationException("Did not write as much data as expected."); } }
/// <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; } }
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); }
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); }
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; }
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)); }
/// <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; } }
/// <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); } }
public static int GetSpaceLeft(ref WriterInternalState state) { if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream == null && state.writeBufferHelper.bufferWriter == null) { return(state.limit - state.position); } else { throw new InvalidOperationException( "SpaceLeft can only be called on CodedOutputStreams that are " + "writing to a flat array or when writing to a single span."); } }
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; } }
/// <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; } }
/// <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) { // 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(ref buffer, ref state, length); if (buffer.Length - state.position >= length) { if (length == value.Length) // Must be all ASCII... { for (int i = 0; i < length; i++) { buffer[state.position + i] = (byte)value[i]; } state.position += length; } else { #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); #else ReadOnlySpan <char> source = value.AsSpan(); int bytesUsed; unsafe { fixed(char *sourceChars = &MemoryMarshal.GetReference(source)) fixed(byte *destinationBytes = &MemoryMarshal.GetReference(buffer.Slice(state.position))) { bytesUsed = Utf8Encoding.GetBytes(sourceChars, source.Length, destinationBytes, buffer.Length); } } state.position += bytesUsed; #endif } } 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); } }
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]); }
public static void Flush(ref Span <byte> buffer, ref WriterInternalState state) { if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null) { // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical. state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position); state.position = 0; } else if (state.writeBufferHelper.bufferWriter != null) { // calling Advance invalidates the current buffer and we must not continue writing to it, // so we set the current buffer to point to an empty Span. If any subsequent writes happen, // the first subsequent write will trigger refresing of the buffer. state.writeBufferHelper.bufferWriter.Advance(state.position); state.position = 0; state.limit = 0; buffer = default; // invalidate the current buffer } }
/// <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); } }
public static void RefreshBuffer(ref Span <byte> buffer, ref WriterInternalState state) { if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null) { // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical. state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position); // reset position, limit stays the same because we are reusing the codedOutputStream's internal buffer. state.position = 0; } else if (state.writeBufferHelper.bufferWriter != null) { // commit the bytes and get a new buffer to write to. state.writeBufferHelper.bufferWriter.Advance(state.position); state.position = 0; buffer = state.writeBufferHelper.bufferWriter.GetSpan(); state.limit = buffer.Length; } else { // We're writing to a single buffer. throw new CodedOutputStream.OutOfSpaceException(); } }
/// <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 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 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 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 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> /// 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 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); }
/// <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 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> /// 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 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)); }