private bool TryWriteValueUtf8(long value)
{
int idx = 0;
Span <byte> byteBuffer = _bufferWriter.Buffer;
if (_indent < 0)
{
if (byteBuffer.Length == 0)
{
return(false);
}
byteBuffer[idx++] = JsonConstants.ListSeperator;
}
if (!JsonWriterHelper.TryFormatInt64Default(value, byteBuffer.Slice(idx), out int bytesWritten))
{
return(false);
}
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
//if (!Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten)) return false;
idx += bytesWritten;
_bufferWriter.Advance(idx);
_indent |= 1 << 31;
return(true);
}
private void WriteNumberValueFormatLoop(long value, ref int idx)
{
int bytesWritten;
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
// Utf8Formatter.TryFormat(value, _buffer.Slice(idx), out bytesWritten);
while (!JsonWriterHelper.TryFormatInt64Default(value, _buffer.Slice(idx), out bytesWritten))
{
AdvanceAndGrow(idx, JsonConstants.MaximumInt64Length);
idx = 0;
}
idx += bytesWritten;
}
private bool TryWriteAttributeUtf8(ReadOnlySpan <byte> nameSpanByte, long value)
{
int idx = 0;
try
{
Span <byte> byteBuffer = _bufferWriter.Buffer;
if (_indent < 0)
{
byteBuffer[idx++] = JsonConstants.ListSeperator;
}
byteBuffer[idx++] = JsonConstants.Quote;
OperationStatus status = Encodings.Utf16.ToUtf8(nameSpanByte, byteBuffer.Slice(idx), out int consumed, out int written);
if (status == OperationStatus.DestinationTooSmall)
{
return(false);
}
if (status != OperationStatus.Done)
{
JsonThrowHelper.ThrowFormatException();
}
Debug.Assert(consumed == nameSpanByte.Length);
idx += written;
byteBuffer[idx++] = JsonConstants.Quote;
byteBuffer[idx++] = JsonConstants.KeyValueSeperator;
if (!JsonWriterHelper.TryFormatInt64Default(value, byteBuffer.Slice(idx), out int bytesWritten))
{
return(false);
}
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
//if (!Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten)) return false;
idx += bytesWritten;
}
catch (IndexOutOfRangeException)
{
return(false);
}
_bufferWriter.Advance(idx);
_indent |= 1 << 31;
return(true);
}
private void WriteArrayFast(ref ReadOnlySpan <byte> propertyName, ref ReadOnlySpan <int> values)
{
if (values.Length > 0 && values.Length < (int.MaxValue - 5 - propertyName.Length) / (JsonConstants.MaximumInt64Length + 1))
{
// Calculated based on the following: '"propertyName":[number0,number1,...,numberN]'
int bytesNeeded = propertyName.Length + 5 + (values.Length * (1 + JsonConstants.MaximumInt64Length) - 1);
if (_currentDepth >= 0)
{
bytesNeeded--;
}
Ensure(bytesNeeded);
WritePropertyName(ref propertyName, bytesNeeded, out int idx);
_buffer[idx++] = JsonConstants.OpenBracket;
bool result = JsonWriterHelper.TryFormatInt64Default(values[0], _buffer.Slice(idx), out int bytesWritten);
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
// bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
for (int i = 1; i < values.Length; i++)
{
_buffer[idx++] = JsonConstants.ListSeperator;
result = JsonWriterHelper.TryFormatInt64Default(values[i], _buffer.Slice(idx), out bytesWritten);
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
// bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
}
_buffer[idx++] = JsonConstants.CloseBracket;
_currentDepth |= 1 << 31;
Advance(idx);
}
else
{
WriteArrayFastIterate(ref propertyName, ref values);
}
}
private void WriteValueFast(long value)
{
// Calculated based on the following: ',number'
int bytesNeeded = 1 + JsonConstants.MaximumInt64Length;
Span <byte> byteBuffer = WriteValue(bytesNeeded, out int idx);
bool result = JsonWriterHelper.TryFormatInt64Default(value, byteBuffer.Slice(idx), out int bytesWritten);
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
// bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
Advance(idx);
}
private void WriteValueFormatted(long value)
{
int indent = Indentation;
// This is guaranteed not to overflow.
Debug.Assert(int.MaxValue - JsonConstants.MaximumInt64Length - 1 - JsonWriterHelper.NewLineUtf8.Length - indent >= 0);
// Calculated based on the following: ',\r\n number'
int bytesNeeded = 1 + JsonWriterHelper.NewLineUtf8.Length + indent + JsonConstants.MaximumInt64Length;
Span <byte> byteBuffer = WriteValueFormatted(bytesNeeded, indent, out int idx);
bool result = JsonWriterHelper.TryFormatInt64Default(value, byteBuffer.Slice(idx), out int bytesWritten);
// Using Utf8Formatter with default StandardFormat is roughly 30% slower (17 ns versus 12 ns)
// See: https://github.com/dotnet/corefx/issues/25425
// bool result = Utf8Formatter.TryFormat(value, byteBuffer.Slice(idx), out int bytesWritten);
Debug.Assert(result);
idx += bytesWritten;
Advance(idx);
}
