public void WriteValue(UInt64 value)
{
WriteStarted(InternalState.Value);
if (!Utf8Formatter.TryFormat(value, m_output.GetSpan(), out var bytesWritten) &&
!Utf8Formatter.TryFormat(value, m_output.GetSpan(Constants.Max64BitNumberSize), out bytesWritten))
{
ThrowFormatException(value);
}
m_output.Advance(bytesWritten);
}
public void Append(System.DateTimeOffset value, StandardFormat format)
{
if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var written, format))
{
Grow();
if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out written, format))
{
ThrowArgumentException(nameof(value));
}
}
index += written;
}
public static bool TryWrite(ref ResizableMemory <byte> writer, DateTime value, StandardFormat standardFormat)
{
// TODO: Will this break in other locales?
var data = writer.RequestSpan(31); // Fri, 31 Dec 9999 11:59:59 ACWST
if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat))
{
return(false);
}
writer.Advance(bytesWritten);
return(true);
}
public void Write(long value)
{
const int MaxInt64Length = 20;
this.EnsureRemainingBufferSpace(MaxInt64Length);
if (!Utf8Formatter.TryFormat(value, this.Cursor.Span, out int bytesWritten))
{
throw new InvalidOperationException($"Failed to {nameof(this.Write)}({typeof(long).FullName}{value})");
}
this.Position += bytesWritten;
}
public void Append(System.Decimal value)
{
if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var written))
{
Grow();
if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out written))
{
ThrowArgumentException(nameof(value));
}
}
index += written;
}
public void Write(Guid value)
{
const int GuidLength = 38;
this.EnsureRemainingBufferSpace(GuidLength);
if (!Utf8Formatter.TryFormat(value, this.Cursor, out int bytesWritten))
{
throw new InvalidOperationException($"Failed to {nameof(this.Write)}({typeof(double).FullName}{value})");
}
this.Position += bytesWritten;
}
public bool WriteStringDouble(double value)
{
Span <byte> span = this.writer.GetSpan(32);
if (Utf8Formatter.TryFormat(value, span, out var written))
{
this.WriteSpan(span.Slice(0, written));
return(true);
}
return(false);
}
private static void EscapeNextBytes(byte value, Span <byte> destination, ref int written)
{
destination[written++] = (byte)'\\';
switch (value)
{
case JsonConstants.Quote:
// Optimize for the common quote case.
destination[written++] = (byte)'u';
destination[written++] = (byte)'0';
destination[written++] = (byte)'0';
destination[written++] = (byte)'2';
destination[written++] = (byte)'2';
break;
case JsonConstants.LineFeed:
destination[written++] = (byte)'n';
break;
case JsonConstants.CarriageReturn:
destination[written++] = (byte)'r';
break;
case JsonConstants.Tab:
destination[written++] = (byte)'t';
break;
case JsonConstants.BackSlash:
destination[written++] = (byte)'\\';
break;
case JsonConstants.Slash:
destination[written++] = (byte)'/';
break;
case JsonConstants.BackSpace:
destination[written++] = (byte)'b';
break;
case JsonConstants.FormFeed:
destination[written++] = (byte)'f';
break;
default:
destination[written++] = (byte)'u';
bool result = Utf8Formatter.TryFormat(value, destination.Slice(written), out int bytesWritten, format: s_hexStandardFormat);
Debug.Assert(result);
Debug.Assert(bytesWritten == 4);
written += bytesWritten;
break;
}
}
private async Task WriteResultHeaderAsync(
Stream outputStream,
int contentLength,
CancellationToken cancellationToken)
{
byte[] buffer = ArrayPool <byte> .Shared.Rent(128);
try
{
Utf8Formatter.TryFormat(contentLength, buffer, out var w);
// Each part of the multipart response must start with --- and a CRLF
await outputStream.WriteAsync(Start, 0, Start.Length, cancellationToken)
.ConfigureAwait(false);
await outputStream.WriteAsync(CrLf, 0, CrLf.Length, cancellationToken)
.ConfigureAwait(false);
// Each part of the multipart response must contain a Content-Type header.
// Similar to the GraphQL specification this specification does not require
// a specific serialization format. For consistency and ease of notation,
// examples of the response are given in JSON throughout the spec.
await outputStream.WriteAsync(
ContentType, 0, ContentType.Length, cancellationToken)
.ConfigureAwait(false);
await outputStream.WriteAsync(CrLf, 0, CrLf.Length, cancellationToken)
.ConfigureAwait(false);
// Each part of the multipart response must contain a Content-Length header.
// This should be the number of bytes of the payload of the response.
// It does not include the size of the headers, boundaries,
// or CRLFs used to separate the content.
await outputStream.WriteAsync(
ContentLength, 0, ContentLength.Length, cancellationToken)
.ConfigureAwait(false);
await outputStream.WriteAsync(buffer, 0, w, cancellationToken)
.ConfigureAwait(false);
await outputStream.WriteAsync(CrLf, 0, CrLf.Length, cancellationToken)
.ConfigureAwait(false);
// After all headers, an additional CRLF is sent.
await outputStream.WriteAsync(CrLf, 0, CrLf.Length, cancellationToken)
.ConfigureAwait(false);
}
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
private void WriteStringIndented(ReadOnlySpan <byte> escapedPropertyName, DateTime value)
{
int indent = Indentation;
Debug.Assert(indent <= 2 * JsonConstants.MaxWriterDepth);
Debug.Assert(escapedPropertyName.Length < int.MaxValue - indent - JsonConstants.MaximumFormatDateTimeOffsetLength - 7 - s_newLineLength);
int minRequired = indent + escapedPropertyName.Length + JsonConstants.MaximumFormatDateTimeOffsetLength + 6; // 2 quotes for property name, 2 quotes for date, 1 colon, and 1 space
int maxRequired = minRequired + 1 + s_newLineLength; // Optionally, 1 list separator and 1-2 bytes for new line
if (_memory.Length - BytesPending < maxRequired)
{
Grow(maxRequired);
}
Span <byte> output = _memory.Span;
if (_currentDepth < 0)
{
output[BytesPending++] = JsonConstants.ListSeparator;
}
if (_tokenType != JsonTokenType.None)
{
WriteNewLine(output);
}
JsonWriterHelper.WriteIndentation(output.Slice(BytesPending), indent);
BytesPending += indent;
output[BytesPending++] = JsonConstants.Quote;
escapedPropertyName.CopyTo(output.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
output[BytesPending++] = JsonConstants.Quote;
output[BytesPending++] = JsonConstants.KeyValueSeperator;
output[BytesPending++] = JsonConstants.Space;
output[BytesPending++] = JsonConstants.Quote;
Span <byte> tempSpan = stackalloc byte[JsonConstants.MaximumFormatDateTimeOffsetLength];
bool result = Utf8Formatter.TryFormat(value, tempSpan, out int bytesWritten, s_dateTimeStandardFormat);
Debug.Assert(result);
JsonWriterHelper.TrimDateTimeOffset(tempSpan.Slice(0, bytesWritten), out bytesWritten);
tempSpan.Slice(0, bytesWritten).CopyTo(output.Slice(BytesPending));
BytesPending += bytesWritten;
output[BytesPending++] = JsonConstants.Quote;
}
private void WriteValueFast(decimal value)
{
// Calculated based on the following: ',number'
int bytesNeeded = 1 + JsonConstants.MaximumDecimalLength;
Span <byte> byteBuffer = WriteValue(bytesNeeded, out int idx);
bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
Advance(idx);
}
public bool TryWriteLine(DateTime date, StandardFormat format)
{
if (!Utf8Formatter.TryFormat(date, Free, out int written, format))
{
return(false);
}
if (!NewLine.TryCopyTo(Free.Slice(written)))
{
return(false);
}
_written += written + NewLine.Length;
return(true);
}
public IntValueNode(Location?location, uint value)
{
Location = location;
_uIntValue = value;
Span <byte> buffer = stackalloc byte[32];
Utf8Formatter.TryFormat(value, buffer, out int written);
var memory = new Memory <byte>(new byte[written]);
buffer.Slice(0, written).CopyTo(memory.Span);
_memory = memory;
}
private void WriteStringIndented(ReadOnlySpan <byte> escapedPropertyName, Guid value)
{
int indent = Indentation;
Debug.Assert(indent <= 2 * _options.MaxDepth);
Debug.Assert(escapedPropertyName.Length < int.MaxValue - indent - JsonConstants.MaximumFormatGuidLength - 7 - s_newLineLength);
int minRequired = indent + escapedPropertyName.Length + JsonConstants.MaximumFormatGuidLength + 6; // 2 quotes for property name, 2 quotes for date, 1 colon, and 1 space
int maxRequired = minRequired + 1 + s_newLineLength; // Optionally, 1 list separator and 1-2 bytes for new line
if (_memory.Length - BytesPending < maxRequired)
{
Grow(maxRequired);
}
Span <byte> output = _memory.Span;
if (_currentDepth < 0)
{
output[BytesPending++] = JsonConstants.ListSeparator;
}
Debug.Assert(_options.SkipValidation || _tokenType != JsonTokenType.PropertyName);
if (_tokenType != JsonTokenType.None)
{
WriteNewLine(output);
}
JsonWriterHelper.WriteIndentation(output.Slice(BytesPending), indent);
BytesPending += indent;
output[BytesPending++] = JsonConstants.Quote;
escapedPropertyName.CopyTo(output.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
output[BytesPending++] = JsonConstants.Quote;
output[BytesPending++] = JsonConstants.KeyValueSeparator;
output[BytesPending++] = JsonConstants.Space;
output[BytesPending++] = JsonConstants.Quote;
bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);
Debug.Assert(result);
BytesPending += bytesWritten;
output[BytesPending++] = JsonConstants.Quote;
}
private void WriteStringIndented(ReadOnlySpan <char> escapedPropertyName, Guid value)
{
int indent = Indentation;
Debug.Assert(indent <= 2 * _options.MaxDepth);
Debug.Assert(escapedPropertyName.Length < (int.MaxValue / JsonConstants.MaxExpansionFactorWhileTranscoding) - indent - JsonConstants.MaximumFormatGuidLength - 7 - s_newLineLength);
// All ASCII, 2 quotes for property name, 2 quotes for date, 1 colon, and 1 space => escapedPropertyName.Length + JsonConstants.MaximumFormatGuidLength + 6
// Optionally, 1 list separator, 1-2 bytes for new line, and up to 3x growth when transcoding
int maxRequired = indent + (escapedPropertyName.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) + JsonConstants.MaximumFormatGuidLength + 7 + s_newLineLength;
if (_memory.Length - BytesPending < maxRequired)
{
Grow(maxRequired);
}
Span <byte> output = _memory.Span;
if (_currentDepth < 0)
{
output[BytesPending++] = JsonConstants.ListSeparator;
}
Debug.Assert(_options.SkipValidation || _tokenType != JsonTokenType.PropertyName);
if (_tokenType != JsonTokenType.None)
{
WriteNewLine(output);
}
JsonWriterHelper.WriteIndentation(output.Slice(BytesPending), indent);
BytesPending += indent;
output[BytesPending++] = JsonConstants.Quote;
TranscodeAndWrite(escapedPropertyName, output);
output[BytesPending++] = JsonConstants.Quote;
output[BytesPending++] = JsonConstants.KeyValueSeparator;
output[BytesPending++] = JsonConstants.Space;
output[BytesPending++] = JsonConstants.Quote;
bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);
Debug.Assert(result);
BytesPending += bytesWritten;
output[BytesPending++] = JsonConstants.Quote;
}
public uint Get(Composition <DateTimeOffset> parameter)
{
Span <byte> span = stackalloc byte[33];
var format = Utf8Formatter.TryFormat(parameter.Instance, span, out var count, _format);
if (format)
{
var result = _trimmer.Get(span.Slice(0, count));
span.Slice(0, (int)result).CopyTo(parameter.View);
return(result);
}
throw new InvalidOperationException($"Could not format '{parameter.Instance}' into its UTF-8 equivalent.");
}
public void WriteValue(Guid value)
{
WriteStarted(InternalState.Value);
WriteUTFByte(Constants.Quote);
if (!Utf8Formatter.TryFormat(value, m_output.GetSpan(Constants.MaxGuidSize), out var bytesWritten))
{
ThrowFormatException(value);
}
m_output.Advance(bytesWritten);
WriteUTFByte(Constants.Quote);
}
internal static GrainType CreateGrainServiceGrainType(int typeCode, string grainSystemId)
{
var extraLen = grainSystemId is null ? 0 : Encoding.UTF8.GetByteCount(grainSystemId);
var buf = new byte[GrainTypePrefix.GrainServicePrefix.Length + 8 + extraLen];
GrainTypePrefix.GrainServicePrefixBytes.Span.CopyTo(buf);
Utf8Formatter.TryFormat(typeCode, buf.AsSpan(GrainTypePrefix.GrainServicePrefix.Length), out var len, new StandardFormat('X', 8));
Debug.Assert(len == 8);
if (grainSystemId != null)
{
Encoding.UTF8.GetBytes(grainSystemId, 0, grainSystemId.Length, buf, buf.Length - extraLen);
}
return(new GrainType(buf));
}
private static void SetDateValues(DateTimeOffset value)
{
lock (s_headerBytesScratch)
{
if (!Utf8Formatter.TryFormat(value, s_headerBytesScratch.AsSpan(prefixLength), out var written, 'R'))
{
throw new Exception("date time format failed");
}
Debug.Assert(written == dateTimeRLength);
var temp = s_headerBytesMaster;
s_headerBytesMaster = s_headerBytesScratch;
s_headerBytesScratch = temp;
}
}
public async Task <ExecutionOutputResult> ExecuteInContainerAsync(
ActiveContainer container,
byte[] assemblyBytes,
byte[] outputBufferBytes,
bool includePerformance,
CancellationToken cancellationToken
)
{
var outputStartMarker = Guid.NewGuid();
var outputEndMarker = Guid.NewGuid();
await _stdinWriter.WriteCommandAsync(container.Stream, new ExecuteCommand(
assemblyBytes,
outputStartMarker,
outputEndMarker,
includePerformance
), cancellationToken);
const int OutputMarkerLength = 36; // length of guid
byte[]? outputStartMarkerBytes = null;
byte[]? outputEndMarkerBytes = null;
try {
outputStartMarkerBytes = ArrayPool <byte> .Shared.Rent(OutputMarkerLength);
outputEndMarkerBytes = ArrayPool <byte> .Shared.Rent(OutputMarkerLength);
Utf8Formatter.TryFormat(outputStartMarker, outputStartMarkerBytes, out _);
Utf8Formatter.TryFormat(outputEndMarker, outputEndMarkerBytes, out _);
using var executionCancellation = CancellationFactory.ContainerExecution(cancellationToken);
return(await _stdoutReader.ReadOutputAsync(
container.Stream,
outputBufferBytes,
outputStartMarkerBytes.AsMemory(0, OutputMarkerLength),
outputEndMarkerBytes.AsMemory(0, OutputMarkerLength),
executionCancellation.Token
));
}
finally {
if (outputStartMarkerBytes != null)
{
ArrayPool <byte> .Shared.Return(outputStartMarkerBytes);
}
if (outputEndMarkerBytes != null)
{
ArrayPool <byte> .Shared.Return(outputEndMarkerBytes);
}
}
}
private static bool WriteUnsignedInteger(ulong value, Span <byte> span, out int written)
{
if (Utf8Formatter.TryFormat(value, span, out int formatted))
{
if (span.Length > formatted)
{
span[formatted] = IntegerSuffix;
written = formatted + 1;
return(true);
}
}
written = 0;
return(false);
}
public static void FillIntegerUtf8Array(byte[] array, int minValue, int maxValue, int seed = 42)
{
Random r = new Random(seed);
Span <byte> span = new Span <byte>(array);
// Generate ints across the entire range
int next = r.Next(minValue + 1, maxValue) + r.Next(-1, 2);
while (Utf8Formatter.TryFormat(next, span, out int written) && span.Length > written)
{
next = r.Next(minValue + 1, maxValue) + r.Next(-1, 2);
span = span.Slice(written + 1);
}
}
public void Write_Type_Name(byte type, int intName)
{
var buffer = ArrayPool <byte> .Shared.Rent(10);
try
{
_ = Utf8Formatter.TryFormat(intName, buffer, out int written);
WriteByte(type);
WriteCString(buffer.AsSpan(0, written));
}
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
public static bool TryFormat(sbyte value, Span <byte> buffer, out int bytesWritten, StandardFormat format = default, SymbolTable symbolTable = null)
{
if (symbolTable == null || symbolTable == SymbolTable.InvariantUtf8)
{
return(Utf8Formatter.TryFormat(value, buffer, out bytesWritten, format));
}
else if (symbolTable == SymbolTable.InvariantUtf16)
{
return(Utf16Formatter.TryFormat(value, buffer, out bytesWritten, format));
}
else
{
return(TryFormatInt64(value, 0xff, buffer, out bytesWritten, format, symbolTable));
}
}
public static bool TryFormat(Guid value, Span <byte> buffer, out int bytesWritten, StandardFormat format = default, SymbolTable symbolTable = null)
{
if (symbolTable == null || symbolTable == SymbolTable.InvariantUtf8)
{
return(Utf8Formatter.TryFormat(value, buffer, out bytesWritten, format));
}
else if (symbolTable == SymbolTable.InvariantUtf16)
{
return(Utf16Formatter.TryFormat(value, buffer, out bytesWritten, format));
}
else
{
throw new NotSupportedException();
}
}
public static void WriteDateTimeOffset(Utf8JsonWriter writer, DateTimeOffset value)
{
long unixTime = Convert.ToInt64((value - s_Epoch).TotalMilliseconds);
TimeSpan utcOffset = value.Offset;
int stackSize = 64;
while (true)
{
Span <byte> span = stackSize <= 1024 ? stackalloc byte[stackSize] : new byte[stackSize];
if (!Utf8Formatter.TryFormat(unixTime, span.Slice(7), out int bytesWritten, new StandardFormat('D')) ||
stackSize < 15 + bytesWritten)
{
stackSize *= 2;
continue;
}
JsonMicrosoftDateTimeConverter.Start.CopyTo(span);
span[7 + bytesWritten] = utcOffset >= TimeSpan.Zero ? 0x2B : 0x2D;
int hours = Math.Abs(utcOffset.Hours);
if (hours < 10)
{
span[7 + bytesWritten + 1] = 0x30;
span[7 + bytesWritten + 2] = (byte)(0x30 + hours);
}
else
{
Utf8Formatter.TryFormat(hours, span.Slice(7 + bytesWritten + 1), out _, new StandardFormat('D'));
}
int minutes = Math.Abs(utcOffset.Minutes);
if (minutes < 10)
{
span[7 + bytesWritten + 3] = 0x30;
span[7 + bytesWritten + 4] = (byte)(0x30 + minutes);
}
else
{
Utf8Formatter.TryFormat(minutes, span.Slice(7 + bytesWritten + 3), out _, new StandardFormat('D'));
}
JsonMicrosoftDateTimeConverter.End.CopyTo(span.Slice(7 + bytesWritten + 5));
writer.WriteStringValue(
JsonMicrosoftDateTimeConverter.CreateJsonEncodedTextFunc(span.Slice(0, 15 + bytesWritten).ToArray()));
break;
}
}
public static bool TryWriteGuid(Span <byte> name, Guid value, Span <byte> target, out int bytesWritten)
{
if (!TryWriteName(name, ref target, out bytesWritten))
{
return(false);
}
if (Utf8Formatter.TryFormat(value, target, out bytesWritten, 'N'))
{
bytesWritten += name.Length + 2;
return(true);
}
bytesWritten = 0;
return(false);
}
private void WriteValueFast(Guid value)
{
// Calculated based on the following: ',"value"'
int bytesNeeded = 3 + JsonConstants.MaximumGuidLength;
Span <byte> byteBuffer = WriteValue(bytesNeeded, out int idx);
byteBuffer[idx++] = JsonConstants.Quote;
bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
byteBuffer[idx++] = JsonConstants.Quote;
Advance(idx);
}
public static Writer Make(int index, NameWriter name)
{
return((reader, buffer) =>
{
if (reader.IsDBNull(index))
{
return buffer;
}
Comma.Write(ref buffer);
name.Write(ref buffer);
Utf8Formatter.TryFormat(reader.GetByte(index), buffer, out var n);
return buffer.Slice(n);
});
}
internal static Result GetSubFilePath(Span <byte> subFilePathBuffer, ReadOnlySpan <byte> basePath, int index)
{
int basePathLen = StringUtils.Copy(subFilePathBuffer, basePath);
// Make sure we have at least 3 bytes for the sub file name
if (basePathLen + 3 > PathTools.MaxPathLength)
{
return(ResultFs.TooLongPath.Log());
}
subFilePathBuffer[basePathLen] = StringTraits.DirectorySeparator;
Utf8Formatter.TryFormat(index, subFilePathBuffer.Slice(basePathLen + 1), out _, new StandardFormat('D', 2));
return(Result.Success);
}
