Utf8JsonWriter
Provides a high-performance API for forward-only, non-cached writing of UTF-8 encoded JSON text.
using System.Buffers;
using System.Buffers.Text;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
namespace System.Text.Json
{
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public sealed class Utf8JsonWriter : IDisposable, IAsyncDisposable
{
internal enum EnclosingContainerType : byte
{
None = 0,
Object = 5,
Array = 16,
Utf8StringSequence = 32,
Utf16StringSequence = 48,
Base64StringSequence = 64
}
private const int DefaultGrowthSize = 4096;
private const int InitialGrowthSize = 256;
private IBufferWriter<byte> _output;
private Stream _stream;
private System.Buffers.ArrayBufferWriter<byte> _arrayBufferWriter;
private Memory<byte> _memory;
private EnclosingContainerType _enclosingContainer;
private bool _commentAfterNoneOrPropertyName;
private JsonTokenType _tokenType;
private BitStack _bitStack;
private byte[] _partialStringData;
private byte _partialStringDataLength;
private int _currentDepth;
private JsonWriterOptions _options;
private byte _indentByte;
private int _indentLength;
private int _newLineLength;
private static readonly char[] s_singleLineCommentDelimiter = new char[2] {
'*',
'/'
};
private Span<byte> PartialStringDataRaw => _partialStringData ?? (_partialStringData = new byte[3]);
public int BytesPending { get; set; }
public long BytesCommitted { get; set; }
public JsonWriterOptions Options => _options;
private int Indentation => CurrentDepth * _indentLength;
internal JsonTokenType TokenType => _tokenType;
public int CurrentDepth => _currentDepth & 2147483647;
private ReadOnlySpan<byte> PartialUtf8StringData {
get {
ReadOnlySpan<byte> readOnlySpan = PartialStringDataRaw;
byte partialStringDataLength = _partialStringDataLength;
return readOnlySpan.Slice(0, partialStringDataLength);
}
set {
Span<byte> partialStringDataRaw = PartialStringDataRaw;
value.CopyTo(partialStringDataRaw);
_partialStringDataLength = (byte)value.Length;
}
}
private ReadOnlySpan<char> PartialUtf16StringData {
get {
ReadOnlySpan<byte> readOnlySpan = PartialStringDataRaw;
byte partialStringDataLength = _partialStringDataLength;
return MemoryMarshal.Cast<byte, char>(readOnlySpan.Slice(0, partialStringDataLength));
}
set {
Span<byte> partialStringDataRaw = PartialStringDataRaw;
value.CopyTo(MemoryMarshal.Cast<byte, char>(partialStringDataRaw));
_partialStringDataLength = (byte)(2 * value.Length);
}
}
private ReadOnlySpan<byte> PartialBase64StringData {
get {
ReadOnlySpan<byte> readOnlySpan = PartialStringDataRaw;
byte partialStringDataLength = _partialStringDataLength;
return readOnlySpan.Slice(0, partialStringDataLength);
}
set {
Span<byte> partialStringDataRaw = PartialStringDataRaw;
value.CopyTo(partialStringDataRaw);
_partialStringDataLength = (byte)value.Length;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private string DebuggerDisplay {
get {
return $"""{BytesCommitted}""{BytesPending}""{CurrentDepth}";
}
}
private bool IsWritingPartialString => (int)_enclosingContainer >= 32;
private unsafe static ReadOnlySpan<byte> SingleLineCommentDelimiterUtf8 => new ReadOnlySpan<byte>(&global::<PrivateImplementationDetails>.BCCD0BA7F848775347BA9B64603DDEAC80563D9BFC8FB67AF20A7FB468DF6FD4, 2);
private bool CanWriteValue => (_enclosingContainer == EnclosingContainerType.Array) | ((uint)_enclosingContainer == (uint)_tokenType);
private bool HasPartialStringData => _partialStringDataLength != 0;
public void WriteStringValueSegment(ReadOnlySpan<char> value, bool isFinalSegment)
{
JsonWriterHelper.ValidateValue(value);
if (!_options.SkipValidation)
ValidateWritingSegment(EnclosingContainerType.Utf16StringSequence);
if (_enclosingContainer != EnclosingContainerType.Utf16StringSequence) {
WriteStringSegmentPrologue();
_enclosingContainer = EnclosingContainerType.Utf16StringSequence;
}
if (HasPartialStringData)
WriteStringSegmentWithLeftover(value, isFinalSegment);
else
WriteStringSegmentEscape(value, isFinalSegment);
if (isFinalSegment) {
WriteStringSegmentEpilogue();
SetFlagToAddListSeparatorBeforeNextItem();
EnclosingContainerType enclosingContainerType = _bitStack.Peek() ? EnclosingContainerType.Object : EnclosingContainerType.Array;
_enclosingContainer = ((_bitStack.CurrentDepth != 0) ? enclosingContainerType : EnclosingContainerType.None);
_tokenType = JsonTokenType.String;
}
}
private unsafe void WriteStringSegmentWithLeftover([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> value, bool isFinalSegment)
{
ReadOnlySpan<char> readOnlySpan = PartialUtf16StringData;
Span<char> span = new Span<char>(stackalloc byte[4], 2);
span = span.Slice(0, ConcatInto(readOnlySpan, value, span));
System.Text.Rune result;
int charsConsumed;
switch (System.Text.Rune.DecodeFromUtf16(span, out result, out charsConsumed)) {
case OperationStatus.NeedMoreData:
value = span.Slice(0, charsConsumed);
readOnlySpan = default(ReadOnlySpan<char>);
break;
case OperationStatus.Done:
value = value.Slice(charsConsumed - readOnlySpan.Length);
readOnlySpan = span.Slice(0, charsConsumed);
break;
case OperationStatus.InvalidData:
value = value.Slice(charsConsumed - readOnlySpan.Length);
readOnlySpan = span.Slice(0, charsConsumed);
break;
}
WriteStringSegmentEscape(readOnlySpan, true);
ClearPartialStringData();
WriteStringSegmentEscape(value, isFinalSegment);
}
private void WriteStringSegmentEscape(ReadOnlySpan<char> value, bool isFinalSegment)
{
if (!value.IsEmpty) {
int num = JsonWriterHelper.NeedsEscaping(value, _options.Encoder);
if (num != -1)
WriteStringSegmentEscapeValue(value, num, isFinalSegment);
else
WriteStringSegmentData(value);
}
}
private unsafe void WriteStringSegmentEscapeValue(ReadOnlySpan<char> value, int firstEscapeIndexVal, bool isFinalSegment)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndexVal);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(value, destination, firstEscapeIndexVal, _options.Encoder, out int consumed, out int written, isFinalSegment);
WriteStringSegmentData(destination.Slice(0, written));
if (value.Length != consumed)
PartialUtf16StringData = value.Slice(consumed);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private void WriteStringSegmentData(ReadOnlySpan<char> escapedValue)
{
int num = escapedValue.Length * 3;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
TranscodeAndWrite(escapedValue, span);
}
public void WriteStringValueSegment(ReadOnlySpan<byte> value, bool isFinalSegment)
{
JsonWriterHelper.ValidateValue(value);
if (!_options.SkipValidation)
ValidateWritingSegment(EnclosingContainerType.Utf8StringSequence);
if (_enclosingContainer != EnclosingContainerType.Utf8StringSequence) {
WriteStringSegmentPrologue();
_enclosingContainer = EnclosingContainerType.Utf8StringSequence;
}
if (HasPartialStringData)
WriteStringSegmentWithLeftover(value, isFinalSegment);
else
WriteStringSegmentEscape(value, isFinalSegment);
if (isFinalSegment) {
WriteStringSegmentEpilogue();
SetFlagToAddListSeparatorBeforeNextItem();
EnclosingContainerType enclosingContainerType = _bitStack.Peek() ? EnclosingContainerType.Object : EnclosingContainerType.Array;
_enclosingContainer = ((_bitStack.CurrentDepth != 0) ? enclosingContainerType : EnclosingContainerType.None);
_tokenType = JsonTokenType.String;
}
}
private unsafe void WriteStringSegmentWithLeftover([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8Value, bool isFinalSegment)
{
ReadOnlySpan<byte> readOnlySpan = PartialUtf8StringData;
Span<byte> span = new Span<byte>(stackalloc byte[4], 4);
span = span.Slice(0, ConcatInto(readOnlySpan, utf8Value, span));
System.Text.Rune result;
int bytesConsumed;
switch (System.Text.Rune.DecodeFromUtf8(span, out result, out bytesConsumed)) {
case OperationStatus.NeedMoreData:
utf8Value = span.Slice(0, bytesConsumed);
readOnlySpan = default(ReadOnlySpan<byte>);
break;
case OperationStatus.Done:
utf8Value = utf8Value.Slice(bytesConsumed - readOnlySpan.Length);
readOnlySpan = span.Slice(0, bytesConsumed);
break;
case OperationStatus.InvalidData:
utf8Value = utf8Value.Slice(bytesConsumed - readOnlySpan.Length);
readOnlySpan = span.Slice(0, bytesConsumed);
break;
}
WriteStringSegmentEscape(readOnlySpan, true);
ClearPartialStringData();
WriteStringSegmentEscape(utf8Value, isFinalSegment);
}
private void WriteStringSegmentEscape(ReadOnlySpan<byte> utf8Value, bool isFinalSegment)
{
if (!utf8Value.IsEmpty) {
int num = JsonWriterHelper.NeedsEscaping(utf8Value, _options.Encoder);
if (num != -1)
WriteStringSegmentEscapeValue(utf8Value, num, isFinalSegment);
else
WriteStringSegmentData(utf8Value);
}
}
private unsafe void WriteStringSegmentEscapeValue(ReadOnlySpan<byte> utf8Value, int firstEscapeIndexVal, bool isFinalSegment)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8Value, destination, firstEscapeIndexVal, _options.Encoder, out int consumed, out int written, isFinalSegment);
WriteStringSegmentData(destination.Slice(0, written));
if (utf8Value.Length != consumed)
PartialUtf8StringData = utf8Value.Slice(consumed);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringSegmentData(ReadOnlySpan<byte> escapedValue)
{
int length = escapedValue.Length;
if (_memory.Length - BytesPending < length)
Grow(length);
escapedValue.CopyTo(_memory.Span.Slice(BytesPending));
BytesPending += escapedValue.Length;
}
public void WriteBase64StringSegment(ReadOnlySpan<byte> value, bool isFinalSegment)
{
if (value.Length > Base64.GetMaxDecodedFromUtf8Length(2147483647))
ThrowHelper.ThrowArgumentException_ValueTooLarge(value.Length);
if (!_options.SkipValidation)
ValidateWritingSegment(EnclosingContainerType.Base64StringSequence);
if (_enclosingContainer != EnclosingContainerType.Base64StringSequence) {
WriteStringSegmentPrologue();
_enclosingContainer = EnclosingContainerType.Base64StringSequence;
}
if (HasPartialStringData)
WriteBase64StringSegmentWithLeftover(value, isFinalSegment);
else
WriteBase64StringSegmentData(value, isFinalSegment);
if (isFinalSegment) {
WriteStringSegmentEpilogue();
SetFlagToAddListSeparatorBeforeNextItem();
EnclosingContainerType enclosingContainerType = _bitStack.Peek() ? EnclosingContainerType.Object : EnclosingContainerType.Array;
_enclosingContainer = ((_bitStack.CurrentDepth != 0) ? enclosingContainerType : EnclosingContainerType.None);
_tokenType = JsonTokenType.String;
}
}
private unsafe void WriteBase64StringSegmentWithLeftover([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> bytes, bool isFinalSegment)
{
ReadOnlySpan<byte> readOnlySpan = PartialBase64StringData;
Span<byte> span = new Span<byte>(stackalloc byte[3], 3);
span = span.Slice(0, ConcatInto(readOnlySpan, bytes, span));
if (span.Length == 3) {
bytes = bytes.Slice(3 - readOnlySpan.Length);
readOnlySpan = span.Slice(0, 3);
} else {
bytes = span;
readOnlySpan = default(ReadOnlySpan<byte>);
}
WriteBase64StringSegmentData(readOnlySpan, false);
ClearPartialStringData();
WriteBase64StringSegmentData(bytes, isFinalSegment);
}
private void WriteBase64StringSegmentData(ReadOnlySpan<byte> bytes, bool isFinalSegment)
{
int num;
if (!isFinalSegment && (num = bytes.Length % 3) != 0) {
PartialBase64StringData = bytes.Slice(bytes.Length - num);
bytes = bytes.Slice(0, bytes.Length - num);
}
if (bytes.Length != 0) {
int maxEncodedToUtf8Length = Base64.GetMaxEncodedToUtf8Length(bytes.Length);
if (_memory.Length - BytesPending < maxEncodedToUtf8Length)
Grow(maxEncodedToUtf8Length);
Span<byte> span = _memory.Span;
Base64EncodeAndWrite(bytes, span);
}
}
private void WriteStringSegmentPrologue()
{
if (_options.Indented)
WriteStringSegmentIndentedPrologue();
else
WriteStringSegmentMinimizedPrologue();
}
private void WriteStringSegmentIndentedPrologue()
{
int indentation = Indentation;
int num = 1 + indentation + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
}
private void WriteStringSegmentMinimizedPrologue()
{
int num = 2;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
}
private void WriteStringSegmentEpilogue()
{
if (_memory.Length == BytesPending)
Grow(1);
_memory.Span[BytesPending++] = 34;
}
private static int ConcatInto<T>(ReadOnlySpan<T> srcLeft, ReadOnlySpan<T> srcRight, Span<T> dest)
{
int num = 0;
int num2 = 0;
while (true) {
if (num2 >= srcLeft.Length) {
for (int i = 0; i < srcRight.Length; i++) {
if ((uint)num >= (uint)dest.Length)
break;
dest[num++] = srcRight[i];
}
break;
}
if ((uint)num >= (uint)dest.Length)
break;
dest[num++] = srcLeft[num2];
num2++;
}
return num;
}
private Utf8JsonWriter()
{
}
[System.Runtime.CompilerServices.NullableContext(1)]
public Utf8JsonWriter(IBufferWriter<byte> bufferWriter, JsonWriterOptions options = default(JsonWriterOptions))
{
System.ExceptionPolyfills.ThrowIfNull(bufferWriter, "bufferWriter");
_output = bufferWriter;
SetOptions(options);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public Utf8JsonWriter(Stream utf8Json, JsonWriterOptions options = default(JsonWriterOptions))
{
System.ExceptionPolyfills.ThrowIfNull(utf8Json, "utf8Json");
if (!utf8Json.CanWrite)
throw new ArgumentException(System.SR.StreamNotWritable);
_stream = utf8Json;
SetOptions(options);
_arrayBufferWriter = new System.Buffers.ArrayBufferWriter<byte>();
}
private void SetOptions(JsonWriterOptions options)
{
_options = options;
_indentByte = (byte)_options.IndentCharacter;
_indentLength = options.IndentSize;
_newLineLength = options.NewLine.Length;
if (_options.MaxDepth == 0)
_options.MaxDepth = 1000;
}
public void Reset()
{
CheckNotDisposed();
_arrayBufferWriter?.Clear();
ResetHelper();
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void Reset(Stream utf8Json)
{
CheckNotDisposed();
if (utf8Json == null)
throw new ArgumentNullException("utf8Json");
if (!utf8Json.CanWrite)
throw new ArgumentException(System.SR.StreamNotWritable);
_stream = utf8Json;
if (_arrayBufferWriter == null)
_arrayBufferWriter = new System.Buffers.ArrayBufferWriter<byte>();
else
_arrayBufferWriter.Clear();
_output = null;
ResetHelper();
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void Reset(IBufferWriter<byte> bufferWriter)
{
CheckNotDisposed();
if (bufferWriter == null)
throw new ArgumentNullException("bufferWriter");
_output = bufferWriter;
_stream = null;
_arrayBufferWriter = null;
ResetHelper();
}
internal void ResetAllStateForCacheReuse()
{
ResetHelper();
_stream = null;
_arrayBufferWriter = null;
_output = null;
}
internal void Reset(IBufferWriter<byte> bufferWriter, JsonWriterOptions options)
{
_output = bufferWriter;
SetOptions(options);
}
internal static Utf8JsonWriter CreateEmptyInstanceForCaching()
{
return new Utf8JsonWriter();
}
private void ResetHelper()
{
BytesPending = 0;
BytesCommitted = 0;
_memory = default(Memory<byte>);
_enclosingContainer = EnclosingContainerType.None;
_tokenType = JsonTokenType.None;
_commentAfterNoneOrPropertyName = false;
_currentDepth = 0;
_bitStack = default(BitStack);
_partialStringData = null;
_partialStringDataLength = 0;
}
private void CheckNotDisposed()
{
if (_stream == null && _output == null)
ThrowHelper.ThrowObjectDisposedException_Utf8JsonWriter();
}
public void Flush()
{
CheckNotDisposed();
_memory = default(Memory<byte>);
if (_stream != null) {
if (BytesPending != 0) {
_arrayBufferWriter.Advance(BytesPending);
BytesPending = 0;
_stream.Write(_arrayBufferWriter.WrittenMemory);
BytesCommitted += _arrayBufferWriter.WrittenCount;
_arrayBufferWriter.Clear();
}
_stream.Flush();
} else if (BytesPending != 0) {
_output.Advance(BytesPending);
BytesCommitted += BytesPending;
BytesPending = 0;
}
}
public void Dispose()
{
if (_stream != null || _output != null) {
Flush();
ResetHelper();
_stream = null;
_arrayBufferWriter = null;
_output = null;
}
}
[AsyncStateMachine(typeof(<DisposeAsync>d__76))]
public ValueTask DisposeAsync()
{
<DisposeAsync>d__76 stateMachine = default(<DisposeAsync>d__76);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[System.Runtime.CompilerServices.NullableContext(1)]
[AsyncStateMachine(typeof(<FlushAsync>d__77))]
public Task FlushAsync(CancellationToken cancellationToken = default(CancellationToken))
{
<FlushAsync>d__77 stateMachine = default(<FlushAsync>d__77);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public void WriteStartArray()
{
WriteStart(91);
_tokenType = JsonTokenType.StartArray;
}
public void WriteStartObject()
{
WriteStart(123);
_tokenType = JsonTokenType.StartObject;
}
private void WriteStart(byte token)
{
if (CurrentDepth >= _options.MaxDepth)
ThrowInvalidOperationException_DepthTooLarge();
if (_options.IndentedOrNotSkipValidation)
WriteStartSlow(token);
else
WriteStartMinimized(token);
_currentDepth &= 2147483647;
_currentDepth++;
}
private void WriteStartMinimized(byte token)
{
if (_memory.Length - BytesPending < 2)
Grow(2);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = token;
}
private void WriteStartSlow(byte token)
{
if (_options.Indented) {
if (!_options.SkipValidation) {
ValidateStart();
UpdateBitStackOnStart(token);
}
WriteStartIndented(token);
} else {
ValidateStart();
UpdateBitStackOnStart(token);
WriteStartMinimized(token);
}
}
private void ValidateStart()
{
if (!CanWriteValue)
OnValidateStartFailed();
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void OnValidateStartFailed()
{
if (IsWritingPartialString)
ThrowInvalidOperationException(ExceptionResource.CannotWriteWithinString);
if (_enclosingContainer == EnclosingContainerType.Object)
ThrowInvalidOperationException(ExceptionResource.CannotStartObjectArrayWithoutProperty);
else
ThrowInvalidOperationException(ExceptionResource.CannotStartObjectArrayAfterPrimitiveOrClose);
}
private void WriteStartIndented(byte token)
{
int indentation = Indentation;
int num = indentation + 1 + 3;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
JsonTokenType tokenType = _tokenType;
if ((tokenType != JsonTokenType.PropertyName && tokenType != 0) || _commentAfterNoneOrPropertyName) {
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = token;
}
public void WriteStartArray(JsonEncodedText propertyName)
{
WriteStartHelper(propertyName.EncodedUtf8Bytes, 91);
_tokenType = JsonTokenType.StartArray;
}
public void WriteStartObject(JsonEncodedText propertyName)
{
WriteStartHelper(propertyName.EncodedUtf8Bytes, 123);
_tokenType = JsonTokenType.StartObject;
}
private void WriteStartHelper(ReadOnlySpan<byte> utf8PropertyName, byte token)
{
ValidateDepth();
WriteStartByOptions(utf8PropertyName, token);
_currentDepth &= 2147483647;
_currentDepth++;
}
public void WriteStartArray(ReadOnlySpan<byte> utf8PropertyName)
{
ValidatePropertyNameAndDepth(utf8PropertyName);
WriteStartEscape(utf8PropertyName, 91);
_currentDepth &= 2147483647;
_currentDepth++;
_tokenType = JsonTokenType.StartArray;
}
public void WriteStartObject(ReadOnlySpan<byte> utf8PropertyName)
{
ValidatePropertyNameAndDepth(utf8PropertyName);
WriteStartEscape(utf8PropertyName, 123);
_currentDepth &= 2147483647;
_currentDepth++;
_tokenType = JsonTokenType.StartObject;
}
private void WriteStartEscape(ReadOnlySpan<byte> utf8PropertyName, byte token)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStartEscapeProperty(utf8PropertyName, token, num);
else
WriteStartByOptions(utf8PropertyName, token);
}
private void WriteStartByOptions(ReadOnlySpan<byte> utf8PropertyName, byte token)
{
ValidateWritingProperty(token);
if (_options.Indented)
WritePropertyNameIndented(utf8PropertyName, token);
else
WritePropertyNameMinimized(utf8PropertyName, token);
}
private unsafe void WriteStartEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, byte token, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStartByOptions(destination.Slice(0, written), token);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteStartArray(string propertyName)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteStartArray(propertyName.AsSpan());
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteStartObject(string propertyName)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteStartObject(propertyName.AsSpan());
}
public void WriteStartArray(ReadOnlySpan<char> propertyName)
{
ValidatePropertyNameAndDepth(propertyName);
WriteStartEscape(propertyName, 91);
_currentDepth &= 2147483647;
_currentDepth++;
_tokenType = JsonTokenType.StartArray;
}
public void WriteStartObject(ReadOnlySpan<char> propertyName)
{
ValidatePropertyNameAndDepth(propertyName);
WriteStartEscape(propertyName, 123);
_currentDepth &= 2147483647;
_currentDepth++;
_tokenType = JsonTokenType.StartObject;
}
private void WriteStartEscape(ReadOnlySpan<char> propertyName, byte token)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStartEscapeProperty(propertyName, token, num);
else
WriteStartByOptions(propertyName, token);
}
private void WriteStartByOptions(ReadOnlySpan<char> propertyName, byte token)
{
ValidateWritingProperty(token);
if (_options.Indented)
WritePropertyNameIndented(propertyName, token);
else
WritePropertyNameMinimized(propertyName, token);
}
private unsafe void WriteStartEscapeProperty(ReadOnlySpan<char> propertyName, byte token, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStartByOptions(destination.Slice(0, written), token);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
public void WriteEndArray()
{
WriteEnd(93);
_tokenType = JsonTokenType.EndArray;
}
public void WriteEndObject()
{
WriteEnd(125);
_tokenType = JsonTokenType.EndObject;
}
private void WriteEnd(byte token)
{
if (_options.IndentedOrNotSkipValidation)
WriteEndSlow(token);
else
WriteEndMinimized(token);
SetFlagToAddListSeparatorBeforeNextItem();
if (CurrentDepth != 0)
_currentDepth--;
}
private void WriteEndMinimized(byte token)
{
if (_memory.Length - BytesPending < 1)
Grow(1);
_memory.Span[BytesPending++] = token;
}
private void WriteEndSlow(byte token)
{
if (_options.Indented) {
if (!_options.SkipValidation)
ValidateEnd(token);
WriteEndIndented(token);
} else {
ValidateEnd(token);
WriteEndMinimized(token);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void ValidateEnd(byte token)
{
if (_tokenType == JsonTokenType.PropertyName)
ThrowInvalidOperationException_MismatchedObjectArray(token);
if (token == 93) {
if (_enclosingContainer != EnclosingContainerType.Array)
ThrowInvalidOperationException_MismatchedObjectArray(token);
} else if (_enclosingContainer != EnclosingContainerType.Object) {
ThrowInvalidOperationException_MismatchedObjectArray(token);
}
EnclosingContainerType enclosingContainerType = _bitStack.Pop() ? EnclosingContainerType.Object : EnclosingContainerType.Array;
_enclosingContainer = ((_bitStack.CurrentDepth != 0) ? enclosingContainerType : EnclosingContainerType.None);
}
private void WriteEndIndented(byte token)
{
if (_tokenType == JsonTokenType.StartObject || _tokenType == JsonTokenType.StartArray)
WriteEndMinimized(token);
else {
int num = Indentation;
if (num != 0)
num -= _indentLength;
int num2 = num + 3;
if (_memory.Length - BytesPending < num2)
Grow(num2);
Span<byte> span = _memory.Span;
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), num);
BytesPending += num;
span[BytesPending++] = token;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteNewLine(Span<byte> output)
{
if (_newLineLength == 2)
output[BytesPending++] = 13;
output[BytesPending++] = 10;
}
private void WriteIndentation(Span<byte> buffer, int indent)
{
JsonWriterHelper.WriteIndentation(buffer, indent, _indentByte);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void UpdateBitStackOnStart(byte token)
{
if (token == 91) {
_bitStack.PushFalse();
_enclosingContainer = EnclosingContainerType.Array;
} else {
_bitStack.PushTrue();
_enclosingContainer = EnclosingContainerType.Object;
}
}
private void Grow(int requiredSize)
{
if (_memory.Length == 0)
FirstCallToGetMemory(requiredSize);
else {
int num = Math.Max(4096, requiredSize);
if (_stream != null) {
int num2 = BytesPending + num;
JsonHelpers.ValidateInt32MaxArrayLength((uint)num2);
_memory = _arrayBufferWriter.GetMemory(num2);
} else {
_output.Advance(BytesPending);
BytesCommitted += BytesPending;
BytesPending = 0;
_memory = _output.GetMemory(num);
if (_memory.Length < num)
ThrowHelper.ThrowInvalidOperationException_NeedLargerSpan();
}
}
}
private void FirstCallToGetMemory(int requiredSize)
{
int num = Math.Max(256, requiredSize);
if (_stream != null)
_memory = _arrayBufferWriter.GetMemory(num);
else {
_memory = _output.GetMemory(num);
if (_memory.Length < num)
ThrowHelper.ThrowInvalidOperationException_NeedLargerSpan();
}
}
private void SetFlagToAddListSeparatorBeforeNextItem()
{
_currentDepth |= -2147483648;
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void ThrowInvalidOperationException(ExceptionResource resource)
{
ThrowHelper.ThrowInvalidOperationException(resource, 0, _options.MaxDepth, 0, _tokenType);
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void ThrowInvalidOperationException_MismatchedObjectArray(byte token)
{
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.MismatchedObjectArray, 0, _options.MaxDepth, token, _tokenType);
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void ThrowInvalidOperationException_DepthTooLarge()
{
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.DepthTooLarge, _currentDepth, _options.MaxDepth, 0, JsonTokenType.None);
}
public void WriteBase64String(JsonEncodedText propertyName, ReadOnlySpan<byte> bytes)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteBase64ByOptions(encodedUtf8Bytes, bytes);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteBase64String([System.Runtime.CompilerServices.Nullable(1)] string propertyName, ReadOnlySpan<byte> bytes)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteBase64String(propertyName.AsSpan(), bytes);
}
public void WriteBase64String(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> bytes)
{
JsonWriterHelper.ValidatePropertyNameLength(propertyName);
WriteBase64Escape(propertyName, bytes);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteBase64String(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> bytes)
{
JsonWriterHelper.ValidatePropertyNameLength(utf8PropertyName);
WriteBase64Escape(utf8PropertyName, bytes);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteBase64Escape(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> bytes)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteBase64EscapeProperty(propertyName, bytes, num);
else
WriteBase64ByOptions(propertyName, bytes);
}
private void WriteBase64Escape(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> bytes)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteBase64EscapeProperty(utf8PropertyName, bytes, num);
else
WriteBase64ByOptions(utf8PropertyName, bytes);
}
private unsafe void WriteBase64EscapeProperty(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> bytes, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteBase64ByOptions(destination.Slice(0, written), bytes);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteBase64EscapeProperty(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> bytes, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteBase64ByOptions(destination.Slice(0, written), bytes);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteBase64ByOptions(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> bytes)
{
ValidateWritingProperty();
if (_options.Indented)
WriteBase64Indented(propertyName, bytes);
else
WriteBase64Minimized(propertyName, bytes);
}
private void WriteBase64ByOptions(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> bytes)
{
ValidateWritingProperty();
if (_options.Indented)
WriteBase64Indented(utf8PropertyName, bytes);
else
WriteBase64Minimized(utf8PropertyName, bytes);
}
private void WriteBase64Minimized(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> bytes)
{
int maxEncodedToUtf8Length = Base64.GetMaxEncodedToUtf8Length(bytes.Length);
int num = escapedPropertyName.Length * 3 + maxEncodedToUtf8Length + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
private void WriteBase64Minimized(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> bytes)
{
int maxEncodedToUtf8Length = Base64.GetMaxEncodedToUtf8Length(bytes.Length);
int num = escapedPropertyName.Length + maxEncodedToUtf8Length + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
private void WriteBase64Indented(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> bytes)
{
int indentation = Indentation;
int maxEncodedToUtf8Length = Base64.GetMaxEncodedToUtf8Length(bytes.Length);
int num = indentation + escapedPropertyName.Length * 3 + maxEncodedToUtf8Length + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
private void WriteBase64Indented(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> bytes)
{
int indentation = Indentation;
int maxEncodedToUtf8Length = Base64.GetMaxEncodedToUtf8Length(bytes.Length);
int num = indentation + escapedPropertyName.Length + maxEncodedToUtf8Length + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
public void WriteString(JsonEncodedText propertyName, DateTime value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteStringByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteString(string propertyName, DateTime value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), value);
}
public void WriteString(ReadOnlySpan<char> propertyName, DateTime value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteStringEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, DateTime value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteStringEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringEscape(ReadOnlySpan<char> propertyName, DateTime value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(propertyName, value, num);
else
WriteStringByOptions(propertyName, value);
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8PropertyName, DateTime value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(utf8PropertyName, value, num);
else
WriteStringByOptions(utf8PropertyName, value);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<char> propertyName, DateTime value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, DateTime value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringByOptions(ReadOnlySpan<char> propertyName, DateTime value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(propertyName, value);
else
WriteStringMinimized(propertyName, value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8PropertyName, DateTime value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(utf8PropertyName, value);
else
WriteStringMinimized(utf8PropertyName, value);
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedPropertyName, DateTime value)
{
int num = escapedPropertyName.Length * 3 + 33 + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedPropertyName, DateTime value)
{
int num = escapedPropertyName.Length + 33 + 5 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedPropertyName, DateTime value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 33 + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedPropertyName, DateTime value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 33 + 6 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
internal unsafe void WritePropertyName(DateTime value)
{
Span<byte> buffer = new Span<byte>(stackalloc byte[33], 33);
JsonWriterHelper.WriteDateTimeTrimmed(buffer, value, out int bytesWritten);
WritePropertyNameUnescaped(buffer.Slice(0, bytesWritten));
}
public void WriteString(JsonEncodedText propertyName, DateTimeOffset value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteStringByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteString(string propertyName, DateTimeOffset value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), value);
}
public void WriteString(ReadOnlySpan<char> propertyName, DateTimeOffset value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteStringEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, DateTimeOffset value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteStringEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringEscape(ReadOnlySpan<char> propertyName, DateTimeOffset value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(propertyName, value, num);
else
WriteStringByOptions(propertyName, value);
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8PropertyName, DateTimeOffset value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(utf8PropertyName, value, num);
else
WriteStringByOptions(utf8PropertyName, value);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<char> propertyName, DateTimeOffset value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, DateTimeOffset value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringByOptions(ReadOnlySpan<char> propertyName, DateTimeOffset value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(propertyName, value);
else
WriteStringMinimized(propertyName, value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8PropertyName, DateTimeOffset value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(utf8PropertyName, value);
else
WriteStringMinimized(utf8PropertyName, value);
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedPropertyName, DateTimeOffset value)
{
int num = escapedPropertyName.Length * 3 + 33 + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedPropertyName, DateTimeOffset value)
{
int num = escapedPropertyName.Length + 33 + 5 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedPropertyName, DateTimeOffset value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 33 + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedPropertyName, DateTimeOffset value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 33 + 6 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
internal unsafe void WritePropertyName(DateTimeOffset value)
{
Span<byte> buffer = new Span<byte>(stackalloc byte[33], 33);
JsonWriterHelper.WriteDateTimeOffsetTrimmed(buffer, value, out int bytesWritten);
WritePropertyNameUnescaped(buffer.Slice(0, bytesWritten));
}
public void WriteNumber(JsonEncodedText propertyName, decimal value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteNumberByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNumber(string propertyName, decimal value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), value);
}
public void WriteNumber(ReadOnlySpan<char> propertyName, decimal value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteNumberEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, decimal value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteNumberEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, decimal value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, decimal value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, decimal value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, decimal value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, decimal value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(propertyName, value);
else
WriteNumberMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, decimal value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(utf8PropertyName, value);
else
WriteNumberMinimized(utf8PropertyName, value);
}
private void WriteNumberMinimized(ReadOnlySpan<char> escapedPropertyName, decimal value)
{
int num = escapedPropertyName.Length * 3 + 31 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberMinimized(ReadOnlySpan<byte> escapedPropertyName, decimal value)
{
int num = escapedPropertyName.Length + 31 + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<char> escapedPropertyName, decimal value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 31 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<byte> escapedPropertyName, decimal value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 31 + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal unsafe void WritePropertyName(decimal value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[31], 31);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteNumber(JsonEncodedText propertyName, double value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
JsonWriterHelper.ValidateDouble(value);
WriteNumberByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNumber(string propertyName, double value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), value);
}
public void WriteNumber(ReadOnlySpan<char> propertyName, double value)
{
JsonWriterHelper.ValidateProperty(propertyName);
JsonWriterHelper.ValidateDouble(value);
WriteNumberEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, double value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
JsonWriterHelper.ValidateDouble(value);
WriteNumberEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, double value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, double value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, double value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, double value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, double value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(propertyName, value);
else
WriteNumberMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, double value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(utf8PropertyName, value);
else
WriteNumberMinimized(utf8PropertyName, value);
}
private void WriteNumberMinimized(ReadOnlySpan<char> escapedPropertyName, double value)
{
int num = escapedPropertyName.Length * 3 + 128 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberMinimized(ReadOnlySpan<byte> escapedPropertyName, double value)
{
int num = escapedPropertyName.Length + 128 + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<char> escapedPropertyName, double value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 128 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<byte> escapedPropertyName, double value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 128 + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
internal unsafe void WritePropertyName(double value)
{
JsonWriterHelper.ValidateDouble(value);
Span<byte> destination = new Span<byte>(stackalloc byte[128], 128);
TryFormatDouble(value, destination, out int bytesWritten);
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteNumber(JsonEncodedText propertyName, float value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
JsonWriterHelper.ValidateSingle(value);
WriteNumberByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNumber(string propertyName, float value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), value);
}
public void WriteNumber(ReadOnlySpan<char> propertyName, float value)
{
JsonWriterHelper.ValidateProperty(propertyName);
JsonWriterHelper.ValidateSingle(value);
WriteNumberEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, float value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
JsonWriterHelper.ValidateSingle(value);
WriteNumberEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, float value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, float value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, float value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, float value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, float value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(propertyName, value);
else
WriteNumberMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, float value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(utf8PropertyName, value);
else
WriteNumberMinimized(utf8PropertyName, value);
}
private void WriteNumberMinimized(ReadOnlySpan<char> escapedPropertyName, float value)
{
int num = escapedPropertyName.Length * 3 + 128 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberMinimized(ReadOnlySpan<byte> escapedPropertyName, float value)
{
int num = escapedPropertyName.Length + 128 + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<char> escapedPropertyName, float value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 128 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<byte> escapedPropertyName, float value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 128 + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
internal unsafe void WritePropertyName(float value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[128], 128);
TryFormatSingle(value, destination, out int bytesWritten);
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
internal void WriteNumber(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateProperty(propertyName);
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
WriteNumberEscape(propertyName, utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
internal void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
WriteNumberEscape(utf8PropertyName, utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
internal void WriteNumber(JsonEncodedText propertyName, ReadOnlySpan<byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
WriteNumberByOptions(propertyName.EncodedUtf8Bytes, utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteLiteralIndented(propertyName, value);
else
WriteLiteralMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteLiteralIndented(utf8PropertyName, value);
else
WriteLiteralMinimized(utf8PropertyName, value);
}
public void WriteString(JsonEncodedText propertyName, Guid value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteStringByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteString(string propertyName, Guid value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), value);
}
public void WriteString(ReadOnlySpan<char> propertyName, Guid value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteStringEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, Guid value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteStringEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringEscape(ReadOnlySpan<char> propertyName, Guid value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(propertyName, value, num);
else
WriteStringByOptions(propertyName, value);
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8PropertyName, Guid value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(utf8PropertyName, value, num);
else
WriteStringByOptions(utf8PropertyName, value);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<char> propertyName, Guid value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, Guid value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringByOptions(ReadOnlySpan<char> propertyName, Guid value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(propertyName, value);
else
WriteStringMinimized(propertyName, value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8PropertyName, Guid value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(utf8PropertyName, value);
else
WriteStringMinimized(utf8PropertyName, value);
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedPropertyName, Guid value)
{
int num = escapedPropertyName.Length * 3 + 36 + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedPropertyName, Guid value)
{
int num = escapedPropertyName.Length + 36 + 5 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedPropertyName, Guid value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 36 + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedPropertyName, Guid value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 36 + 6 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
internal unsafe void WritePropertyName(Guid value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[36], 36);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ValidatePropertyNameAndDepth(ReadOnlySpan<char> propertyName)
{
if (propertyName.Length > 166666666 || CurrentDepth >= _options.MaxDepth)
ThrowHelper.ThrowInvalidOperationOrArgumentException(propertyName, _currentDepth, _options.MaxDepth);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ValidatePropertyNameAndDepth(ReadOnlySpan<byte> utf8PropertyName)
{
if (utf8PropertyName.Length > 166666666 || CurrentDepth >= _options.MaxDepth)
ThrowHelper.ThrowInvalidOperationOrArgumentException(utf8PropertyName, _currentDepth, _options.MaxDepth);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ValidateDepth()
{
if (CurrentDepth >= _options.MaxDepth)
ThrowHelper.ThrowInvalidOperationException(_currentDepth, _options.MaxDepth);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ValidateWritingProperty()
{
if (!_options.SkipValidation && (_enclosingContainer != EnclosingContainerType.Object || _tokenType == JsonTokenType.PropertyName))
OnValidateWritingPropertyFailed();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ValidateWritingProperty(byte token)
{
if (!_options.SkipValidation) {
if (_enclosingContainer != EnclosingContainerType.Object || _tokenType == JsonTokenType.PropertyName)
OnValidateWritingPropertyFailed();
UpdateBitStackOnStart(token);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void OnValidateWritingPropertyFailed()
{
if (IsWritingPartialString)
ThrowInvalidOperationException(ExceptionResource.CannotWriteWithinString);
ThrowInvalidOperationException(ExceptionResource.CannotWritePropertyWithinArray);
}
private void WritePropertyNameMinimized(ReadOnlySpan<byte> escapedPropertyName, byte token)
{
int num = escapedPropertyName.Length + 4 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = token;
}
private void WritePropertyNameIndented(ReadOnlySpan<byte> escapedPropertyName, byte token)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 5 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = token;
}
private void WritePropertyNameMinimized(ReadOnlySpan<char> escapedPropertyName, byte token)
{
int num = escapedPropertyName.Length * 3 + 5;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = token;
}
private void WritePropertyNameIndented(ReadOnlySpan<char> escapedPropertyName, byte token)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 6 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = token;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void TranscodeAndWrite(ReadOnlySpan<char> escapedPropertyName, Span<byte> output)
{
JsonWriterHelper.ToUtf8(escapedPropertyName, output.Slice(BytesPending), out int written);
BytesPending += written;
}
public void WriteNull(JsonEncodedText propertyName)
{
WriteLiteralHelper(propertyName.EncodedUtf8Bytes, JsonConstants.NullValue);
_tokenType = JsonTokenType.Null;
}
internal void WriteNullSection(ReadOnlySpan<byte> escapedPropertyNameSection)
{
if (_options.Indented) {
ReadOnlySpan<byte> utf8PropertyName = escapedPropertyNameSection.Slice(1, escapedPropertyNameSection.Length - 3);
WriteLiteralHelper(utf8PropertyName, JsonConstants.NullValue);
_tokenType = JsonTokenType.Null;
} else {
ReadOnlySpan<byte> nullValue = JsonConstants.NullValue;
WriteLiteralSection(escapedPropertyNameSection, nullValue);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Null;
}
}
private void WriteLiteralHelper(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value)
{
WriteLiteralByOptions(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNull(string propertyName)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNull(propertyName.AsSpan());
}
public void WriteNull(ReadOnlySpan<char> propertyName)
{
JsonWriterHelper.ValidateProperty(propertyName);
ReadOnlySpan<byte> nullValue = JsonConstants.NullValue;
WriteLiteralEscape(propertyName, nullValue);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Null;
}
public void WriteNull(ReadOnlySpan<byte> utf8PropertyName)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
ReadOnlySpan<byte> nullValue = JsonConstants.NullValue;
WriteLiteralEscape(utf8PropertyName, nullValue);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Null;
}
public void WriteBoolean(JsonEncodedText propertyName, bool value)
{
if (value) {
WriteLiteralHelper(propertyName.EncodedUtf8Bytes, JsonConstants.TrueValue);
_tokenType = JsonTokenType.True;
} else {
WriteLiteralHelper(propertyName.EncodedUtf8Bytes, JsonConstants.FalseValue);
_tokenType = JsonTokenType.False;
}
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteBoolean(string propertyName, bool value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteBoolean(propertyName.AsSpan(), value);
}
public void WriteBoolean(ReadOnlySpan<char> propertyName, bool value)
{
JsonWriterHelper.ValidateProperty(propertyName);
ReadOnlySpan<byte> value2 = value ? JsonConstants.TrueValue : JsonConstants.FalseValue;
WriteLiteralEscape(propertyName, value2);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = (value ? JsonTokenType.True : JsonTokenType.False);
}
public void WriteBoolean(ReadOnlySpan<byte> utf8PropertyName, bool value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
ReadOnlySpan<byte> value2 = value ? JsonConstants.TrueValue : JsonConstants.FalseValue;
WriteLiteralEscape(utf8PropertyName, value2);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = (value ? JsonTokenType.True : JsonTokenType.False);
}
private void WriteLiteralEscape(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteLiteralEscapeProperty(propertyName, value, num);
else
WriteLiteralByOptions(propertyName, value);
}
private void WriteLiteralEscape(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteLiteralEscapeProperty(utf8PropertyName, value, num);
else
WriteLiteralByOptions(utf8PropertyName, value);
}
private unsafe void WriteLiteralEscapeProperty(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteLiteralByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteLiteralEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteLiteralByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteLiteralByOptions(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteLiteralIndented(propertyName, value);
else
WriteLiteralMinimized(propertyName, value);
}
private void WriteLiteralByOptions(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteLiteralIndented(utf8PropertyName, value);
else
WriteLiteralMinimized(utf8PropertyName, value);
}
private void WriteLiteralMinimized(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> value)
{
int num = escapedPropertyName.Length * 3 + value.Length + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
value.CopyTo(span.Slice(BytesPending));
BytesPending += value.Length;
}
private void WriteLiteralMinimized(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> value)
{
int num = escapedPropertyName.Length + value.Length + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
value.CopyTo(span.Slice(BytesPending));
BytesPending += value.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteLiteralSection(ReadOnlySpan<byte> escapedPropertyNameSection, ReadOnlySpan<byte> value)
{
int num = escapedPropertyNameSection.Length + value.Length + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
escapedPropertyNameSection.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyNameSection.Length;
value.CopyTo(span.Slice(BytesPending));
BytesPending += value.Length;
}
private void WriteLiteralIndented(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + value.Length + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
value.CopyTo(span.Slice(BytesPending));
BytesPending += value.Length;
}
private void WriteLiteralIndented(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + value.Length + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
value.CopyTo(span.Slice(BytesPending));
BytesPending += value.Length;
}
internal unsafe void WritePropertyName(bool value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[5], 5);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteNumber(JsonEncodedText propertyName, long value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteNumberByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNumber(string propertyName, long value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), value);
}
public void WriteNumber(ReadOnlySpan<char> propertyName, long value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteNumberEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, long value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteNumberEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
public void WriteNumber(JsonEncodedText propertyName, int value)
{
WriteNumber(propertyName, (long)value);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteNumber(string propertyName, int value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), (long)value);
}
public void WriteNumber(ReadOnlySpan<char> propertyName, int value)
{
WriteNumber(propertyName, (long)value);
}
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, int value)
{
WriteNumber(utf8PropertyName, (long)value);
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, long value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, long value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, long value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, long value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, long value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(propertyName, value);
else
WriteNumberMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, long value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(utf8PropertyName, value);
else
WriteNumberMinimized(utf8PropertyName, value);
}
private void WriteNumberMinimized(ReadOnlySpan<char> escapedPropertyName, long value)
{
int num = escapedPropertyName.Length * 3 + 20 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberMinimized(ReadOnlySpan<byte> escapedPropertyName, long value)
{
int num = escapedPropertyName.Length + 20 + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<char> escapedPropertyName, long value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 20 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<byte> escapedPropertyName, long value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 20 + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal void WritePropertyName(int value)
{
WritePropertyName((long)value);
}
internal unsafe void WritePropertyName(long value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[20], 20);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
public void WritePropertyName(JsonEncodedText propertyName)
{
WritePropertyNameHelper(propertyName.EncodedUtf8Bytes);
}
internal void WritePropertyNameSection(ReadOnlySpan<byte> escapedPropertyNameSection)
{
if (_options.Indented) {
ReadOnlySpan<byte> utf8PropertyName = escapedPropertyNameSection.Slice(1, escapedPropertyNameSection.Length - 3);
WritePropertyNameHelper(utf8PropertyName);
} else {
WriteStringPropertyNameSection(escapedPropertyNameSection);
_currentDepth &= 2147483647;
_tokenType = JsonTokenType.PropertyName;
_commentAfterNoneOrPropertyName = false;
}
}
private void WritePropertyNameHelper(ReadOnlySpan<byte> utf8PropertyName)
{
WriteStringByOptionsPropertyName(utf8PropertyName);
_currentDepth &= 2147483647;
_tokenType = JsonTokenType.PropertyName;
_commentAfterNoneOrPropertyName = false;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WritePropertyName(string propertyName)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WritePropertyName(propertyName.AsSpan());
}
public void WritePropertyName(ReadOnlySpan<char> propertyName)
{
JsonWriterHelper.ValidateProperty(propertyName);
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(propertyName, num);
else
WriteStringByOptionsPropertyName(propertyName);
_currentDepth &= 2147483647;
_tokenType = JsonTokenType.PropertyName;
_commentAfterNoneOrPropertyName = false;
}
private unsafe void WriteStringEscapeProperty([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> propertyName, int firstEscapeIndexProp)
{
char[] array = null;
if (firstEscapeIndexProp != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> destination;
if (maxEscapedLength > 128) {
array = ArrayPool<char>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<char>(stackalloc byte[256], 128);
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
propertyName = destination.Slice(0, written);
}
WriteStringByOptionsPropertyName(propertyName);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private void WriteStringByOptionsPropertyName(ReadOnlySpan<char> propertyName)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndentedPropertyName(propertyName);
else
WriteStringMinimizedPropertyName(propertyName);
}
private void WriteStringMinimizedPropertyName(ReadOnlySpan<char> escapedPropertyName)
{
int num = escapedPropertyName.Length * 3 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
}
private void WriteStringIndentedPropertyName(ReadOnlySpan<char> escapedPropertyName)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
}
public void WritePropertyName(ReadOnlySpan<byte> utf8PropertyName)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStringEscapeProperty(utf8PropertyName, num);
else
WriteStringByOptionsPropertyName(utf8PropertyName);
_currentDepth &= 2147483647;
_tokenType = JsonTokenType.PropertyName;
_commentAfterNoneOrPropertyName = false;
}
private void WritePropertyNameUnescaped(ReadOnlySpan<byte> utf8PropertyName)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteStringByOptionsPropertyName(utf8PropertyName);
_currentDepth &= 2147483647;
_tokenType = JsonTokenType.PropertyName;
_commentAfterNoneOrPropertyName = false;
}
private unsafe void WriteStringEscapeProperty([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8PropertyName, int firstEscapeIndexProp)
{
byte[] array = null;
if (firstEscapeIndexProp != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> destination;
if (maxEscapedLength > 256) {
array = ArrayPool<byte>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<byte>(stackalloc byte[256], 256);
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
utf8PropertyName = destination.Slice(0, written);
}
WriteStringByOptionsPropertyName(utf8PropertyName);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringByOptionsPropertyName(ReadOnlySpan<byte> utf8PropertyName)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndentedPropertyName(utf8PropertyName);
else
WriteStringMinimizedPropertyName(utf8PropertyName);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteStringMinimizedPropertyName(ReadOnlySpan<byte> escapedPropertyName)
{
int num = escapedPropertyName.Length + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteStringPropertyNameSection(ReadOnlySpan<byte> escapedPropertyNameSection)
{
int num = escapedPropertyNameSection.Length + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
escapedPropertyNameSection.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyNameSection.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void WriteStringIndentedPropertyName(ReadOnlySpan<byte> escapedPropertyName)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
}
public void WriteString(JsonEncodedText propertyName, JsonEncodedText value)
{
WriteStringHelper(propertyName.EncodedUtf8Bytes, value.EncodedUtf8Bytes);
}
private void WriteStringHelper(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
WriteStringByOptions(utf8PropertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteString(string propertyName, JsonEncodedText value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), value);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteString(string propertyName, [System.Runtime.CompilerServices.Nullable(2)] string value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
if (value == null)
WriteNull(propertyName.AsSpan());
else
WriteString(propertyName.AsSpan(), value.AsSpan());
}
public void WriteString(ReadOnlySpan<char> propertyName, ReadOnlySpan<char> value)
{
JsonWriterHelper.ValidatePropertyAndValue(propertyName, value);
WriteStringEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidatePropertyAndValue(utf8PropertyName, utf8Value);
WriteStringEscape(utf8PropertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(2)]
public void WriteString(JsonEncodedText propertyName, string value)
{
if (value == null)
WriteNull(propertyName);
else
WriteString(propertyName, value.AsSpan());
}
public void WriteString(JsonEncodedText propertyName, ReadOnlySpan<char> value)
{
WriteStringHelperEscapeValue(propertyName.EncodedUtf8Bytes, value);
}
private void WriteStringHelperEscapeValue(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<char> value)
{
JsonWriterHelper.ValidateValue(value);
int num = JsonWriterHelper.NeedsEscaping(value, _options.Encoder);
if (num != -1)
WriteStringEscapeValueOnly(utf8PropertyName, value, num);
else
WriteStringByOptions(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString([System.Runtime.CompilerServices.Nullable(1)] string propertyName, ReadOnlySpan<char> value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), value);
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<char> value)
{
JsonWriterHelper.ValidatePropertyAndValue(utf8PropertyName, value);
WriteStringEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(JsonEncodedText propertyName, ReadOnlySpan<byte> utf8Value)
{
WriteStringHelperEscapeValue(propertyName.EncodedUtf8Bytes, utf8Value);
}
private void WriteStringHelperEscapeValue(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidateValue(utf8Value);
int num = JsonWriterHelper.NeedsEscaping(utf8Value, _options.Encoder);
if (num != -1)
WriteStringEscapeValueOnly(utf8PropertyName, utf8Value, num);
else
WriteStringByOptions(utf8PropertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString([System.Runtime.CompilerServices.Nullable(1)] string propertyName, ReadOnlySpan<byte> utf8Value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteString(propertyName.AsSpan(), utf8Value);
}
public void WriteString(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidatePropertyAndValue(propertyName, utf8Value);
WriteStringEscape(propertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<char> propertyName, JsonEncodedText value)
{
WriteStringHelperEscapeProperty(propertyName, value.EncodedUtf8Bytes);
}
private void WriteStringHelperEscapeProperty(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidateProperty(propertyName);
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteStringEscapePropertyOnly(propertyName, utf8Value, num);
else
WriteStringByOptions(propertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<char> propertyName, [System.Runtime.CompilerServices.Nullable(2)] string value)
{
if (value == null)
WriteNull(propertyName);
else
WriteString(propertyName, value.AsSpan());
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, JsonEncodedText value)
{
WriteStringHelperEscapeProperty(utf8PropertyName, value.EncodedUtf8Bytes);
}
private void WriteStringHelperEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteStringEscapePropertyOnly(utf8PropertyName, utf8Value, num);
else
WriteStringByOptions(utf8PropertyName, utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
public void WriteString(ReadOnlySpan<byte> utf8PropertyName, [System.Runtime.CompilerServices.Nullable(2)] string value)
{
if (value == null)
WriteNull(utf8PropertyName);
else
WriteString(utf8PropertyName, value.AsSpan());
}
private unsafe void WriteStringEscapeValueOnly(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> utf8Value, int firstEscapeIndex)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndex);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8Value, destination, firstEscapeIndex, _options.Encoder, out int written);
WriteStringByOptions(escapedPropertyName, destination.Slice(0, written));
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapeValueOnly(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<char> value, int firstEscapeIndex)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndex);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(value, destination, firstEscapeIndex, _options.Encoder, out int written);
WriteStringByOptions(escapedPropertyName, destination.Slice(0, written));
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapePropertyOnly(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> escapedValue, int firstEscapeIndex)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndex);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndex, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), escapedValue);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteStringEscapePropertyOnly(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> escapedValue, int firstEscapeIndex)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndex);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndex, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written), escapedValue);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteStringEscape(ReadOnlySpan<char> propertyName, ReadOnlySpan<char> value)
{
int num = JsonWriterHelper.NeedsEscaping(value, _options.Encoder);
int num2 = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num + num2 != -2)
WriteStringEscapePropertyOrValue(propertyName, value, num2, num);
else
WriteStringByOptions(propertyName, value);
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8Value, _options.Encoder);
int num2 = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num + num2 != -2)
WriteStringEscapePropertyOrValue(utf8PropertyName, utf8Value, num2, num);
else
WriteStringByOptions(utf8PropertyName, utf8Value);
}
private void WriteStringEscape(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8Value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8Value, _options.Encoder);
int num2 = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num + num2 != -2)
WriteStringEscapePropertyOrValue(propertyName, utf8Value, num2, num);
else
WriteStringByOptions(propertyName, utf8Value);
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<char> value)
{
int num = JsonWriterHelper.NeedsEscaping(value, _options.Encoder);
int num2 = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num + num2 != -2)
WriteStringEscapePropertyOrValue(utf8PropertyName, value, num2, num);
else
WriteStringByOptions(utf8PropertyName, value);
}
private unsafe void WriteStringEscapePropertyOrValue([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> propertyName, [System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> value, int firstEscapeIndexProp, int firstEscapeIndexVal)
{
char[] array = null;
char[] array2 = null;
if (firstEscapeIndexVal != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndexVal);
Span<char> destination;
if (maxEscapedLength > 128) {
array = ArrayPool<char>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<char>(stackalloc byte[256], 128);
JsonWriterHelper.EscapeString(value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
value = destination.Slice(0, written);
}
if (firstEscapeIndexProp != -1) {
int maxEscapedLength2 = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> destination2;
if (maxEscapedLength2 > 128) {
array2 = ArrayPool<char>.Shared.Rent(maxEscapedLength2);
destination2 = array2;
} else
destination2 = new Span<char>(stackalloc byte[256], 128);
JsonWriterHelper.EscapeString(propertyName, destination2, firstEscapeIndexProp, _options.Encoder, out int written2);
propertyName = destination2.Slice(0, written2);
}
WriteStringByOptions(propertyName, value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
if (array2 != null)
ArrayPool<char>.Shared.Return(array2, false);
}
private unsafe void WriteStringEscapePropertyOrValue([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8PropertyName, [System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8Value, int firstEscapeIndexProp, int firstEscapeIndexVal)
{
byte[] array = null;
byte[] array2 = null;
if (firstEscapeIndexVal != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal);
Span<byte> destination;
if (maxEscapedLength > 256) {
array = ArrayPool<byte>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<byte>(stackalloc byte[256], 256);
JsonWriterHelper.EscapeString(utf8Value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
utf8Value = destination.Slice(0, written);
}
if (firstEscapeIndexProp != -1) {
int maxEscapedLength2 = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> destination2;
if (maxEscapedLength2 > 256) {
array2 = ArrayPool<byte>.Shared.Rent(maxEscapedLength2);
destination2 = array2;
} else
destination2 = new Span<byte>(stackalloc byte[256], 256);
JsonWriterHelper.EscapeString(utf8PropertyName, destination2, firstEscapeIndexProp, _options.Encoder, out int written2);
utf8PropertyName = destination2.Slice(0, written2);
}
WriteStringByOptions(utf8PropertyName, utf8Value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
if (array2 != null)
ArrayPool<byte>.Shared.Return(array2, false);
}
private unsafe void WriteStringEscapePropertyOrValue([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> propertyName, [System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8Value, int firstEscapeIndexProp, int firstEscapeIndexVal)
{
byte[] array = null;
char[] array2 = null;
if (firstEscapeIndexVal != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal);
Span<byte> destination;
if (maxEscapedLength > 256) {
array = ArrayPool<byte>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<byte>(stackalloc byte[256], 256);
JsonWriterHelper.EscapeString(utf8Value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
utf8Value = destination.Slice(0, written);
}
if (firstEscapeIndexProp != -1) {
int maxEscapedLength2 = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> destination2;
if (maxEscapedLength2 > 128) {
array2 = ArrayPool<char>.Shared.Rent(maxEscapedLength2);
destination2 = array2;
} else
destination2 = new Span<char>(stackalloc byte[256], 128);
JsonWriterHelper.EscapeString(propertyName, destination2, firstEscapeIndexProp, _options.Encoder, out int written2);
propertyName = destination2.Slice(0, written2);
}
WriteStringByOptions(propertyName, utf8Value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
if (array2 != null)
ArrayPool<char>.Shared.Return(array2, false);
}
private unsafe void WriteStringEscapePropertyOrValue([System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<byte> utf8PropertyName, [System.Runtime.CompilerServices.ScopedRef] ReadOnlySpan<char> value, int firstEscapeIndexProp, int firstEscapeIndexVal)
{
char[] array = null;
byte[] array2 = null;
if (firstEscapeIndexVal != -1) {
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndexVal);
Span<char> destination;
if (maxEscapedLength > 128) {
array = ArrayPool<char>.Shared.Rent(maxEscapedLength);
destination = array;
} else
destination = new Span<char>(stackalloc byte[256], 128);
JsonWriterHelper.EscapeString(value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
value = destination.Slice(0, written);
}
if (firstEscapeIndexProp != -1) {
int maxEscapedLength2 = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> destination2;
if (maxEscapedLength2 > 256) {
array2 = ArrayPool<byte>.Shared.Rent(maxEscapedLength2);
destination2 = array2;
} else
destination2 = new Span<byte>(stackalloc byte[256], 256);
JsonWriterHelper.EscapeString(utf8PropertyName, destination2, firstEscapeIndexProp, _options.Encoder, out int written2);
utf8PropertyName = destination2.Slice(0, written2);
}
WriteStringByOptions(utf8PropertyName, value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
if (array2 != null)
ArrayPool<byte>.Shared.Return(array2, false);
}
private void WriteStringByOptions(ReadOnlySpan<char> propertyName, ReadOnlySpan<char> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(propertyName, value);
else
WriteStringMinimized(propertyName, value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(utf8PropertyName, utf8Value);
else
WriteStringMinimized(utf8PropertyName, utf8Value);
}
private void WriteStringByOptions(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8Value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(propertyName, utf8Value);
else
WriteStringMinimized(propertyName, utf8Value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<char> value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteStringIndented(utf8PropertyName, value);
else
WriteStringMinimized(utf8PropertyName, value);
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<char> escapedValue)
{
int num = (escapedPropertyName.Length + escapedValue.Length) * 3 + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> escapedValue)
{
int num = escapedPropertyName.Length + escapedValue.Length + 5 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> escapedValue)
{
int num = escapedPropertyName.Length * 3 + escapedValue.Length + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<char> escapedValue)
{
int num = escapedValue.Length * 3 + escapedPropertyName.Length + 6;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<char> escapedValue)
{
int indentation = Indentation;
int num = indentation + (escapedPropertyName.Length + escapedValue.Length) * 3 + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<byte> escapedValue)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + escapedValue.Length + 6 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedPropertyName, ReadOnlySpan<byte> escapedValue)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + escapedValue.Length + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedPropertyName, ReadOnlySpan<char> escapedValue)
{
int indentation = Indentation;
int num = indentation + escapedValue.Length * 3 + escapedPropertyName.Length + 7 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
[CLSCompliant(false)]
public void WriteNumber(JsonEncodedText propertyName, ulong value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = propertyName.EncodedUtf8Bytes;
WriteNumberByOptions(encodedUtf8Bytes, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[System.Runtime.CompilerServices.NullableContext(1)]
[CLSCompliant(false)]
public void WriteNumber(string propertyName, ulong value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), value);
}
[CLSCompliant(false)]
public void WriteNumber(ReadOnlySpan<char> propertyName, ulong value)
{
JsonWriterHelper.ValidateProperty(propertyName);
WriteNumberEscape(propertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[CLSCompliant(false)]
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, ulong value)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
WriteNumberEscape(utf8PropertyName, value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
[CLSCompliant(false)]
public void WriteNumber(JsonEncodedText propertyName, uint value)
{
WriteNumber(propertyName, (ulong)value);
}
[System.Runtime.CompilerServices.NullableContext(1)]
[CLSCompliant(false)]
public void WriteNumber(string propertyName, uint value)
{
System.ExceptionPolyfills.ThrowIfNull(propertyName, "propertyName");
WriteNumber(propertyName.AsSpan(), (ulong)value);
}
[CLSCompliant(false)]
public void WriteNumber(ReadOnlySpan<char> propertyName, uint value)
{
WriteNumber(propertyName, (ulong)value);
}
[CLSCompliant(false)]
public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, uint value)
{
WriteNumber(utf8PropertyName, (ulong)value);
}
private void WriteNumberEscape(ReadOnlySpan<char> propertyName, ulong value)
{
int num = JsonWriterHelper.NeedsEscaping(propertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(propertyName, value, num);
else
WriteNumberByOptions(propertyName, value);
}
private void WriteNumberEscape(ReadOnlySpan<byte> utf8PropertyName, ulong value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8PropertyName, _options.Encoder);
if (num != -1)
WriteNumberEscapeProperty(utf8PropertyName, value, num);
else
WriteNumberByOptions(utf8PropertyName, value);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<char> propertyName, ulong value, int firstEscapeIndexProp)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(propertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
private unsafe void WriteNumberEscapeProperty(ReadOnlySpan<byte> utf8PropertyName, ulong value, int firstEscapeIndexProp)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8PropertyName, destination, firstEscapeIndexProp, _options.Encoder, out int written);
WriteNumberByOptions(destination.Slice(0, written), value);
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
private void WriteNumberByOptions(ReadOnlySpan<char> propertyName, ulong value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(propertyName, value);
else
WriteNumberMinimized(propertyName, value);
}
private void WriteNumberByOptions(ReadOnlySpan<byte> utf8PropertyName, ulong value)
{
ValidateWritingProperty();
if (_options.Indented)
WriteNumberIndented(utf8PropertyName, value);
else
WriteNumberMinimized(utf8PropertyName, value);
}
private void WriteNumberMinimized(ReadOnlySpan<char> escapedPropertyName, ulong value)
{
int num = escapedPropertyName.Length * 3 + 20 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberMinimized(ReadOnlySpan<byte> escapedPropertyName, ulong value)
{
int num = escapedPropertyName.Length + 20 + 3 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<char> escapedPropertyName, ulong value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length * 3 + 20 + 5 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedPropertyName, span);
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberIndented(ReadOnlySpan<byte> escapedPropertyName, ulong value)
{
int indentation = Indentation;
int num = indentation + escapedPropertyName.Length + 20 + 4 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
span[BytesPending++] = 34;
escapedPropertyName.CopyTo(span.Slice(BytesPending));
BytesPending += escapedPropertyName.Length;
span[BytesPending++] = 34;
span[BytesPending++] = 58;
span[BytesPending++] = 32;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal void WritePropertyName(uint value)
{
WritePropertyName((ulong)value);
}
internal unsafe void WritePropertyName(ulong value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[20], 20);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WritePropertyNameUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteBase64StringValue(ReadOnlySpan<byte> bytes)
{
WriteBase64ByOptions(bytes);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteBase64ByOptions(ReadOnlySpan<byte> bytes)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteBase64Indented(bytes);
else
WriteBase64Minimized(bytes);
}
private void WriteBase64Minimized(ReadOnlySpan<byte> bytes)
{
if (bytes.Length > 1610612733)
ThrowHelper.ThrowArgumentException_ValueTooLarge(bytes.Length);
int num = Base64.GetMaxEncodedToUtf8Length(bytes.Length) + 3;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
private void WriteBase64Indented(ReadOnlySpan<byte> bytes)
{
int indentation = Indentation;
int num = indentation + 3 + _newLineLength;
int num2 = 1610612733 - num;
if (bytes.Length > num2)
ThrowHelper.ThrowArgumentException_ValueTooLarge(bytes.Length);
int num3 = Base64.GetMaxEncodedToUtf8Length(bytes.Length) + num;
if (_memory.Length - BytesPending < num3)
Grow(num3);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
Base64EncodeAndWrite(bytes, span);
span[BytesPending++] = 34;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteCommentValue(string value)
{
System.ExceptionPolyfills.ThrowIfNull(value, "value");
WriteCommentValue(value.AsSpan());
}
public void WriteCommentValue(ReadOnlySpan<char> value)
{
JsonWriterHelper.ValidateValue(value);
if (value.IndexOf(s_singleLineCommentDelimiter) != -1)
ThrowHelper.ThrowArgumentException_InvalidCommentValue();
WriteCommentByOptions(value);
JsonTokenType tokenType = _tokenType;
if ((tokenType == JsonTokenType.None || tokenType == JsonTokenType.PropertyName) ? true : false)
_commentAfterNoneOrPropertyName = true;
}
private void WriteCommentByOptions(ReadOnlySpan<char> value)
{
if (!_options.SkipValidation)
ValidateNotWithinUnfinalizedString();
if (_options.Indented)
WriteCommentIndented(value);
else
WriteCommentMinimized(value);
}
private void WriteCommentMinimized(ReadOnlySpan<char> value)
{
int num = value.Length * 3 + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
span[BytesPending++] = 47;
span[BytesPending++] = 42;
if (JsonWriterHelper.ToUtf8(value, span.Slice(BytesPending), out int written) == OperationStatus.InvalidData)
ThrowHelper.ThrowArgumentException_InvalidUTF16(value[written]);
BytesPending += written;
span[BytesPending++] = 42;
span[BytesPending++] = 47;
}
private void WriteCommentIndented(ReadOnlySpan<char> value)
{
int indentation = Indentation;
int num = indentation + value.Length * 3 + 4 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_tokenType != 0 || _commentAfterNoneOrPropertyName) {
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 47;
span[BytesPending++] = 42;
if (JsonWriterHelper.ToUtf8(value, span.Slice(BytesPending), out int written) == OperationStatus.InvalidData)
ThrowHelper.ThrowArgumentException_InvalidUTF16(value[written]);
BytesPending += written;
span[BytesPending++] = 42;
span[BytesPending++] = 47;
}
public void WriteCommentValue(ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidateValue(utf8Value);
if (utf8Value.IndexOf(SingleLineCommentDelimiterUtf8) != -1)
ThrowHelper.ThrowArgumentException_InvalidCommentValue();
if (!JsonWriterHelper.IsValidUtf8String(utf8Value))
ThrowHelper.ThrowArgumentException_InvalidUTF8(utf8Value);
WriteCommentByOptions(utf8Value);
JsonTokenType tokenType = _tokenType;
if ((tokenType == JsonTokenType.None || tokenType == JsonTokenType.PropertyName) ? true : false)
_commentAfterNoneOrPropertyName = true;
}
private void WriteCommentByOptions(ReadOnlySpan<byte> utf8Value)
{
if (_options.Indented)
WriteCommentIndented(utf8Value);
else
WriteCommentMinimized(utf8Value);
}
private void WriteCommentMinimized(ReadOnlySpan<byte> utf8Value)
{
int num = utf8Value.Length + 4;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
span[BytesPending++] = 47;
span[BytesPending++] = 42;
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
span[BytesPending++] = 42;
span[BytesPending++] = 47;
}
private void WriteCommentIndented(ReadOnlySpan<byte> utf8Value)
{
int indentation = Indentation;
int num = indentation + utf8Value.Length + 4 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_tokenType != 0 || _commentAfterNoneOrPropertyName) {
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 47;
span[BytesPending++] = 42;
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
span[BytesPending++] = 42;
span[BytesPending++] = 47;
}
public void WriteStringValue(DateTime value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteStringValueIndented(value);
else
WriteStringValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringValueMinimized(DateTime value)
{
int num = 36;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringValueIndented(DateTime value)
{
int indentation = Indentation;
int num = indentation + 33 + 3 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
public void WriteStringValue(DateTimeOffset value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteStringValueIndented(value);
else
WriteStringValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringValueMinimized(DateTimeOffset value)
{
int num = 36;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringValueIndented(DateTimeOffset value)
{
int indentation = Indentation;
int num = indentation + 33 + 3 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
JsonWriterHelper.WriteDateTimeOffsetTrimmed(span.Slice(BytesPending), value, out int bytesWritten);
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
public void WriteNumberValue(decimal value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(value);
else
WriteNumberValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(decimal value)
{
int num = 32;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberValueIndented(decimal value)
{
int indentation = Indentation;
int num = indentation + 31 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal unsafe void WriteNumberValueAsString(decimal value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[31], 31);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WriteNumberValueAsStringUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteNumberValue(double value)
{
JsonWriterHelper.ValidateDouble(value);
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(value);
else
WriteNumberValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(double value)
{
int num = 129;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberValueIndented(double value)
{
int indentation = Indentation;
int num = indentation + 128 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
TryFormatDouble(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private static bool TryFormatDouble(double value, Span<byte> destination, out int bytesWritten)
{
string text = value.ToString("G17", CultureInfo.InvariantCulture);
if (text.Length <= destination.Length)
try {
byte[] bytes = Encoding.UTF8.GetBytes(text);
if (bytes.Length <= destination.Length) {
bytes.CopyTo(destination);
bytesWritten = bytes.Length;
return true;
}
bytesWritten = 0;
return false;
} catch {
bytesWritten = 0;
return false;
}
bytesWritten = 0;
return false;
}
internal unsafe void WriteNumberValueAsString(double value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[128], 128);
TryFormatDouble(value, destination, out int bytesWritten);
WriteNumberValueAsStringUnescaped(destination.Slice(0, bytesWritten));
}
internal void WriteFloatingPointConstant(double value)
{
if (double.IsNaN(value))
WriteNumberValueAsStringUnescaped(JsonConstants.NaNValue);
else if (double.IsPositiveInfinity(value)) {
WriteNumberValueAsStringUnescaped(JsonConstants.PositiveInfinityValue);
} else if (double.IsNegativeInfinity(value)) {
WriteNumberValueAsStringUnescaped(JsonConstants.NegativeInfinityValue);
} else {
WriteNumberValue(value);
}
}
public void WriteNumberValue(float value)
{
JsonWriterHelper.ValidateSingle(value);
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(value);
else
WriteNumberValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(float value)
{
int num = 129;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private void WriteNumberValueIndented(float value)
{
int indentation = Indentation;
int num = indentation + 128 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
TryFormatSingle(value, span.Slice(BytesPending), out int bytesWritten);
BytesPending += bytesWritten;
}
private static bool TryFormatSingle(float value, Span<byte> destination, out int bytesWritten)
{
string text = value.ToString("G9", CultureInfo.InvariantCulture);
if (text.Length <= destination.Length)
try {
byte[] bytes = Encoding.UTF8.GetBytes(text);
if (bytes.Length <= destination.Length) {
bytes.CopyTo(destination);
bytesWritten = bytes.Length;
return true;
}
bytesWritten = 0;
return false;
} catch {
bytesWritten = 0;
return false;
}
bytesWritten = 0;
return false;
}
internal unsafe void WriteNumberValueAsString(float value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[128], 128);
TryFormatSingle(value, destination, out int bytesWritten);
WriteNumberValueAsStringUnescaped(destination.Slice(0, bytesWritten));
}
internal void WriteFloatingPointConstant(float value)
{
if (float.IsNaN(value))
WriteNumberValueAsStringUnescaped(JsonConstants.NaNValue);
else if (float.IsPositiveInfinity(value)) {
WriteNumberValueAsStringUnescaped(JsonConstants.PositiveInfinityValue);
} else if (float.IsNegativeInfinity(value)) {
WriteNumberValueAsStringUnescaped(JsonConstants.NegativeInfinityValue);
} else {
WriteNumberValue(value);
}
}
internal void WriteNumberValue(ReadOnlySpan<byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(utf8FormattedNumber);
else
WriteNumberValueMinimized(utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(ReadOnlySpan<byte> utf8Value)
{
int num = utf8Value.Length + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
}
private void WriteNumberValueIndented(ReadOnlySpan<byte> utf8Value)
{
int indentation = Indentation;
int num = indentation + utf8Value.Length + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
}
public void WriteStringValue(Guid value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteStringValueIndented(value);
else
WriteStringValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringValueMinimized(Guid value)
{
int num = 39;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void WriteStringValueIndented(Guid value)
{
int indentation = Indentation;
int num = indentation + 36 + 3 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
span[BytesPending++] = 34;
}
private void ClearPartialStringData()
{
_partialStringDataLength = 0;
}
private void ValidateWritingValue()
{
if (!CanWriteValue)
OnValidateWritingValueFailed();
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void OnValidateWritingValueFailed()
{
if (IsWritingPartialString)
ThrowInvalidOperationException(ExceptionResource.CannotWriteWithinString);
if (_enclosingContainer == EnclosingContainerType.Object)
ThrowInvalidOperationException(ExceptionResource.CannotWriteValueWithinObject);
else
ThrowInvalidOperationException(ExceptionResource.CannotWriteValueAfterPrimitiveOrClose);
}
private void ValidateWritingSegment(EnclosingContainerType currentSegmentEncoding)
{
if (_enclosingContainer != currentSegmentEncoding && !CanWriteValue)
OnValidateWritingSegmentFailed(currentSegmentEncoding);
}
[MethodImpl(MethodImplOptions.NoInlining)]
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
private void OnValidateWritingSegmentFailed(EnclosingContainerType currentSegmentEncoding)
{
if (IsWritingPartialString)
ThrowHelper.ThrowInvalidOperationException_CannotMixEncodings(_enclosingContainer, currentSegmentEncoding);
if (_enclosingContainer == EnclosingContainerType.Object)
ThrowInvalidOperationException(ExceptionResource.CannotWriteValueWithinObject);
else
ThrowInvalidOperationException(ExceptionResource.CannotWriteValueAfterPrimitiveOrClose);
}
private void ValidateNotWithinUnfinalizedString()
{
if (IsWritingPartialString)
ThrowInvalidOperationException(ExceptionResource.CannotWriteWithinString);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void Base64EncodeAndWrite(ReadOnlySpan<byte> bytes, Span<byte> output)
{
Span<byte> utf = output.Slice(BytesPending);
Base64.EncodeToUtf8(bytes, utf, out int _, out int bytesWritten, true);
BytesPending += bytesWritten;
}
public void WriteNullValue()
{
WriteLiteralByOptions(JsonConstants.NullValue);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Null;
}
public void WriteBooleanValue(bool value)
{
if (value) {
WriteLiteralByOptions(JsonConstants.TrueValue);
_tokenType = JsonTokenType.True;
} else {
WriteLiteralByOptions(JsonConstants.FalseValue);
_tokenType = JsonTokenType.False;
}
SetFlagToAddListSeparatorBeforeNextItem();
}
private void WriteLiteralByOptions(ReadOnlySpan<byte> utf8Value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteLiteralIndented(utf8Value);
else
WriteLiteralMinimized(utf8Value);
}
private void WriteLiteralMinimized(ReadOnlySpan<byte> utf8Value)
{
int num = utf8Value.Length + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
}
private void WriteLiteralIndented(ReadOnlySpan<byte> utf8Value)
{
int indentation = Indentation;
int num = indentation + utf8Value.Length + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
utf8Value.CopyTo(span.Slice(BytesPending));
BytesPending += utf8Value.Length;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public void WriteRawValue([System.Diagnostics.CodeAnalysis.StringSyntax("Json")] string json, bool skipInputValidation = false)
{
if (!_options.SkipValidation)
ValidateWritingValue();
System.ExceptionPolyfills.ThrowIfNull(json, "json");
TranscodeAndWriteRawValue(json.AsSpan(), skipInputValidation);
}
public void WriteRawValue([System.Diagnostics.CodeAnalysis.StringSyntax("Json")] ReadOnlySpan<char> json, bool skipInputValidation = false)
{
if (!_options.SkipValidation)
ValidateWritingValue();
TranscodeAndWriteRawValue(json, skipInputValidation);
}
public void WriteRawValue(ReadOnlySpan<byte> utf8Json, bool skipInputValidation = false)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (utf8Json.Length == 2147483647)
ThrowHelper.ThrowArgumentException_ValueTooLarge(2147483647);
WriteRawValueCore(utf8Json, skipInputValidation);
}
public void WriteRawValue(ReadOnlySequence<byte> utf8Json, bool skipInputValidation = false)
{
if (!_options.SkipValidation)
ValidateWritingValue();
long length = utf8Json.Length;
if (length == 0)
ThrowHelper.ThrowArgumentException(System.SR.ExpectedJsonTokens);
if (length >= 2147483647)
ThrowHelper.ThrowArgumentException_ValueTooLarge(length);
if (skipInputValidation)
_tokenType = JsonTokenType.String;
else {
Utf8JsonReader utf8JsonReader = new Utf8JsonReader(utf8Json, default(JsonReaderOptions));
while (utf8JsonReader.Read()) {
}
_tokenType = utf8JsonReader.TokenType;
}
int num = (int)length;
int num2 = num + 1;
if (_memory.Length - BytesPending < num2)
Grow(num2);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
ref utf8Json.CopyTo(span.Slice(BytesPending));
BytesPending += num;
SetFlagToAddListSeparatorBeforeNextItem();
}
private unsafe void TranscodeAndWriteRawValue(ReadOnlySpan<char> json, bool skipInputValidation)
{
if (json.Length > 715827882)
ThrowHelper.ThrowArgumentException_ValueTooLarge(json.Length);
byte[] array = null;
Span<byte> span = (json.Length > 85) ? ((Span<byte>)(((long)json.Length > 349525) ? new byte[JsonReaderHelper.GetUtf8ByteCount(json)] : (array = ArrayPool<byte>.Shared.Rent(json.Length * 3)))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> span2 = span;
try {
int utf8FromText = JsonReaderHelper.GetUtf8FromText(json, span2);
span2 = span2.Slice(0, utf8FromText);
WriteRawValueCore(span2, skipInputValidation);
} finally {
if (array != null) {
span2.Clear();
ArrayPool<byte>.Shared.Return(array, false);
}
}
}
private void WriteRawValueCore(ReadOnlySpan<byte> utf8Json, bool skipInputValidation)
{
int length = utf8Json.Length;
if (length == 0)
ThrowHelper.ThrowArgumentException(System.SR.ExpectedJsonTokens);
if (skipInputValidation)
_tokenType = JsonTokenType.String;
else {
Utf8JsonReader utf8JsonReader = new Utf8JsonReader(utf8Json, default(JsonReaderOptions));
while (utf8JsonReader.Read()) {
}
_tokenType = utf8JsonReader.TokenType;
}
int num = length + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
utf8Json.CopyTo(span.Slice(BytesPending));
BytesPending += length;
SetFlagToAddListSeparatorBeforeNextItem();
}
public void WriteNumberValue(int value)
{
WriteNumberValue((long)value);
}
public void WriteNumberValue(long value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(value);
else
WriteNumberValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(long value)
{
int num = 21;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberValueIndented(long value)
{
int indentation = Indentation;
int num = indentation + 20 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal unsafe void WriteNumberValueAsString(long value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[20], 20);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WriteNumberValueAsStringUnescaped(destination.Slice(0, bytesWritten));
}
public void WriteStringValue(JsonEncodedText value)
{
ReadOnlySpan<byte> encodedUtf8Bytes = value.EncodedUtf8Bytes;
WriteStringByOptions(encodedUtf8Bytes);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[System.Runtime.CompilerServices.NullableContext(2)]
public void WriteStringValue(string value)
{
if (value == null)
WriteNullValue();
else
WriteStringValue(value.AsSpan());
}
public void WriteStringValue(ReadOnlySpan<char> value)
{
JsonWriterHelper.ValidateValue(value);
WriteStringEscape(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringEscape(ReadOnlySpan<char> value)
{
int num = JsonWriterHelper.NeedsEscaping(value, _options.Encoder);
if (num != -1)
WriteStringEscapeValue(value, num);
else
WriteStringByOptions(value);
}
private void WriteStringByOptions(ReadOnlySpan<char> value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteStringIndented(value);
else
WriteStringMinimized(value);
}
private void WriteStringMinimized(ReadOnlySpan<char> escapedValue)
{
int num = escapedValue.Length * 3 + 3;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<char> escapedValue)
{
int indentation = Indentation;
int num = indentation + escapedValue.Length * 3 + 3 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
TranscodeAndWrite(escapedValue, span);
span[BytesPending++] = 34;
}
private unsafe void WriteStringEscapeValue(ReadOnlySpan<char> value, int firstEscapeIndexVal)
{
char[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndexVal);
Span<char> span = (maxEscapedLength > 128) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(maxEscapedLength))) : new Span<char>(stackalloc byte[256], 128);
Span<char> destination = span;
JsonWriterHelper.EscapeString(value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written));
if (array != null)
ArrayPool<char>.Shared.Return(array, false);
}
public void WriteStringValue(ReadOnlySpan<byte> utf8Value)
{
JsonWriterHelper.ValidateValue(utf8Value);
WriteStringEscape(utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
private void WriteStringEscape(ReadOnlySpan<byte> utf8Value)
{
int num = JsonWriterHelper.NeedsEscaping(utf8Value, _options.Encoder);
if (num != -1)
WriteStringEscapeValue(utf8Value, num);
else
WriteStringByOptions(utf8Value);
}
private void WriteStringByOptions(ReadOnlySpan<byte> utf8Value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteStringIndented(utf8Value);
else
WriteStringMinimized(utf8Value);
}
private void WriteStringMinimized(ReadOnlySpan<byte> escapedValue)
{
int num = escapedValue.Length + 2 + 1;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private void WriteStringIndented(ReadOnlySpan<byte> escapedValue)
{
int indentation = Indentation;
int num = indentation + escapedValue.Length + 2 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
span[BytesPending++] = 34;
escapedValue.CopyTo(span.Slice(BytesPending));
BytesPending += escapedValue.Length;
span[BytesPending++] = 34;
}
private unsafe void WriteStringEscapeValue(ReadOnlySpan<byte> utf8Value, int firstEscapeIndexVal)
{
byte[] array = null;
int maxEscapedLength = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal);
Span<byte> span = (maxEscapedLength > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(maxEscapedLength))) : new Span<byte>(stackalloc byte[256], 256);
Span<byte> destination = span;
JsonWriterHelper.EscapeString(utf8Value, destination, firstEscapeIndexVal, _options.Encoder, out int written);
WriteStringByOptions(destination.Slice(0, written));
if (array != null)
ArrayPool<byte>.Shared.Return(array, false);
}
internal void WriteNumberValueAsStringUnescaped(ReadOnlySpan<byte> utf8Value)
{
WriteStringByOptions(utf8Value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
[CLSCompliant(false)]
public void WriteNumberValue(uint value)
{
WriteNumberValue((ulong)value);
}
[CLSCompliant(false)]
public void WriteNumberValue(ulong value)
{
if (!_options.SkipValidation)
ValidateWritingValue();
if (_options.Indented)
WriteNumberValueIndented(value);
else
WriteNumberValueMinimized(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private void WriteNumberValueMinimized(ulong value)
{
int num = 21;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
private void WriteNumberValueIndented(ulong value)
{
int indentation = Indentation;
int num = indentation + 20 + 1 + _newLineLength;
if (_memory.Length - BytesPending < num)
Grow(num);
Span<byte> span = _memory.Span;
if (_currentDepth < 0)
span[BytesPending++] = 44;
if (_tokenType != JsonTokenType.PropertyName) {
if (_tokenType != 0)
WriteNewLine(span);
WriteIndentation(span.Slice(BytesPending), indentation);
BytesPending += indentation;
}
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, span.Slice(BytesPending), out bytesWritten, default(StandardFormat));
BytesPending += bytesWritten;
}
internal unsafe void WriteNumberValueAsString(ulong value)
{
Span<byte> destination = new Span<byte>(stackalloc byte[20], 20);
int bytesWritten = default(int);
Utf8Formatter.TryFormat(value, destination, out bytesWritten, default(StandardFormat));
WriteNumberValueAsStringUnescaped(destination.Slice(0, bytesWritten));
}
}
}