public static byte[] SequenceReturnBytesHelper(byte[] data, out int length, JsonCommentHandling commentHandling = JsonCommentHandling.Disallow, int maxDepth = 64) { ReadOnlySequence <byte> sequence = CreateSegments(data); var state = new JsonReaderState(new JsonReaderOptions { CommentHandling = commentHandling, MaxDepth = maxDepth }); var reader = new Utf8JsonReader(sequence, true, state); return(ReaderLoop(data.Length, out length, ref reader)); }
private static void TestReadingJsonWithComments(byte[] inputData, ReadOnlySequence <byte> sequence, string expectedWithoutComments, string expectedWithComments) { var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = JsonCommentHandling.Allow }); var json = new Utf8JsonReader(sequence, isFinalBlock: true, state); var builder = new StringBuilder(); while (json.Read()) { if (json.TokenType == JsonTokenType.Number || json.TokenType == JsonTokenType.Comment || json.TokenType == JsonTokenType.PropertyName) { builder.Append(Encoding.UTF8.GetString(json.HasValueSequence ? json.ValueSequence.ToArray() : json.ValueSpan.ToArray())); if (json.HasValueSequence) { Assert.True(json.ValueSpan == default); } else { Assert.True(json.ValueSequence.IsEmpty); } } } Assert.Equal(expectedWithComments, builder.ToString()); Assert.Equal(inputData, sequence.Slice(0, json.Position).ToArray()); Assert.True(json.Position.Equals(json.CurrentState.Position)); state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = JsonCommentHandling.Skip }); json = new Utf8JsonReader(sequence, isFinalBlock: true, state); builder = new StringBuilder(); while (json.Read()) { if (json.TokenType == JsonTokenType.Number || json.TokenType == JsonTokenType.Comment || json.TokenType == JsonTokenType.PropertyName) { builder.Append(Encoding.UTF8.GetString(json.HasValueSequence ? json.ValueSequence.ToArray() : json.ValueSpan.ToArray())); if (json.HasValueSequence) { Assert.True(json.ValueSpan == default); } else { Assert.True(json.ValueSequence.IsEmpty); } } } Assert.Equal(expectedWithoutComments, builder.ToString()); Assert.Equal(inputData, sequence.Slice(0, json.Position).ToArray()); Assert.True(json.Position.Equals(json.CurrentState.Position)); }
public static async Task <(bool success, IEnumerable <string> failedIds)> FromStreamAsync(Stream stream, CancellationToken ct = default) { var buffer = ArrayPool <byte> .Shared.Rent(1024); // hardcoded as I know the length in this sample JsonReaderState state = default; int leftOver = 0; bool foundErrorsProperty = false; bool hasErrors = true; List <string> errors = null; var insideMainObject = false; var insideItemsArray = false; try { while (true) { // could use pipelines here too int dataLength = await stream.ReadAsync(buffer.AsMemory(leftOver, buffer.Length - leftOver), ct); int dataSize = dataLength + leftOver; bool isFinalBlock = dataSize == 0; var consumed = ParseErrors(buffer.AsSpan(0, dataSize), isFinalBlock, ref state, ref foundErrorsProperty, ref hasErrors, ref insideMainObject, ref insideItemsArray, ref errors); if (foundErrorsProperty && !hasErrors) { break; // there are no errors so we can short-circuit here. } leftOver = dataSize - (int)consumed; if (leftOver != 0) { buffer.AsSpan(dataSize - leftOver).CopyTo(buffer); // can we avoid this copy? } if (isFinalBlock) { break; } } } finally { ArrayPool <byte> .Shared.Return(buffer); } return(!hasErrors, errors); }
public JsonReader(TextReader stream) { this.state = JsonReaderState.Start; this.stack = new Stack<JsonReaderState>(); this.buffer = new JsonReaderBuffer { Size = 1024, Stream = stream, Data = new char[1024] }; }
public bool Next() { if (state == JsonReaderState.Final) return false; if (state == JsonReaderState.SyntaxError) return false; if (state == JsonReaderState.StreamError) return false; try { EnsureOrThrow(false); SkipWhiteSpacesOrThrow(); switch (state) { case JsonReaderState.Start: return ReadArrayOrObject(); case JsonReaderState.BeginObject: return ReadPropertyOrEndObject(); case JsonReaderState.BeginArray: return ReadValueOrEndArray(); case JsonReaderState.Property: return ReadPropertySeparatorAndValue(); case JsonReaderState.ValueInObject: return ReadItemSeparatorAndPropertyOrEndObject(); case JsonReaderState.ValueInArray: return ReadItemSeparatorAndValueOrEndArray(); } } catch (JsonReaderStreamException) { state = JsonReaderState.StreamError; } catch (JsonReaderSyntaxException) { state = JsonReaderState.SyntaxError; } finally { if (state == JsonReaderState.Final) SkipWhiteSpaces(); } return false; }
private static object ParseCore(ReadOnlySpan <byte> utf8Json, Type returnType, JsonSerializerOptions options) { if (options == null) { options = s_defaultSettings; } var state = new JsonReaderState(options: options.ReaderOptions); var reader = new Utf8JsonReader(utf8Json, isFinalBlock: true, state); return(ReadCore(reader, returnType, options)); }
private static void ReadCore <T>(ref JsonReaderState readerState, bool isFinalBlock, ReadOnlySpan <byte> buffer, ref DdbEntityReadStack readStack) where T : class { var ddbReader = new DdbReader(buffer, isFinalBlock, ref readerState, ref readStack) { State = { ReadAhead = !isFinalBlock, BytesConsumed = 0 } }; ReadCore <T>(ref ddbReader); readerState = ddbReader.JsonReaderValue.CurrentState; readStack = ddbReader.State; }
//[Fact] //TODO: Fix and re-enable public void ReadFromPipeUsingSpan() { string actual = ""; var taskReader = Task.Run(async() => { SequencePosition position = default; JsonReaderState state = default; string str = ""; while (true) { ReadResult result = await _pipe.Reader.ReadAsync(); ReadOnlySequence <byte> data = result.Buffer; bool isFinalBlock = result.IsCompleted; (state, position, str) = ProcessDataSpan(data, isFinalBlock, state); _pipe.Reader.AdvanceTo(position); actual += str; if (isFinalBlock) { break; } } }); var taskWriter = Task.Run(async() => { while (true) { Memory <byte> mem = default; bool isLastSegment = false; if (_written >= _dataUtf8.Length - 4_000) { isLastSegment = true; mem = _dataUtf8.AsMemory(_written); } else { mem = _dataUtf8.AsMemory(_written, 4_000); } FlushResult result = await _pipe.Writer.WriteAsync(mem); _written += 4000; if (isLastSegment) { break; } } _pipe.Writer.Complete(); }); Task[] tasks = new Task[] { taskReader, taskWriter }; Task.WaitAll(tasks, 30_000); // The test shouldn't take more than 30 seconds to finish. Assert.Equal(_expectedString, actual); }
public static void JsonReaderStateDefaultCtor() { var state = new JsonReaderState(); var expectedOption = new JsonReaderOptions { CommentHandling = JsonCommentHandling.Disallow, MaxDepth = 0 }; Assert.Equal(expectedOption, state.Options); }
public static void JsonWithTrailingCommasMultiSegment_Valid(string jsonString) { byte[] utf8 = Encoding.UTF8.GetBytes(jsonString); ReadOnlySequence <byte> sequence = JsonTestHelper.GetSequence(utf8, 1); { JsonReaderState state = default; TrailingCommasHelper(sequence, state, allow: false, expectThrow: true); } { var state = new JsonReaderState(options: default);
public void Utf8JsonReaderCommentParsing() { var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = CommentHandling }); Utf8JsonReader reader = MultiSegment ? new Utf8JsonReader(_jsonPayloadSequence, isFinalBlock: true, state) : new Utf8JsonReader(_jsonPayload, isFinalBlock: true, state); while (reader.Read()) { } }
public static void ReaderOptionsWinMaxDepth() { byte[] utf8 = Encoding.UTF8.GetBytes("[[]]"); var readerOptions = new JsonReaderOptions { MaxDepth = 1, }; var serializerOptions = new JsonSerializerOptions { MaxDepth = 5, }; Assert.Throws <JsonException>(() => { var reader = new Utf8JsonReader(utf8, readerOptions); JsonSerializer.Deserialize(ref reader, typeof(int[][]), serializerOptions); }); var state = new JsonReaderState(readerOptions); Assert.Throws <JsonException>(() => { var reader = new Utf8JsonReader(utf8, isFinalBlock: false, state); JsonSerializer.Deserialize(ref reader, typeof(int[][]), serializerOptions); }); readerOptions = new JsonReaderOptions { MaxDepth = 5, }; serializerOptions = new JsonSerializerOptions { MaxDepth = 1, }; { var reader = new Utf8JsonReader(utf8, readerOptions); int[][] result = JsonSerializer.Deserialize <int[][]>(ref reader); Assert.Equal(1, result.Length); } { var reader = new Utf8JsonReader(utf8, readerOptions); int[][] result = JsonSerializer.Deserialize <int[][]>(ref reader, serializerOptions); Assert.Equal(1, result.Length); } }
public static void DefaultJsonReaderState() { JsonReaderState state = default; Assert.Equal(0, state.BytesConsumed); Assert.Equal(0, state.MaxDepth); var expectedOption = new JsonReaderOptions { CommentHandling = JsonCommentHandling.Disallow }; Assert.Equal(expectedOption, state.Options); }
private static object ReadInternal(string json, Type returnType, JsonSerializerOptions options = null) { if (options == null) { options = s_defaultSettings; } // todo: use an array pool here for smaller requests to avoid the alloc. Also doc the API that UTF8 is preferred for perf. byte[] jsonBytes = s_utf8Encoding.GetBytes(json); var state = new JsonReaderState(options: options.ReaderOptions); var reader = new Utf8JsonReader(jsonBytes, isFinalBlock: true, state); return(Read(reader, returnType, options)); }
public static bool TryReadPlaylistItem( ref ReadOnlySequence <byte> sequence, ref JsonReaderState state, [NotNullWhen(true)] out string?videoId) { videoId = default; var reader = new Utf8JsonReader(sequence, true, state); int savedDepth = 0; while (reader.Read()) { if (reader.TokenType == JsonTokenType.PropertyName) { if (reader.ValueTextEquals(PlaylistVideoRendererProperty)) { savedDepth = reader.CurrentDepth; } else if (reader.ValueTextEquals(VideoIdPropertyName)) { if (!TryGetString(ref reader, out videoId)) { return(false); } while (reader.CurrentDepth > savedDepth) { if (!reader.Read()) { return(false); } } sequence = sequence.Slice(reader.Position); state = reader.CurrentState; return(true); } else if (reader.ValueTextEquals(SidebarPropertyName)) { if (!reader.TrySkip()) { return(false); } } } } return(false); }
public static void PrintJson(string str) { ReadOnlySpan <byte> dataUtf8 = Encoding.ASCII.GetBytes(str).AsSpan(); var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default); while (json.Read()) { JsonTokenType tokenType = json.TokenType; ReadOnlySpan <byte> valueSpan = json.ValueSpan; switch (tokenType) { case JsonTokenType.StartObject: case JsonTokenType.EndObject: break; case JsonTokenType.StartArray: case JsonTokenType.EndArray: break; case JsonTokenType.PropertyName: break; case JsonTokenType.String: Console.WriteLine($"STRING: {json.GetString()}"); break; case JsonTokenType.Number: if (!json.TryGetInt32(out int valueInteger)) { throw new FormatException(); } break; case JsonTokenType.True: case JsonTokenType.False: Console.WriteLine($"BOOL: {json.GetBoolean()}"); break; case JsonTokenType.Null: break; default: throw new ArgumentException(); } } dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed); JsonReaderState state = json.CurrentState; }
public static void Utf8JsonReaderLoop(ReadOnlySpan <byte> dataUtf8) { var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default); while (json.Read()) { JsonTokenType tokenType = json.TokenType; ReadOnlySpan <byte> valueSpan = json.ValueSpan; switch (tokenType) { case JsonTokenType.StartObject: case JsonTokenType.EndObject: break; case JsonTokenType.StartArray: case JsonTokenType.EndArray: break; case JsonTokenType.PropertyName: break; case JsonTokenType.String: string valueString = json.GetString(); break; case JsonTokenType.Number: if (!json.TryGetInt32(out int valueInteger)) { throw new FormatException(); } break; case JsonTokenType.True: case JsonTokenType.False: bool valueBool = json.GetBoolean(); break; case JsonTokenType.Null: break; default: throw new ArgumentException(); } } dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed); JsonReaderState state = json.CurrentState; }
private static void ReadCore( ref JsonReaderState readerState, bool isFinalBlock, Span <byte> buffer, JsonSerializerOptions options, ref ReadStack state) { var reader = new Utf8JsonReader(buffer, isFinalBlock, readerState); ReadCore( options, ref reader, ref state); readerState = reader.CurrentState; }
public static void EnableComments() { string json = "3"; var options = new JsonReaderOptions { CommentHandling = JsonCommentHandling.Allow, }; byte[] utf8 = Encoding.UTF8.GetBytes(json); AssertExtensions.Throws <ArgumentException>( "reader", () => { var state = new JsonReaderState(options); var reader = new Utf8JsonReader(utf8, isFinalBlock: false, state); JsonSerializer.Deserialize(ref reader, typeof(int)); }); AssertExtensions.Throws <ArgumentException>( "reader", () => { var state = new JsonReaderState(options); var reader = new Utf8JsonReader(utf8, isFinalBlock: true, state); JsonSerializer.Deserialize(ref reader, typeof(int)); }); AssertExtensions.Throws <ArgumentException>( "reader", () => { var state = new JsonReaderState(options); var reader = new Utf8JsonReader(utf8, isFinalBlock: false, state); JsonSerializer.Deserialize <int>(ref reader); }); AssertExtensions.Throws <ArgumentException>( "reader", () => { var state = new JsonReaderState(options); var reader = new Utf8JsonReader(utf8, isFinalBlock: true, state); JsonSerializer.Deserialize <int>(ref reader); }); }
private static void ReadCore( ref JsonReaderState readerState, bool isFinalBlock, byte[] buffer, int bytesToRead, JsonSerializerOptions options, ref ReadStack state) { Utf8JsonReader reader = new Utf8JsonReader(buffer.AsSpan(0, bytesToRead), isFinalBlock, readerState); ReadCore( options, ref reader, ref state); readerState = reader.CurrentState; }
private static object ParseCore(ReadOnlySpan <byte> utf8Json, Type returnType, JsonSerializerOptions options) { options ??= JsonSerializerOptions.s_defaultOptions; var readerState = new JsonReaderState(options.GetReaderOptions()); var reader = new Utf8JsonReader(utf8Json, isFinalBlock: true, readerState); object result = ReadCore(returnType, options, ref reader); readerState = reader.CurrentState; if (readerState.BytesConsumed != utf8Json.Length) { throw new JsonReaderException(SR.Format(SR.DeserializeDataRemaining, utf8Json.Length, utf8Json.Length - readerState.BytesConsumed), readerState); } return(result); }
public override bool Read() { if (ReaderState.Next != null) { ReaderState = ReaderState.Next; this.SetToken(ReaderState.Token, ReaderState.Value); return(true); } else { var result = InnerReader.Read(); this.SetToken(InnerReader.TokenType, InnerReader.Value); ReaderState.Next = new JsonReaderState(this.TokenType, this.Value); ReaderState = ReaderState.Next; return(result); } }
private static object ParseCore(ReadOnlySpan <byte> utf8Json, Type returnType, JsonSerializerOptions options) { if (options == null) { options = JsonSerializerOptions.s_defaultOptions; } var readerState = new JsonReaderState(options.GetReaderOptions()); var reader = new Utf8JsonReader(utf8Json, isFinalBlock: true, readerState); object result = ReadCore(returnType, options, ref reader); if (reader.BytesConsumed != utf8Json.Length) { ThrowHelper.ThrowJsonException_DeserializeDataRemaining(utf8Json.Length, utf8Json.Length - reader.BytesConsumed); } return(result); }
private static object ParseCore(string json, Type returnType, JsonSerializerOptions options = null) { options ??= JsonSerializerOptions.s_defaultOptions; // todo: use an array pool here for smaller requests to avoid the alloc? byte[] jsonBytes = JsonReaderHelper.s_utf8Encoding.GetBytes(json); var readerState = new JsonReaderState(options.GetReaderOptions()); var reader = new Utf8JsonReader(jsonBytes, isFinalBlock: true, readerState); object result = ReadCore(returnType, options, ref reader); readerState = reader.CurrentState; if (readerState.BytesConsumed != jsonBytes.Length) { throw new JsonReaderException(SR.Format(SR.DeserializeDataRemaining, jsonBytes.Length, jsonBytes.Length - readerState.BytesConsumed), readerState); } return(result); }
private static async Task <T> ReadAsync <T>(PipeReader utf8Reader, Type returnType, JsonSerializerOptions options = null, CancellationToken cancellationToken = default) { if (options == null) { options = s_defaultSettings; } ReadObjectState current = default; JsonClassInfo classInfo = options.GetOrAddClass(returnType); current.ClassInfo = classInfo; if (classInfo.ClassType != ClassType.Object) { current.PropertyInfo = classInfo.GetPolicyProperty(); } var readerState = new JsonReaderState(options: options.ReaderOptions); List <ReadObjectState> previous = null; int arrayIndex = 0; ReadResult result; do { result = await utf8Reader.ReadAsync(cancellationToken).ConfigureAwait(false); ReadOnlySequence <byte> buffer = result.Buffer; Read( ref readerState, returnType, result.IsCompleted, buffer, options, ref current, ref previous, ref arrayIndex); utf8Reader.AdvanceTo(buffer.GetPosition(readerState.BytesConsumed), buffer.End); } while (!result.IsCompleted); return((T)current.ReturnValue); }
internal static bool DoSingleValueReadWithReadAhead(ref Utf8JsonReader reader, ref ReadStack state) { // When we're reading ahead we always have to save the state as we don't know if the next token // is an opening object or an array brace. JsonReaderState initialReaderState = reader.CurrentState; long initialReaderBytesConsumed = reader.BytesConsumed; if (!reader.Read()) { return(false); } // Perform the actual read-ahead. JsonTokenType tokenType = reader.TokenType; if (tokenType == JsonTokenType.StartObject || tokenType == JsonTokenType.StartArray) { // Attempt to skip to make sure we have all the data we need. bool complete = reader.TrySkip(); // We need to restore the state in all cases as we need to be positioned back before // the current token to either attempt to skip again or to actually read the value. reader = new Utf8JsonReader(reader.OriginalSpan.Slice(checked ((int)initialReaderBytesConsumed)), isFinalBlock: reader.IsFinalBlock, state: initialReaderState); Debug.Assert(reader.BytesConsumed == 0); state.BytesConsumed += initialReaderBytesConsumed; if (!complete) { // Couldn't read to the end of the object, exit out to get more data in the buffer. return(false); } // Success, requeue the reader to the start token. reader.ReadWithVerify(); Debug.Assert(tokenType == reader.TokenType); } return(true); }
private static void TestReadingSingleValueJson(ReadOnlySequence <byte> sequence, string expectedString) { foreach (JsonCommentHandling commentHandling in Enum.GetValues(typeof(JsonCommentHandling))) { var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = commentHandling }); var json = new Utf8JsonReader(sequence, false, state); while (json.Read()) { // Check if the TokenType is a primitive "value", i.e. String, Number, True, False, and Null Assert.True(json.TokenType >= JsonTokenType.String && json.TokenType <= JsonTokenType.Null); Assert.Equal(expectedString, Encoding.UTF8.GetString(json.HasValueSequence ? json.ValueSequence.ToArray() : json.ValueSpan.ToArray())); } Assert.Equal(json.BytesConsumed, json.CurrentState.BytesConsumed); } }
public static void TestingGetComment(string jsonData, string expected) { byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonData); var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = JsonCommentHandling.Allow }); var reader = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state); Assert.True(reader.Read()); Assert.Equal(JsonTokenType.StartObject, reader.TokenType); Assert.True(reader.Read()); Assert.Equal(JsonTokenType.Comment, reader.TokenType); Assert.Equal(expected, reader.GetComment()); Assert.True(reader.Read()); Assert.Equal(JsonTokenType.EndObject, reader.TokenType); Assert.False(reader.Read()); }
public static void SkipSingleLineCommentMultiSpanTest(string expected) { string jsonData = "{" + expected + "}"; byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonData); ReadOnlySequence <byte> sequence = JsonTestHelper.GetSequence(dataUtf8, 1); for (int i = 0; i < jsonData.Length; i++) { var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = JsonCommentHandling.Skip }); var json = new Utf8JsonReader(sequence.Slice(0, i), isFinalBlock: false, state); VerifyReadLoop(ref json, null); json = new Utf8JsonReader(sequence.Slice(state.BytesConsumed), isFinalBlock: true, state); VerifyReadLoop(ref json, null); } }
private static void ReadCore( ref JsonReaderState readerState, Type returnType, bool isFinalBlock, ReadOnlySequence <byte> buffer, JsonSerializerOptions options, ref ReadObjectState current, ref List <ReadObjectState> previous, ref int arrayIndex) { Utf8JsonReader reader = new Utf8JsonReader(buffer, isFinalBlock, readerState); ReadCore( options, ref reader, ref current, ref previous, ref arrayIndex); readerState = reader.CurrentState; }
private static void ReadCore( ref JsonReaderState readerState, bool isFinalBlock, byte[] buffer, int bytesToRead, JsonSerializerOptions options, ref ReadObjectState current, ref List <ReadObjectState> previous, ref int arrayIndex) { Utf8JsonReader reader = new Utf8JsonReader(new ReadOnlySpan <byte>(buffer, 0, bytesToRead), isFinalBlock, readerState); ReadCore( options, ref reader, ref current, ref previous, ref arrayIndex); readerState = reader.CurrentState; }
public static void TestingGetStringInvalidUTF16(string jsonString) { byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonString); foreach (JsonCommentHandling commentHandling in Enum.GetValues(typeof(JsonCommentHandling))) { var state = new JsonReaderState(options: new JsonReaderOptions { CommentHandling = commentHandling }); var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state); Assert.True(json.Read()); Assert.Equal(JsonTokenType.String, json.TokenType); try { string val = json.GetString(); Assert.True(false, "Expected InvalidOperationException when trying to get string value for invalid UTF-16 JSON text."); } catch (InvalidOperationException) { } } }
private bool ReadValueOrEndArray() { switch (buffer.Data[buffer.Offset]) { case ']': state = stack.Pop(); token = new TypedToken(JsonTokenType.EndArray); buffer.Forward(false); return true; } return ReadValue(JsonReaderState.ValueInArray); }
private bool ReadValue(JsonReaderState nextState) { switch (buffer.Data[buffer.Offset]) { case '{': return ReadStartObject(nextState); case '[': return ReadStartArray(nextState); case '"': return ReadTextOrProperty(JsonTokenType.Text, nextState); case 't': return ReadTrue(nextState); case 'f': return ReadFalse(nextState); case 'n': return ReadNull(nextState); } return ReadNumber(nextState); }
private bool ReadTextOrProperty(JsonTokenType textOrProperty, JsonReaderState nextState) { token = TextParser.Parse(buffer, textOrProperty); state = nextState; return true; }
private bool ReadNumber(JsonReaderState nextState) { token = NumberParser.Parse(buffer); state = nextState; return true; }
private bool ReadStartArray(JsonReaderState nextState) { stack.Push(nextState); state = JsonReaderState.BeginArray; token = new TypedToken(JsonTokenType.OpenArray); buffer.Forward(false); return true; }
private bool ReadEndArray() { state = stack.Pop(); token = new TypedToken(JsonTokenType.EndArray); buffer.Forward(false); return true; }
private bool ReadFalse(JsonReaderState nextState) { if (Skip("false")) { state = nextState; token = new TypedToken(JsonTokenType.False); return true; } throw new JsonReaderSyntaxException(); }
private bool ReadNull(JsonReaderState nextState) { if (Skip("null")) { state = nextState; token = new TypedToken(JsonTokenType.Null); return true; } throw new JsonReaderSyntaxException(); }