TryParseValue() [1/2]

static bool System.Text.Json.JsonDocument.TryParseValue ( ref Utf8JsonReader reader, [NotNullWhen(true)] out JsonDocument document, bool shouldThrow, bool useArrayPools )

inlinestaticpackage

Definition at line 1236 of file JsonDocument.cs.

    {
        JsonReaderState currentState = reader.CurrentState;
        CheckSupportedOptions(currentState.Options, "reader");
        Utf8JsonReader utf8JsonReader = reader;
        ReadOnlySpan<byte> readOnlySpan = default(ReadOnlySpan<byte>);
        ReadOnlySequence<byte> sequence = default(ReadOnlySequence<byte>);
        try
        {
            JsonTokenType tokenType = reader.TokenType;
            ReadOnlySpan<byte> bytes;
            if ((tokenType == JsonTokenType.None || tokenType == JsonTokenType.PropertyName) && !reader.Read())
            {
                if (shouldThrow)
                {
                    bytes = default(ReadOnlySpan<byte>);
                    ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.ExpectedJsonTokens, 0, bytes);
                }
                reader = utf8JsonReader;
                document = null;
                return false;
            }
            switch (reader.TokenType)
            {
            case JsonTokenType.StartObject:
            case JsonTokenType.StartArray:
            {
                long tokenStartIndex = reader.TokenStartIndex;
                if (!reader.TrySkip())
                {
                    if (shouldThrow)
                    {
                        bytes = default(ReadOnlySpan<byte>);
                        ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.ExpectedJsonTokens, 0, bytes);
                    }
                    reader = utf8JsonReader;
                    document = null;
                    return false;
                }
                long num3 = reader.BytesConsumed - tokenStartIndex;
                ReadOnlySequence<byte> originalSequence2 = reader.OriginalSequence;
                if (originalSequence2.IsEmpty)
                {
                    bytes = reader.OriginalSpan;
                    readOnlySpan = checked(bytes.Slice((int)tokenStartIndex, (int)num3));
                }
                else
                {
                    sequence = originalSequence2.Slice(tokenStartIndex, num3);
                }
                break;
            }
            case JsonTokenType.True:
            case JsonTokenType.False:
            case JsonTokenType.Null:
                if (useArrayPools)
                {
                    if (reader.HasValueSequence)
                    {
                        sequence = reader.ValueSequence;
                    }
                    else
                    {
                        readOnlySpan = reader.ValueSpan;
                    }
                    break;
                }
                document = CreateForLiteral(reader.TokenType);
                return true;
            case JsonTokenType.Number:
                if (reader.HasValueSequence)
                {
                    sequence = reader.ValueSequence;
                }
                else
                {
                    readOnlySpan = reader.ValueSpan;
                }
                break;
            case JsonTokenType.String:
            {
                ReadOnlySequence<byte> originalSequence = reader.OriginalSequence;
                if (originalSequence.IsEmpty)
                {
                    bytes = reader.ValueSpan;
                    int length = bytes.Length + 2;
                    readOnlySpan = reader.OriginalSpan.Slice((int)reader.TokenStartIndex, length);
                    break;
                }
                long num = 2L;
                if (reader.HasValueSequence)
                {
                    num += reader.ValueSequence.Length;
                }
                else
                {
                    long num2 = num;
                    bytes = reader.ValueSpan;
                    num = num2 + bytes.Length;
                }
                sequence = originalSequence.Slice(reader.TokenStartIndex, num);
                break;
            }
            default:
                if (shouldThrow)
                {
                    bytes = reader.ValueSpan;
                    byte nextByte = bytes[0];
                    bytes = default(ReadOnlySpan<byte>);
                    ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.ExpectedStartOfValueNotFound, nextByte, bytes);
                }
                reader = utf8JsonReader;
                document = null;
                return false;
            }
        }
        catch
        {
            reader = utf8JsonReader;
            throw;
        }
        int num4 = (readOnlySpan.IsEmpty ? checked((int)sequence.Length) : readOnlySpan.Length);
        if (useArrayPools)
        {
            byte[] array = ArrayPool<byte>.Shared.Rent(num4);
            Span<byte> destination = array.AsSpan(0, num4);
            try
            {
                if (readOnlySpan.IsEmpty)
                {
                    sequence.CopyTo(destination);
                }
                else
                {
                    readOnlySpan.CopyTo(destination);
                }
                document = Parse(array.AsMemory(0, num4), currentState.Options, array);
            }
            catch
            {
                destination.Clear();
                ArrayPool<byte>.Shared.Return(array);
                throw;
            }
        }
        else
        {
            byte[] array2 = ((!readOnlySpan.IsEmpty) ? readOnlySpan.ToArray() : BuffersExtensions.ToArray(in sequence));
            document = ParseUnrented(array2, currentState.Options, reader.TokenType);
        }
        return true;
    }

References System.array, System.bytes, System.Text.Json.JsonDocument.CheckSupportedOptions(), System.Span< T >.CopyTo(), System.Text.Json.JsonDocument.CreateForLiteral(), System.destination, System.Text.Json.Dictionary, System.L, System.length, System.Text.Json.JsonDocument.Parse(), System.Text.Json.JsonDocument.ParseUnrented(), System.Buffers.ArrayPool< T >.Shared, System.Buffers.ReadOnlySequence< T >.Slice(), and System.Text.Json.ThrowHelper.ThrowJsonReaderException().