/// <summary>
/// Parses out a JSON array AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON array AST node</returns>
private static ArrayNode ParseArrayNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
List <JsonTextNavigatorNode> items = new List <JsonTextNavigatorNode>();
ReadOnlyMemory <byte> bufferedArrayStartToken = jsonTextReader.GetBufferedJsonToken().Memory;
if (!MemoryMarshal.TryGetArray(bufferedArrayStartToken, out ArraySegment <byte> startArrayArraySegment))
{
throw new InvalidOperationException($"Failed to get {nameof(startArrayArraySegment)}.");
}
// consume the begin array token
jsonTextReader.Read();
while (jsonTextReader.CurrentTokenType != JsonTokenType.EndArray)
{
items.Add(Parser.ParseNode(jsonTextReader));
}
ReadOnlyMemory <byte> bufferedArrayEndToken = jsonTextReader.GetBufferedJsonToken().Memory;
if (!MemoryMarshal.TryGetArray(bufferedArrayEndToken, out ArraySegment <byte> endArrayArraySegment))
{
throw new InvalidOperationException($"Failed to get {nameof(endArrayArraySegment)}.");
}
// consume the end array token
jsonTextReader.Read();
ReadOnlyMemory <byte> bufferedRawArray = startArrayArraySegment.Array;
bufferedRawArray = bufferedRawArray.Slice(start: startArrayArraySegment.Offset, length: endArrayArraySegment.Offset - startArrayArraySegment.Offset + 1);
return(ArrayNode.Create(items, bufferedRawArray));
}
private static BinaryNode ParseBinaryNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
ReadOnlyMemory <byte> bufferedRawJsonToken = jsonTextReader.GetBufferedJsonToken().Memory;
BinaryNode node = BinaryNode.Create(bufferedRawJsonToken);
// advance the reader forward.
jsonTextReader.Read();
return(node);
}
/// <summary>
/// Parses out a JSON number AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON number AST node</returns>
private static NumberNode ParseNumberNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
ReadOnlyMemory <byte> bufferedRawJsonToken = jsonTextReader.GetBufferedJsonToken().Memory;
NumberNode numberNode = NumberNode.Create(bufferedRawJsonToken);
// consume the number from the reader
jsonTextReader.Read();
return(numberNode);
}
/// <summary>
/// Parses out a JSON string AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON string AST node</returns>
private static StringNode ParseStringNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
Utf8Memory bufferedStringValue = jsonTextReader.GetBufferedJsonToken();
StringNode stringNode = StringNode.Create(bufferedStringValue);
// consume the string from the reader
jsonTextReader.Read();
return(stringNode);
}
/// <summary>
/// Parses out a JSON property AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON property AST node</returns>
private static ObjectProperty ParsePropertyNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
ReadOnlyMemory <byte> bufferedRawJsonToken = jsonTextReader.GetBufferedJsonToken().Memory;
FieldNameNode fieldName = FieldNameNode.Create(Utf8Memory.UnsafeCreateNoValidation(bufferedRawJsonToken));
// Consume the fieldname from the jsonreader
jsonTextReader.Read();
JsonTextNavigatorNode value = Parser.ParseNode(jsonTextReader);
return(new ObjectProperty(fieldName, value));
}
private static FloatNode ParseFloatNode(
IJsonTextReaderPrivateImplementation jsonTextReader,
JsonTokenType jsonTokenType)
{
ReadOnlyMemory <byte> bufferedRawJsonToken = jsonTextReader.GetBufferedJsonToken().Memory;
FloatNode floatNode = jsonTokenType switch
{
JsonTokenType.Float32 => Float32Node.Create(bufferedRawJsonToken),
JsonTokenType.Float64 => Float64Node.Create(bufferedRawJsonToken),
_ => throw new ArgumentException($"Unknown {nameof(JsonTokenType)}: {jsonTokenType}"),
};
// consume the float from the reader
jsonTextReader.Read();
return(floatNode);
}
/// <summary>
/// Gets the root node of a JSON AST from a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>The root node of a JSON AST from a jsonTextReader.</returns>
public static JsonTextNavigatorNode Parse(IJsonTextReaderPrivateImplementation jsonTextReader)
{
// Read past the json object not started state.
if (!jsonTextReader.Read())
{
throw new InvalidOperationException("Failed to read from reader");
}
JsonTextNavigatorNode rootNode = Parser.ParseNode(jsonTextReader);
// Make sure that we are at the end of the file.
if (jsonTextReader.Read())
{
throw new ArgumentException("Did not fully parse json");
}
return(rootNode);
}
private static IntegerNode ParseIntegerNode(
IJsonTextReaderPrivateImplementation jsonTextReader,
JsonTokenType jsonTokenType)
{
ReadOnlyMemory <byte> bufferedRawJsonToken = jsonTextReader.GetBufferedJsonToken().Memory;
IntegerNode integerNode = jsonTokenType switch
{
JsonTokenType.Int8 => Int8Node.Create(bufferedRawJsonToken),
JsonTokenType.Int16 => Int16Node.Create(bufferedRawJsonToken),
JsonTokenType.Int32 => Int32Node.Create(bufferedRawJsonToken),
JsonTokenType.Int64 => Int64Node.Create(bufferedRawJsonToken),
JsonTokenType.UInt32 => UInt32Node.Create(bufferedRawJsonToken),
_ => throw new ArgumentException($"Unknown {nameof(JsonTokenType)}: {jsonTokenType}"),
};
// consume the integer from the reader
jsonTextReader.Read();
return(integerNode);
}
/// <summary>
/// Parses out a JSON object AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON object AST node</returns>
private static ObjectNode ParseObjectNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
List <ObjectProperty> properties = new List <ObjectProperty>();
ReadOnlyMemory <byte> bufferedObjectStartToken = jsonTextReader.GetBufferedJsonToken().Memory;
if (!MemoryMarshal.TryGetArray(bufferedObjectStartToken, out ArraySegment <byte> startObjectArraySegment))
{
throw new InvalidOperationException($"Failed to get {nameof(startObjectArraySegment)}.");
}
// consume the begin object token
jsonTextReader.Read();
while (jsonTextReader.CurrentTokenType != JsonTokenType.EndObject)
{
ObjectProperty property = Parser.ParsePropertyNode(jsonTextReader);
properties.Add(property);
}
ReadOnlyMemory <byte> bufferedObjectEndToken = jsonTextReader.GetBufferedJsonToken().Memory;
if (!MemoryMarshal.TryGetArray(bufferedObjectEndToken, out ArraySegment <byte> endObjectArraySegment))
{
throw new InvalidOperationException($"Failed to get {nameof(endObjectArraySegment)}.");
}
// consume the end object token
jsonTextReader.Read();
ReadOnlyMemory <byte> bufferedRawObject = startObjectArraySegment.Array;
bufferedRawObject = bufferedRawObject.Slice(start: startObjectArraySegment.Offset, length: endObjectArraySegment.Offset - startObjectArraySegment.Offset + 1);
return(ObjectNode.Create(properties, bufferedRawObject));
}
/// <summary>
/// Parses out a JSON AST node with a jsonTextReader.
/// </summary>
/// <param name="jsonTextReader">The reader to use as a lexer / tokenizer</param>
/// <returns>JSON AST node (type determined by the reader)</returns>
private static JsonTextNavigatorNode ParseNode(IJsonTextReaderPrivateImplementation jsonTextReader)
{
JsonTextNavigatorNode node;
switch (jsonTextReader.CurrentTokenType)
{
case JsonTokenType.BeginArray:
node = Parser.ParseArrayNode(jsonTextReader);
break;
case JsonTokenType.BeginObject:
node = Parser.ParseObjectNode(jsonTextReader);
break;
case JsonTokenType.String:
node = Parser.ParseStringNode(jsonTextReader);
break;
case JsonTokenType.Number:
node = Parser.ParseNumberNode(jsonTextReader);
break;
case JsonTokenType.Float32:
case JsonTokenType.Float64:
node = Parser.ParseFloatNode(jsonTextReader, jsonTextReader.CurrentTokenType);
break;
case JsonTokenType.Int8:
case JsonTokenType.Int16:
case JsonTokenType.Int32:
case JsonTokenType.Int64:
case JsonTokenType.UInt32:
node = Parser.ParseIntegerNode(jsonTextReader, jsonTextReader.CurrentTokenType);
break;
case JsonTokenType.True:
node = Parser.ParseTrueNode(jsonTextReader);
break;
case JsonTokenType.False:
node = Parser.ParseFalseNode(jsonTextReader);
break;
case JsonTokenType.Null:
node = Parser.ParseNullNode(jsonTextReader);
break;
case JsonTokenType.Guid:
node = Parser.ParseGuidNode(jsonTextReader);
break;
case JsonTokenType.Binary:
node = Parser.ParseBinaryNode(jsonTextReader);
break;
default:
throw new JsonInvalidTokenException();
}
return(node);
}
