public void Expect(JsonTokenType type1, JsonTokenType type2)
{
if (this.TokenType != type1 && this.TokenType != type2)
{
throw LiteException.UnexpectedToken(this.Token);
}
}
public EscapingToken(JsonTokenType type, char[] data, int offset, int length)
{
this.type = type;
this.data = data;
this.offset = offset;
this.length = length;
}
public JsonReader(string str)
{
_str = new Utf8String(str);
_index = 0;
_insideObject = 0;
_insideArray = 0;
TokenType = JsonTokenType.Start;
}
public JsonReader(Utf8String str)
{
_str = str;
_index = 0;
_insideObject = 0;
_insideArray = 0;
TokenType = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonUnexpectedTokenException"/> class.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="text">The text.</param>
/// <param name="expectedTypes">The expected types.</param>
public JsonUnexpectedTokenException(JsonTokenType token, string text, IEnumerable<JsonTokenType> expectedTypes, string expectedText = null)
: base(string.Format("Unexpected token '{0}'{1}", text, expectedTypes.ToErrorString(expectedText)))
{
this.Data.Add("Token", token);
this.Data.Add("Text", text);
this.Data.Add("ExpectedTypes", expectedTypes.ToArray());
this.Data.Add("ExpectedText", expectedText);
}
public JsonReader(string str)
{
_str = new Utf8String(str);
_index = 0;
_insideObject = 0;
_insideArray = 0;
TokenType = 0;
_length = _str.Length;
}
public JsonReader(string str)
{
_str = new Utf8String(str).Trim();
_index = 0;
_insideObject = 0;
_insideArray = 0;
TokenType = 0;
_jsonStartIsObject = (byte)_str[0] == '{';
}
public JsonReader(Utf8String str)
{
_str = str;
_index = 0;
TokenType = JsonTokenType.ObjectStart;
_insideArray = false;
_mapping = new Dictionary<Utf8CodeUnit, JsonTokenType>
{
{CurlyOpenString, JsonTokenType.ObjectStart},
{CurlyCloseString, JsonTokenType.ObjectEnd},
{SquareOpenString, JsonTokenType.ArrayStart},
{SquareCloseString, JsonTokenType.ArrayEnd},
{QuoteString, JsonTokenType.PropertyName}
};
}
public JsonParser(byte[] buffer, int lengthOfJson)
{
_buffer = buffer;
_insideObject = 0;
_insideArray = 0;
TokenType = 0;
_index = 0;
_end = lengthOfJson;
var nextByte = _buffer[_index];
while (isWhiteSpace(nextByte) || nextByte == 0)
{
_index++;
nextByte = _buffer[_index];
}
_dbIndex = _end + 1;
_jsonStartIsObject = _buffer[_index] == '{';
}
public abstract void ReadEnumerable(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader);
internal static bool IsStructEnd(JsonTokenType token)
{
return token == JsonTokenType.EndArray || token == JsonTokenType.EndObject;
}
private void Push(JsonTokenType value)
{
_stack.Add(value);
_top++;
}
private void MoveToNextTokenType()
{
SkipWhitespace();
var nextByte = _values[_valuesIndex];
switch (_tokenType) {
case JsonTokenType.ObjectStart:
if (nextByte != '}') {
_tokenType = JsonTokenType.Property;
return;
}
break;
case JsonTokenType.ObjectEnd:
if (nextByte == ',') {
_valuesIndex++;
if (_insideObject == _insideArray) {
_tokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
_tokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayStart:
if (nextByte != ']') {
_tokenType = JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayEnd:
if (nextByte == ',') {
_valuesIndex++;
if (_insideObject == _insideArray) {
_tokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
_tokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.Property:
if (nextByte == ',') {
_valuesIndex++;
return;
}
break;
case JsonTokenType.Value:
if (nextByte == ',') {
_valuesIndex++;
return;
}
break;
}
_valuesIndex++;
switch (nextByte) {
case (byte)'{':
_insideObject++;
_tokenType = JsonTokenType.ObjectStart;
return;
case (byte)'}':
_insideObject--;
_tokenType = JsonTokenType.ObjectEnd;
return;
case (byte)'[':
_insideArray++;
_tokenType = JsonTokenType.ArrayStart;
return;
case (byte)']':
_insideArray--;
_tokenType = JsonTokenType.ArrayEnd;
return;
default:
throw new FormatException("Unable to get next token type. Check json format.");
}
}
// Returns true if the TokenType is a primitive "value", i.e. String, Number, True, False, and Null // Otherwise, return false. public static bool IsTokenTypePrimitive(JsonTokenType tokenType) => (tokenType - JsonTokenType.String) <= (JsonTokenType.Null - JsonTokenType.String);
private void MoveToNextTokenType()
{
SkipEmpty();
var nextByte = (byte) _str[_index];
switch (TokenType)
{
case JsonTokenType.ObjectStart:
if (nextByte != '}')
{
TokenType = JsonTokenType.Property;
return;
}
break;
case JsonTokenType.ObjectEnd:
if (nextByte == ',')
{
_index++;
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayStart:
if (nextByte != ']')
{
TokenType = JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayEnd:
if (nextByte == ',')
{
_index++;
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.Property:
if (nextByte == ',')
{
_index++;
return;
}
break;
case JsonTokenType.Value:
if (nextByte == ',')
{
_index++;
return;
}
break;
}
switch (nextByte)
{
case (byte) '{':
_index++;
_insideObject++;
TokenType = JsonTokenType.ObjectStart;
return;
case (byte) '}':
_index++;
_insideObject--;
TokenType = JsonTokenType.ObjectEnd;
return;
case (byte) '[':
_index++;
_insideArray++;
TokenType = JsonTokenType.ArrayStart;
return;
case (byte) ']':
_index++;
_insideArray--;
TokenType = JsonTokenType.ArrayEnd;
return;
default:
throw new FormatException("Unable to get next token type. Check json format.");
}
}
public static InvalidOperationException GetInvalidOperationException(ExceptionResource resource, int currentDepth, byte token, JsonTokenType tokenType)
{
string message = GetResourceString(resource, currentDepth, token, tokenType);
return(new InvalidOperationException(message));
}
private void WriteEnd(JsonTokenType type)
{
switch (type)
{
case JsonTokenType.Object:
WriteEndObject();
break;
case JsonTokenType.Array:
WriteEndArray();
break;
case JsonTokenType.Constructor:
WriteEndConstructor();
break;
default:
throw new JsonWriterException("Unexpected type when writing end: " + type);
}
}
private static InvalidOperationException GetInvalidOperationException(string message, JsonTokenType tokenType)
{
return(new InvalidOperationException(SR.Format(SR.InvalidCast, tokenType, message)));
}
public static void ThrowInvalidOperationException(ExceptionResource resource, int currentDepth = default, byte token = default, JsonTokenType tokenType = default)
{
throw GetInvalidOperationException(resource, currentDepth, token, tokenType);
}
public static InvalidOperationException GetInvalidOperationException_ExpectedString(JsonTokenType tokenType)
{
return(GetInvalidOperationException("string", tokenType));
}
public static InvalidOperationException GetInvalidOperationException_ExpectedBoolean(JsonTokenType tokenType)
{
return(GetInvalidOperationException("boolean", tokenType));
}
public static InvalidOperationException GetInvalidOperationException_ExpectedNumber(JsonTokenType tokenType)
{
return(GetInvalidOperationException("number", tokenType));
}
/// <summary>
/// Performs any post write operations needed after the specified
/// token has been written to the underlying stream.
/// </summary>
/// <param name="token">The token written.</param>
protected virtual void PostWrite(JsonTokenType token)
{
this.CurrentToken = token;
switch(token) {
case JsonTokenType.BeginArray:
this.StructStack.Push(JsonStructType.Array);
break;
case JsonTokenType.BeginObject:
this.StructStack.Push(JsonStructType.Object);
break;
case JsonTokenType.EndArray:
Debug.Assert(this.CurrentStruct == JsonStructType.Array);
this.StructStack.Pop();
break;
case JsonTokenType.EndObject:
Debug.Assert(this.CurrentStruct == JsonStructType.Object);
this.StructStack.Pop();
break;
default:
break;
}
}
// constructors
/// <summary>
/// Initializes a new instance of the StringJsonToken class.
/// </summary>
/// <param name="type">The token type.</param>
/// <param name="lexeme">The lexeme.</param>
/// <param name="value">The String value.</param>
public StringJsonToken(JsonTokenType type, string lexeme, string value)
: base(type, lexeme)
{
this.value = value;
}
private void Assert(bool cond, JsonTokenType nextToken)
{
if(!cond) {
StringBuilder sb = new StringBuilder(150);
sb.Append("Attempted state transition would lead to an invalid JSON output.");
sb.Append(Environment.NewLine);
sb.Append("Current Token:\t").Append(this.CurrentToken.ToString());
sb.Append(Environment.NewLine);
sb.Append("Attempted Token:\t").Append(nextToken.ToString());
sb.Append(Environment.NewLine);
sb.Append("Current Struct:\t").Append(this.CurrentStruct.ToString());
throw new InvalidOperationException(sb.ToString());
}
}
/// <summary>
/// Parses a string representing JSON document into <see cref="JsonNode"/>.
/// </summary>
/// <param name="json">JSON to parse.</param>
/// <param name="options">Options to control the parsing behavior.</param>
/// <returns><see cref="JsonNode"/> representation of <paramref name="json"/>.</returns>
public static JsonNode Parse(string json, JsonNodeOptions options = default)
{
Utf8JsonReader reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json), options.GetReaderOptions());
var currentNodes = new Stack <KeyValuePair <string, JsonNode> >(); // nodes currently being created
JsonNode toReturn = null;
while (reader.Read())
{
JsonTokenType tokenType = reader.TokenType;
currentNodes.TryPeek(out KeyValuePair <string, JsonNode> currentPair);
void AddNewPair(JsonNode jsonNode, bool keepInCurrentNodes = false)
{
KeyValuePair <string, JsonNode> newProperty;
if (currentPair.Value == null)
{
// If previous token was property name,
// it was added to stack with not null name and null value,
// otherwise, this is first JsonNode added
if (currentPair.Key != null)
{
// Create as property, keep name, replace null with new JsonNode:
currentNodes.Pop();
newProperty = new KeyValuePair <string, JsonNode>(currentPair.Key, jsonNode);
}
else
{
// Add first JsonNode:
newProperty = new KeyValuePair <string, JsonNode>(null, jsonNode);
}
}
else
{
// Create as value:
newProperty = new KeyValuePair <string, JsonNode>(null, jsonNode);
}
if (keepInCurrentNodes)
{
// If after adding property, it should be kept in currentNodes, it must be JsonObject or JsonArray
Debug.Assert(jsonNode.ValueKind == JsonValueKind.Object || jsonNode.ValueKind == JsonValueKind.Array);
currentNodes.Push(newProperty);
}
else
{
AddToParent(newProperty, ref currentNodes, ref toReturn, options.DuplicatePropertyNameHandling);
}
}
switch (tokenType)
{
case JsonTokenType.StartObject:
AddNewPair(new JsonObject(), true);
break;
case JsonTokenType.EndObject:
Debug.Assert(currentPair.Value is JsonObject);
currentNodes.Pop();
AddToParent(currentPair, ref currentNodes, ref toReturn, options.DuplicatePropertyNameHandling);
break;
case JsonTokenType.StartArray:
AddNewPair(new JsonArray(), true);
break;
case JsonTokenType.EndArray:
Debug.Assert(currentPair.Value is JsonArray);
currentNodes.Pop();
AddToParent(currentPair, ref currentNodes, ref toReturn, options.DuplicatePropertyNameHandling);
break;
case JsonTokenType.PropertyName:
currentNodes.Push(new KeyValuePair <string, JsonNode>(reader.GetString(), null));
break;
case JsonTokenType.Number:
AddNewPair(new JsonNumber(JsonHelpers.Utf8GetString(reader.ValueSpan)));
break;
case JsonTokenType.String:
AddNewPair(new JsonString(reader.GetString()));
break;
case JsonTokenType.True:
AddNewPair(new JsonBoolean(true));
break;
case JsonTokenType.False:
AddNewPair(new JsonBoolean(false));
break;
case JsonTokenType.Null:
AddNewPair(new JsonNull());
break;
}
}
Debug.Assert(toReturn != null);
return(toReturn);
}
private static string GetResourceString(ExceptionResource resource, int currentDepth, byte token, JsonTokenType tokenType)
{
string message = "";
switch (resource)
{
case ExceptionResource.MismatchedObjectArray:
message = SR.Format(SR.MismatchedObjectArray, token);
break;
case ExceptionResource.DepthTooLarge:
message = SR.Format(SR.DepthTooLarge, currentDepth & JsonConstants.RemoveFlagsBitMask, JsonConstants.MaxWriterDepth);
break;
case ExceptionResource.CannotStartObjectArrayWithoutProperty:
message = SR.Format(SR.CannotStartObjectArrayWithoutProperty, tokenType);
break;
case ExceptionResource.CannotStartObjectArrayAfterPrimitiveOrClose:
message = SR.Format(SR.CannotStartObjectArrayAfterPrimitiveOrClose, tokenType);
break;
case ExceptionResource.CannotWriteValueWithinObject:
message = SR.Format(SR.CannotWriteValueWithinObject, tokenType);
break;
case ExceptionResource.CannotWritePropertyWithinArray:
message = SR.Format(SR.CannotWritePropertyWithinArray, tokenType);
break;
case ExceptionResource.CannotWriteValueAfterPrimitive:
message = SR.Format(SR.CannotWriteValueAfterPrimitive, tokenType);
break;
default:
Debug.Fail($"The ExceptionResource enum value: {resource} is not part of the switch. Add the appropriate case and exception message.");
break;
}
return(message);
}
public static bool IsInRangeInclusive(JsonTokenType value, JsonTokenType lowerBound, JsonTokenType upperBound) => (value - lowerBound) <= (upperBound - lowerBound);
public JsonObject Parse(ReadOnlySpan <byte> utf8Json, BufferPool pool = null)
{
_pool = pool;
if (_pool == null)
{
_pool = ManagedBufferPool.Shared;
}
_scratchManager = _pool.Rent(utf8Json.Length * 4);
_scratchMemory = _scratchManager.Memory;
int dbLength = _scratchMemory.Length / 2;
_db = _scratchMemory.Slice(0, dbLength);
_stack = new TwoStacks(_scratchMemory.Slice(dbLength));
_values = utf8Json;
_insideObject = 0;
_insideArray = 0;
_tokenType = 0;
_valuesIndex = 0;
_dbIndex = 0;
_jsonStartIsObject = false;
SkipWhitespace();
_jsonStartIsObject = _values[_valuesIndex] == '{';
int arrayItemsCount = 0;
int numberOfRowsForMembers = 0;
while (Read())
{
var tokenType = _tokenType;
switch (tokenType)
{
case JsonTokenType.ObjectStart:
AppendDbRow(JsonObject.JsonValueType.Object, _valuesIndex);
while (!_stack.TryPushObject(numberOfRowsForMembers))
{
ResizeDb();
}
numberOfRowsForMembers = 0;
break;
case JsonTokenType.ObjectEnd:
_db.Span.Slice(FindLocation(_stack.ObjectStackCount - 1, true)).Write <int>(numberOfRowsForMembers);
numberOfRowsForMembers += _stack.PopObject();
break;
case JsonTokenType.ArrayStart:
AppendDbRow(JsonObject.JsonValueType.Array, _valuesIndex);
while (!_stack.TryPushArray(arrayItemsCount))
{
ResizeDb();
}
arrayItemsCount = 0;
break;
case JsonTokenType.ArrayEnd:
_db.Span.Slice(FindLocation(_stack.ArrayStackCount - 1, false)).Write <int>(arrayItemsCount);
arrayItemsCount += _stack.PopArray();
break;
case JsonTokenType.Property:
ParsePropertyName();
ParseValue();
numberOfRowsForMembers++;
numberOfRowsForMembers++;
break;
case JsonTokenType.Value:
ParseValue();
arrayItemsCount++;
numberOfRowsForMembers++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var result = new JsonObject(_values, _db.Slice(0, _dbIndex).Span, _pool, _scratchManager);
_scratchManager = null;
return(result);
}
private void MoveToNextTokenType()
{
SkipWhitespace();
var nextByte = _values[_valuesIndex];
switch (_tokenType)
{
case JsonTokenType.ObjectStart:
if (nextByte != '}')
{
_tokenType = JsonTokenType.Property;
return;
}
break;
case JsonTokenType.ObjectEnd:
if (nextByte == ',')
{
_valuesIndex++;
if (_insideObject == _insideArray)
{
_tokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
_tokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayStart:
if (nextByte != ']')
{
_tokenType = JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayEnd:
if (nextByte == ',')
{
_valuesIndex++;
if (_insideObject == _insideArray)
{
_tokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
_tokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.Property:
if (nextByte == ',')
{
_valuesIndex++;
return;
}
break;
case JsonTokenType.Value:
if (nextByte == ',')
{
_valuesIndex++;
return;
}
break;
}
_valuesIndex++;
switch (nextByte)
{
case (byte)'{':
_insideObject++;
_tokenType = JsonTokenType.ObjectStart;
return;
case (byte)'}':
_insideObject--;
_tokenType = JsonTokenType.ObjectEnd;
return;
case (byte)'[':
_insideArray++;
_tokenType = JsonTokenType.ArrayStart;
return;
case (byte)']':
_insideArray--;
_tokenType = JsonTokenType.ArrayEnd;
return;
default:
throw new FormatException("Unable to get next token type. Check json format.");
}
}
private static JsonTokenType GetStringValueType(JsonTokenType? current)
{
if (current == null)
return JsonTokenType.String;
switch (current.Value)
{
case JsonTokenType.Comment:
case JsonTokenType.String:
case JsonTokenType.Raw:
return current.Value;
default:
return JsonTokenType.String;
}
}
public abstract void ReadEnumerable(JsonTokenType tokenType, JsonSerializerOptions options, ref ReadStack state, ref Utf8JsonReader reader);
/// <summary>
/// Reads the next token from the reader.
/// </summary>
/// <returns>True if a token was read, else false.</returns>
public override bool Read()
{
bool read = this.jsonReader.Read();
if (!read)
{
this.SetToken(JsonToken.None);
return(false);
}
JsonTokenType jsonTokenType = this.jsonReader.CurrentTokenType;
JsonToken newtonsoftToken;
object value;
switch (jsonTokenType)
{
case JsonTokenType.BeginArray:
newtonsoftToken = JsonToken.StartArray;
value = CosmosDBToNewtonsoftReader.Null;
break;
case JsonTokenType.EndArray:
newtonsoftToken = JsonToken.EndArray;
value = CosmosDBToNewtonsoftReader.Null;
break;
case JsonTokenType.BeginObject:
newtonsoftToken = JsonToken.StartObject;
value = CosmosDBToNewtonsoftReader.Null;
break;
case JsonTokenType.EndObject:
newtonsoftToken = JsonToken.EndObject;
value = CosmosDBToNewtonsoftReader.Null;
break;
case JsonTokenType.String:
newtonsoftToken = JsonToken.String;
value = this.jsonReader.GetStringValue();
break;
case JsonTokenType.Number:
Number64 number64Value = this.jsonReader.GetNumberValue();
if (number64Value.IsInteger)
{
value = Number64.ToLong(number64Value);
newtonsoftToken = JsonToken.Integer;
}
else
{
value = Number64.ToDouble(number64Value);
newtonsoftToken = JsonToken.Float;
}
break;
case JsonTokenType.True:
newtonsoftToken = JsonToken.Boolean;
value = CosmosDBToNewtonsoftReader.True;
break;
case JsonTokenType.False:
newtonsoftToken = JsonToken.Boolean;
value = CosmosDBToNewtonsoftReader.False;
break;
case JsonTokenType.Null:
newtonsoftToken = JsonToken.Null;
value = CosmosDBToNewtonsoftReader.Null;
break;
case JsonTokenType.FieldName:
newtonsoftToken = JsonToken.PropertyName;
value = this.jsonReader.GetStringValue();
break;
default:
throw new ArgumentException($"Unexpected jsonTokenType: {jsonTokenType}");
}
this.SetToken(newtonsoftToken, value);
return(read);
}
private void MoveToNextTokenType()
{
var nextByte = (byte)_str[_index];
while (isWhiteSpace(nextByte))
{
_index++;
nextByte = (byte)_str[_index];
}
switch (TokenType)
{
case JsonTokenType.ObjectStart:
if (nextByte != '}')
{
TokenType = JsonTokenType.Property;
return;
}
break;
case JsonTokenType.ObjectEnd:
if (nextByte == ',')
{
_index++;
if (_insideObject == _insideArray)
{
TokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayStart:
if (nextByte != ']')
{
TokenType = JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayEnd:
if (nextByte == ',')
{
_index++;
if (_insideObject == _insideArray)
{
TokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.Property:
if (nextByte == ',')
{
_index++;
return;
}
break;
case JsonTokenType.Value:
if (nextByte == ',')
{
_index++;
return;
}
break;
}
_index++;
switch (nextByte)
{
case (byte)'{':
_insideObject++;
TokenType = JsonTokenType.ObjectStart;
return;
case (byte)'}':
_insideObject--;
TokenType = JsonTokenType.ObjectEnd;
return;
case (byte)'[':
_insideArray++;
TokenType = JsonTokenType.ArrayStart;
return;
case (byte)']':
_insideArray--;
TokenType = JsonTokenType.ArrayEnd;
return;
default:
throw new FormatException("Unable to get next token type. Check json format.");
}
}
public JsonObject Parse(ReadOnlySpan<byte> utf8Json, BufferPool pool = null)
{
_pool = pool;
if (_pool == null) _pool = ManagedBufferPool.Shared;
_scratchManager = _pool.Rent(utf8Json.Length * 4);
_scratchMemory = _scratchManager.Memory;
int dbLength = _scratchMemory.Length / 2;
_db = _scratchMemory.Slice(0, dbLength);
_stack = new TwoStacks(_scratchMemory.Slice(dbLength));
_values = utf8Json;
_insideObject = 0;
_insideArray = 0;
_tokenType = 0;
_valuesIndex = 0;
_dbIndex = 0;
_jsonStartIsObject = false;
SkipWhitespace();
_jsonStartIsObject = _values[_valuesIndex] == '{';
int arrayItemsCount = 0;
int numberOfRowsForMembers = 0;
while (Read()) {
var tokenType = _tokenType;
switch (tokenType) {
case JsonTokenType.ObjectStart:
AppendDbRow(JsonObject.JsonValueType.Object, _valuesIndex);
while(!_stack.TryPushObject(numberOfRowsForMembers)) {
ResizeDb();
}
numberOfRowsForMembers = 0;
break;
case JsonTokenType.ObjectEnd:
_db.Span.Slice(FindLocation(_stack.ObjectStackCount - 1, true)).Write<int>(numberOfRowsForMembers);
numberOfRowsForMembers += _stack.PopObject();
break;
case JsonTokenType.ArrayStart:
AppendDbRow(JsonObject.JsonValueType.Array, _valuesIndex);
while (!_stack.TryPushArray(arrayItemsCount)) {
ResizeDb();
}
arrayItemsCount = 0;
break;
case JsonTokenType.ArrayEnd:
_db.Span.Slice(FindLocation(_stack.ArrayStackCount - 1, false)).Write<int>(arrayItemsCount);
arrayItemsCount += _stack.PopArray();
break;
case JsonTokenType.Property:
ParsePropertyName();
ParseValue();
numberOfRowsForMembers++;
numberOfRowsForMembers++;
break;
case JsonTokenType.Value:
ParseValue();
arrayItemsCount++;
numberOfRowsForMembers++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var result = new JsonObject(_values, _db.Slice(0, _dbIndex).Span, _pool, _scratchManager);
_scratchManager = null;
return result;
}
/// <summary>
/// Writes a json node to the internal buffer.
/// </summary>
/// <param name="jsonNavigator">The navigator to use to navigate the node</param>
/// <param name="jsonNavigatorNode">The node to write.</param>
public void WriteJsonNode(IJsonNavigator jsonNavigator, IJsonNavigatorNode jsonNavigatorNode)
{
if (jsonNavigator == null)
{
throw new ArgumentNullException($"{nameof(jsonNavigator)} can not be null");
}
if (jsonNavigatorNode == null)
{
throw new ArgumentNullException($"{nameof(jsonNavigatorNode)} can not be null");
}
// For now short circuit this to false until we figure out how to optimize this.
bool sameFormat = jsonNavigator.SerializationFormat == this.SerializationFormat && (this.SerializationFormat == JsonSerializationFormat.Binary || this.SerializationFormat == JsonSerializationFormat.HybridRow);
JsonNodeType jsonNodeType = jsonNavigator.GetNodeType(jsonNavigatorNode);
// See if we can write the node without looking at it's value
switch (jsonNodeType)
{
case JsonNodeType.Null:
this.WriteNullValue();
return;
case JsonNodeType.False:
this.WriteBoolValue(false);
return;
case JsonNodeType.True:
this.WriteBoolValue(true);
return;
}
// If the navigator has the same format as this writer then we try to retrieve the node raw JSON
IReadOnlyList <byte> bufferedRawJson;
if (sameFormat && jsonNavigator.TryGetBufferedRawJson(jsonNavigatorNode, out bufferedRawJson))
{
// Token type really doesn't make any difference other than whether this is a field name
JsonTokenType jsonTokenType = (jsonNodeType == JsonNodeType.FieldName ? JsonTokenType.FieldName : JsonTokenType.Null);
this.WriteRawJsonToken(jsonTokenType, bufferedRawJson);
}
else
{
// Either the formats did not match or we couldn't retrieve the buffered raw JSON
switch (jsonNodeType)
{
case JsonNodeType.Number:
Number64 numberValue = jsonNavigator.GetNumberValue(jsonNavigatorNode);
this.WriteNumberValue(numberValue);
break;
case JsonNodeType.String:
case JsonNodeType.FieldName:
bool fieldName = jsonNodeType == JsonNodeType.FieldName;
IReadOnlyList <byte> bufferedStringValue;
if (jsonNavigator.TryGetBufferedStringValue(jsonNavigatorNode, out bufferedStringValue))
{
if (fieldName)
{
this.WriteRawJsonToken(JsonTokenType.FieldName, bufferedStringValue);
}
else
{
this.WriteRawJsonToken(JsonTokenType.String, bufferedStringValue);
}
}
else
{
string value = jsonNavigator.GetStringValue(jsonNavigatorNode);
if (fieldName)
{
this.WriteFieldName(value);
}
else
{
this.WriteStringValue(value);
}
}
break;
case JsonNodeType.Int8:
{
sbyte number = jsonNavigator.GetInt8Value(jsonNavigatorNode);
this.WriteInt8Value(number);
break;
}
case JsonNodeType.Int16:
{
short number = jsonNavigator.GetInt16Value(jsonNavigatorNode);
this.WriteInt16Value(number);
break;
}
case JsonNodeType.Int32:
{
int number = jsonNavigator.GetInt32Value(jsonNavigatorNode);
this.WriteInt32Value(number);
break;
}
case JsonNodeType.Int64:
{
long number = jsonNavigator.GetInt64Value(jsonNavigatorNode);
this.WriteInt64Value(number);
break;
}
case JsonNodeType.UInt32:
{
uint number = jsonNavigator.GetUInt32Value(jsonNavigatorNode);
this.WriteUInt32Value(number);
break;
}
case JsonNodeType.Float32:
{
float number = jsonNavigator.GetFloat32Value(jsonNavigatorNode);
this.WriteFloat32Value(number);
break;
}
case JsonNodeType.Float64:
{
double number = jsonNavigator.GetFloat64Value(jsonNavigatorNode);
this.WriteFloat64Value(number);
break;
}
case JsonNodeType.Guid:
{
Guid number = jsonNavigator.GetGuidValue(jsonNavigatorNode);
this.WriteGuidValue(number);
break;
}
case JsonNodeType.Binary:
{
IReadOnlyList <byte> bufferedBinaryValue;
if (jsonNavigator.TryGetBufferedBinaryValue(jsonNavigatorNode, out bufferedBinaryValue))
{
this.WriteRawJsonToken(JsonTokenType.Binary, bufferedBinaryValue);
}
else
{
IReadOnlyList <byte> value = jsonNavigator.GetBinaryValue(jsonNavigatorNode);
this.WriteBinaryValue(value);
}
break;
}
case JsonNodeType.Array:
this.WriteArrayStart();
foreach (IJsonNavigatorNode arrayItem in jsonNavigator.GetArrayItems(jsonNavigatorNode))
{
this.WriteJsonNode(jsonNavigator, arrayItem);
}
this.WriteArrayEnd();
break;
case JsonNodeType.Object:
this.WriteObjectStart();
foreach (ObjectProperty objectProperty in jsonNavigator.GetObjectProperties(jsonNavigatorNode))
{
this.WriteJsonNode(jsonNavigator, objectProperty.NameNode);
this.WriteJsonNode(jsonNavigator, objectProperty.ValueNode);
}
this.WriteObjectEnd();
break;
default:
throw new ArgumentException($"Unexpected JsonNodeType: {jsonNodeType}");
}
}
}
private void GetNextTokenType()
{
if (!Read()) return;
SkipAll();
if (_str[_index] == ColonString)
{
_index++;
SkipAll();
if (!_mapping.TryGetValue(_str[_index], out TokenType))
{
TokenType = JsonTokenType.PropertyValueAsInt;
}
if (_str[_index] == QuoteString)
{
TokenType = JsonTokenType.PropertyValueAsString;
}
}
else
{
var nextToken = _str[_index];
var prevTokenType = TokenType;
if (!_mapping.TryGetValue(nextToken, out TokenType))
{
TokenType = JsonTokenType.PropertyValueAsInt;
}
if ((_insideArray || prevTokenType == JsonTokenType.ArrayStart) &&
TokenType == JsonTokenType.PropertyName)
{
TokenType = JsonTokenType.PropertyValueAsString;
}
}
if (TokenType == JsonTokenType.ArrayStart)
{
_insideArray = true;
}
else if (TokenType == JsonTokenType.ArrayEnd)
{
_insideArray = false;
}
}
internal bool TryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, ref ReadStack state, out T?value)
{
if (ClassType == ClassType.Value)
{
// A value converter should never be within a continuation.
Debug.Assert(!state.IsContinuation);
// For perf and converter simplicity, handle null here instead of forwarding to the converter.
if (reader.TokenType == JsonTokenType.Null && !HandleNull)
{
if (!CanBeNull)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(TypeToConvert);
}
value = default;
return(true);
}
#if !DEBUG
// For performance, only perform validation on internal converters on debug builds.
if (IsInternalConverter)
{
if (IsInternalConverterForNumberType && state.Current.NumberHandling != null)
{
value = ReadNumberWithCustomHandling(ref reader, state.Current.NumberHandling.Value);
}
else
{
value = Read(ref reader, typeToConvert, options);
}
}
else
#endif
{
JsonTokenType originalPropertyTokenType = reader.TokenType;
int originalPropertyDepth = reader.CurrentDepth;
long originalPropertyBytesConsumed = reader.BytesConsumed;
if (IsInternalConverterForNumberType && state.Current.NumberHandling != null)
{
value = ReadNumberWithCustomHandling(ref reader, state.Current.NumberHandling.Value);
}
else
{
value = Read(ref reader, typeToConvert, options);
}
VerifyRead(
originalPropertyTokenType,
originalPropertyDepth,
originalPropertyBytesConsumed,
isValueConverter: true,
ref reader);
}
if (CanBePolymorphic && options.ReferenceHandler != null)
{
// Edge case where we want to lookup for a reference when parsing into typeof(object)
// instead of return `value` as a JsonElement.
Debug.Assert(TypeToConvert == typeof(object));
Debug.Assert(value is JsonElement);
if (JsonSerializer.TryGetReferenceFromJsonElement(ref state, (JsonElement)(object)value, out object?referenceValue))
{
value = (T)referenceValue;
}
}
return(true);
}
bool success;
// Remember if we were a continuation here since Push() may affect IsContinuation.
bool wasContinuation = state.IsContinuation;
state.Push();
#if !DEBUG
// For performance, only perform validation on internal converters on debug builds.
if (IsInternalConverter)
{
if (reader.TokenType == JsonTokenType.Null && !HandleNull && !wasContinuation)
{
if (!CanBeNull)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(TypeToConvert);
}
// For perf and converter simplicity, handle null here instead of forwarding to the converter.
value = default;
success = true;
}
else
{
success = OnTryRead(ref reader, typeToConvert, options, ref state, out value);
}
}
else
#endif
{
if (!wasContinuation)
{
// For perf and converter simplicity, handle null here instead of forwarding to the converter.
if (reader.TokenType == JsonTokenType.Null && !HandleNull)
{
if (!CanBeNull)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(TypeToConvert);
}
value = default;
state.Pop(true);
return(true);
}
Debug.Assert(state.Current.OriginalTokenType == JsonTokenType.None);
state.Current.OriginalTokenType = reader.TokenType;
Debug.Assert(state.Current.OriginalDepth == 0);
state.Current.OriginalDepth = reader.CurrentDepth;
}
success = OnTryRead(ref reader, typeToConvert, options, ref state, out value);
if (success)
{
if (state.IsContinuation)
{
// The resumable converter did not forward to the next converter that previously returned false.
ThrowHelper.ThrowJsonException_SerializationConverterRead(this);
}
VerifyRead(
state.Current.OriginalTokenType,
state.Current.OriginalDepth,
bytesConsumed: 0,
isValueConverter: false,
ref reader);
// No need to clear state.Current.* since a stack pop will occur.
}
}
state.Pop(success);
return(success);
}
/// <summary>
/// Initialises a new instance of the JsonWriter class and specifies
/// the underlying <see cref="System.IO.TextWriter"/> and a value indicating
/// if the instance owns the specified TextWriter.
/// </summary>
/// <param name="writer">The underlying text writer.</param>
/// <param name="ownsWriter">True if this instance owns the specified TextWriter,
/// otherwise; false.</param>
public JsonWriter(TextWriter writer, bool ownsWriter)
{
if(writer == null)
throw new ArgumentNullException("writer");
_writer = writer;
_ownsWriter = ownsWriter;
_token = JsonTokenType.None;
_structStack = new Stack<JsonStructType>();
}
// constructors
/// <summary>
/// Initializes a new instance of the JsonToken class.
/// </summary>
/// <param name="type">The token type.</param>
/// <param name="lexeme">The lexeme.</param>
public JsonToken(JsonTokenType type, string lexeme)
{
_type = type;
_lexeme = lexeme;
}
internal static bool IsStructStart(JsonTokenType token)
{
return token == JsonTokenType.BeginArray || token == JsonTokenType.BeginObject;
}
// constructors
/// <summary>
/// Initializes a new instance of the StringJsonToken class.
/// </summary>
/// <param name="type">The token type.</param>
/// <param name="lexeme">The lexeme.</param>
/// <param name="value">The String value.</param>
public StringJsonToken(JsonTokenType type, string lexeme, string value)
: base(type, lexeme)
{
_value = value;
}
/// <summary>
/// Performs any assertions and / or write operations needed before the specified
/// token is written to the underlying stream.
/// </summary>
/// <param name="token">The next token to be written.</param>
protected virtual void PreWrite(JsonTokenType token)
{
switch(JsonWriter.TRANSITION_TABLE[(int)this.CurrentToken][(int)token]) {
case ST.SOK:
// void.
break;
case ST.ERR:
Assert(false, token);
break;
case ST.AIO:
Assert(this.CurrentStruct == JsonStructType.Object, token);
break;
case ST.AIA:
Assert(this.CurrentStruct == JsonStructType.Array, token);
break;
case ST.AIS:
Assert(this.CurrentStruct != JsonStructType.None, token);
break;
default:
Debug.Fail("JsonWriter::PreWrite - Unknown token.");
break;
}
// This is horrible but without increasing the complexity of the state
// table it is needed.
Assert(!(this.CurrentStruct == JsonStructType.Object && token != JsonTokenType.EndObject &&
this.CurrentToken != JsonTokenType.Name && token != JsonTokenType.Name), token);
// See if we should write a seperator.
if(!JsonWriter.IsStructEnd(token) && (JsonWriter.IsStructEnd(this.CurrentToken) ||
this.CurrentToken == JsonTokenType.Value))
this.Writer.Write(JsonWriter.ValueSeperator);
}
private static void GetOriginalValues(ref Utf8JsonReader reader, out JsonTokenType tokenType, out int depth, out long bytesConsumed)
{
tokenType = reader.TokenType;
depth = reader.CurrentDepth;
bytesConsumed = reader.BytesConsumed;
}
private void Push(JsonTokenType value)
{
_top++;
if (_stack.Count <= _top)
_stack.Add(value);
else
_stack[_top] = value;
}
protected abstract void OnReadEnumerable(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader);
private JsonToken GetCloseTokenForType(JsonTokenType type)
{
switch (type)
{
case JsonTokenType.Object:
return JsonToken.EndObject;
case JsonTokenType.Array:
return JsonToken.EndArray;
case JsonTokenType.Constructor:
return JsonToken.EndConstructor;
default:
throw new JsonWriterException("No close token for type: " + type);
}
}
private bool ReadSingleSegment()
{
bool retVal = false;
if (CurrentIndex >= (uint)_buffer.Length)
{
if (!_isSingleValue && _isFinalBlock)
{
if (TokenType != JsonTokenType.EndArray && TokenType != JsonTokenType.EndObject)
{
ThrowJsonReaderException(ref this, ExceptionResource.InvalidEndOfJson);
}
}
goto Done;
}
byte first = _buffer[CurrentIndex];
if (first <= JsonConstants.Space)
{
SkipWhiteSpace();
if (CurrentIndex >= (uint)_buffer.Length)
{
if (!_isSingleValue && _isFinalBlock)
{
if (TokenType != JsonTokenType.EndArray && TokenType != JsonTokenType.EndObject)
{
ThrowJsonReaderException(ref this, ExceptionResource.InvalidEndOfJson);
}
}
goto Done;
}
first = _buffer[CurrentIndex];
}
TokenStartIndex = CurrentIndex;
if (TokenType == JsonTokenType.None)
{
goto ReadFirstToken;
}
if (TokenType == JsonTokenType.StartObject)
{
if (first == JsonConstants.CloseBrace)
{
CurrentIndex++;
_position++;
EndObject();
}
else
{
if (first != JsonConstants.Quote)
{
ThrowJsonReaderException(ref this, ExceptionResource.ExpectedStartOfPropertyNotFound, first);
}
TokenStartIndex++;
int prevCurrentIndex = CurrentIndex;
int prevPosition = _position;
if (ConsumePropertyName())
{
return(true);
}
CurrentIndex = prevCurrentIndex;
TokenType = JsonTokenType.StartObject;
_position = prevPosition;
return(false);
}
}
else if (TokenType == JsonTokenType.StartArray)
{
if (first == JsonConstants.CloseBracket)
{
CurrentIndex++;
_position++;
EndArray();
}
else
{
return(ConsumeValue(first));
}
}
else if (TokenType == JsonTokenType.PropertyName)
{
return(ConsumeValue(first));
}
else
{
int prevCurrentIndex = CurrentIndex;
int prevPosition = _position;
JsonTokenType prevTokenType = TokenType;
if (ConsumeNextToken(first))
{
return(true);
}
CurrentIndex = prevCurrentIndex;
TokenType = prevTokenType;
_position = prevPosition;
return(false);
}
retVal = true;
Done:
return(retVal);
ReadFirstToken:
retVal = ReadFirstToken(first);
goto Done;
}
// constructors
/// <summary>
/// Initializes a new instance of the JsonToken class.
/// </summary>
/// <param name="type">The token type.</param>
/// <param name="lexeme">The lexeme.</param>
public JsonToken(JsonTokenType type, string lexeme)
{
this.type = type;
this.lexeme = lexeme;
}
private static readonly byte[] IndexKeyword = { 0x69, 0x6E, 0x64, 0x65, 0x78 }; // = index
/// <summary>
/// Parses FFprobe JSON output and returns a new <see cref="MediaInfo"/>
/// </summary>
/// <param name="data">JSON output</param>
/// <param name="file">The file the JSON output format is about</param>
/// <returns><see cref="MediaInfo"/> containing information from FFprobe output</returns>
public static MediaInfo Read(byte[] data, string file)
{
var json = new Utf8JsonReader(data, isFinalBlock: true, state: default);
var streams = new List <Dictionary <string, object> >();
var format = new Dictionary <string, object>();
var currentStream = -1;
var currentObject = JsonObjects.None;
string lastKey = null;
while (json.Read())
{
JsonTokenType tokenType = json.TokenType;
ReadOnlySpan <byte> valueSpan = json.ValueSpan;
switch (tokenType)
{
case JsonTokenType.StartObject:
case JsonTokenType.EndObject:
case JsonTokenType.Null:
case JsonTokenType.StartArray:
case JsonTokenType.EndArray:
break;
case JsonTokenType.PropertyName:
if (valueSpan.SequenceEqual(StreamsKeyword.AsSpan()))
{
currentObject = JsonObjects.Streams;
break;
}
if (valueSpan.SequenceEqual(FormatKeyword.AsSpan()))
{
currentObject = JsonObjects.Format;
break;
}
if (valueSpan.SequenceEqual(IndexKeyword.AsSpan()))
{
streams.Add(new Dictionary <string, object>());
currentStream++;
}
if (currentObject == JsonObjects.Streams)
{
lastKey = json.GetStringValue();
streams[currentStream].Add(lastKey, null);
}
else if (currentObject == JsonObjects.Format)
{
lastKey = json.GetStringValue();
format.Add(lastKey, null);
}
break;
case JsonTokenType.String:
if (currentObject == JsonObjects.Streams)
{
streams[currentStream][lastKey] = json.GetStringValue();
}
else if (currentObject == JsonObjects.Format)
{
format[lastKey] = json.GetStringValue();
}
break;
case JsonTokenType.Number:
if (!json.TryGetInt32Value(out int valueInteger))
{
#if DEBUG
System.Diagnostics.Trace.TraceWarning($"JSON number parse error: \"{lastKey}\" = {System.Text.Encoding.UTF8.GetString(valueSpan.ToArray())}, file = {file}");
#endif
break;
}
if (currentObject == JsonObjects.Streams)
{
streams[currentStream][lastKey] = valueInteger;
}
else if (currentObject == JsonObjects.Format)
{
format[lastKey] = valueInteger;
}
break;
case JsonTokenType.True:
case JsonTokenType.False:
bool valueBool = json.GetBooleanValue();
if (currentObject == JsonObjects.Streams)
{
streams[currentStream][lastKey] = valueBool;
}
else if (currentObject == JsonObjects.Format)
{
format[lastKey] = valueBool;
}
break;
default:
throw new ArgumentException();
}
}
var info = new MediaInfo {
Streams = new MediaInfo.StreamInfo[streams.Count]
};
if (format.ContainsKey("duration") && TimeSpan.TryParse((string)format["duration"], out var duration))
{
info.Duration = duration;
}
for (int i = 0; i < streams.Count; i++)
{
info.Streams[i] = new MediaInfo.StreamInfo();
if (streams[i].ContainsKey("bit_rate") && long.TryParse((string)streams[i]["bit_rate"], out var bitrate))
{
info.Streams[i].BitRate = bitrate;
}
if (streams[i].ContainsKey("width"))
{
info.Streams[i].Width = (int)streams[i]["width"];
}
if (streams[i].ContainsKey("height"))
{
info.Streams[i].Width = (int)streams[i]["height"];
}
if (streams[i].ContainsKey("codec_name"))
{
info.Streams[i].CodecName = (string)streams[i]["codec_name"];
}
if (streams[i].ContainsKey("codec_long_name"))
{
info.Streams[i].CodecLongName = (string)streams[i]["codec_long_name"];
}
if (streams[i].ContainsKey("codec_type"))
{
info.Streams[i].CodecType = (string)streams[i]["codec_type"];
}
if (streams[i].ContainsKey("channel_layout"))
{
info.Streams[i].ChannelLayout = (string)streams[i]["channel_layout"];
}
if (streams[i].ContainsKey("pix_fmt"))
{
info.Streams[i].PixelFormat = (string)streams[i]["pix_fmt"];
}
if (streams[i].ContainsKey("sample_rate") && int.TryParse((string)streams[i]["sample_rate"], out var sample_rate))
{
info.Streams[i].SampleRate = sample_rate;
}
if (streams[i].ContainsKey("index"))
{
info.Streams[i].Index = ((int)streams[i]["index"]).ToString();
}
if (streams[i].ContainsKey("r_frame_rate"))
{
var stringFrameRate = (string)streams[i]["r_frame_rate"];
if (stringFrameRate.Contains('/'))
{
var split = stringFrameRate.Split('/');
if (split.Length == 2 && int.TryParse(split[0], out var firstRate) && int.TryParse(split[1], out var secondRate))
{
info.Streams[i].FrameRate = (firstRate > 0 && secondRate > 0) ? firstRate / (float)secondRate : -1f;
}
}
}
}
return(info);
}
public static JsonToken Parse(JsonReaderBuffer buffer, JsonTokenType textOrProperty)
{
char character;
bool escaped = false;
int start = buffer.Offset + 1;
int length = 0;
Action forward = () =>
{
ForwardOrThrow(buffer, true);
length++;
};
ForwardOrThrow(buffer, true);
while (buffer.Data[buffer.Offset] != '"')
{
if (buffer.Data[buffer.Offset] != '\\')
{
forward();
continue;
}
escaped = true;
forward();
character = buffer.Data[buffer.Offset];
switch (character)
{
case 'n':
case 't':
case 'r':
case 'b':
case 'f':
case '/':
case '\\':
case '\"':
forward();
continue;
}
if (character != 'u')
throw new JsonReaderSyntaxException();
for (int i = 0; i < 4; i++)
{
forward();
character = buffer.Data[buffer.Offset];
if ('0' <= character && character <= '9')
continue;
if ('a' <= character && character <= 'f')
continue;
throw new JsonReaderSyntaxException();
}
forward();
continue;
}
buffer.Forward(true);
if (escaped)
return new EscapingToken(textOrProperty, buffer.Data, start, length);
return new DataToken(textOrProperty, buffer.Data, start, length);
}
internal int FindIndexOfFirstUnsetSizeOrLength(JsonTokenType lookupType)
{
Debug.Assert(lookupType == JsonTokenType.StartObject || lookupType == JsonTokenType.StartArray);
return(FindOpenElement(lookupType));
}
private void MoveToNextTokenType()
{
var nextByte = _buffer[_index];
while (isWhiteSpace(nextByte))
{
_index++;
nextByte = _buffer[_index];
}
switch (TokenType)
{
case JsonTokenType.ObjectStart:
if (nextByte != '}')
{
TokenType = JsonTokenType.Property;
return;
}
break;
case JsonTokenType.ObjectEnd:
if (nextByte == ',')
{
_index++;
if (_insideObject == _insideArray)
{
TokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayStart:
if (nextByte != ']')
{
TokenType = JsonTokenType.Value;
return;
}
break;
case JsonTokenType.ArrayEnd:
if (nextByte == ',')
{
_index++;
if (_insideObject == _insideArray)
{
TokenType = !_jsonStartIsObject ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
TokenType = _insideObject > _insideArray ? JsonTokenType.Property : JsonTokenType.Value;
return;
}
break;
case JsonTokenType.Property:
if (nextByte == ',')
{
_index++;
return;
}
break;
case JsonTokenType.Value:
if (nextByte == ',')
{
_index++;
return;
}
break;
}
_index++;
switch (nextByte)
{
case (byte)'{':
_insideObject++;
TokenType = JsonTokenType.ObjectStart;
return;
case (byte)'}':
_insideObject--;
TokenType = JsonTokenType.ObjectEnd;
return;
case (byte)'[':
_insideArray++;
TokenType = JsonTokenType.ArrayStart;
return;
case (byte)']':
_insideArray--;
TokenType = JsonTokenType.ArrayEnd;
return;
default:
throw new FormatException("Unable to get next token type. Check json format.");
}
}
/// <summary>
/// Writes the beginning of a JSON object.
/// </summary>
/// <exception cref="InvalidOperationException">
/// Thrown when the depth of the JSON has exceeded the maximum depth of 1000
/// OR if this would result in an invalid JSON to be written (while validation is enabled).
/// </exception>
public void WriteStartObject()
{
WriteStart(JsonConstants.OpenBrace);
_tokenType = JsonTokenType.StartObject;
}
internal JValue(object value, JsonTokenType type)
{
_value = value;
_valueType = type;
}
/// <summary>
/// Writes current token from a json reader to the internal buffer.
/// </summary>
/// <param name="jsonReader">The JsonReader to the get the current token from.</param>
public void WriteCurrentToken(IJsonReader jsonReader)
{
if (jsonReader == null)
{
throw new ArgumentNullException("jsonReader can not be null");
}
// For now we don't optimize for text, since the reader could be UTF-8 and the writer could be UTF-16.
// We need to add more enums for the different serialization formats.
bool sameFormat = jsonReader.SerializationFormat == this.SerializationFormat && (this.SerializationFormat == JsonSerializationFormat.Binary || this.SerializationFormat == JsonSerializationFormat.HybridRow);
JsonTokenType jsonTokenType = jsonReader.CurrentTokenType;
switch (jsonTokenType)
{
case JsonTokenType.NotStarted:
break;
case JsonTokenType.BeginArray:
this.WriteArrayStart();
break;
case JsonTokenType.EndArray:
this.WriteArrayEnd();
break;
case JsonTokenType.BeginObject:
this.WriteObjectStart();
break;
case JsonTokenType.EndObject:
this.WriteObjectEnd();
break;
case JsonTokenType.True:
this.WriteBoolValue(true);
break;
case JsonTokenType.False:
this.WriteBoolValue(false);
break;
case JsonTokenType.Null:
this.WriteNullValue();
break;
default:
{
if (sameFormat)
{
IReadOnlyList <byte> bufferedRawJson = jsonReader.GetBufferedRawJsonToken();
this.WriteRawJsonToken(jsonTokenType, bufferedRawJson);
}
else
{
switch (jsonTokenType)
{
case JsonTokenType.String:
case JsonTokenType.FieldName:
{
string value = jsonReader.GetStringValue();
if (jsonTokenType == JsonTokenType.FieldName)
{
this.WriteFieldName(value);
}
else
{
this.WriteStringValue(value);
}
break;
}
case JsonTokenType.Number:
{
Number64 value = jsonReader.GetNumberValue();
this.WriteNumberValue(value);
}
break;
case JsonTokenType.Int8:
{
sbyte value = jsonReader.GetInt8Value();
this.WriteInt8Value(value);
}
break;
case JsonTokenType.Int16:
{
short value = jsonReader.GetInt16Value();
this.WriteInt16Value(value);
}
break;
case JsonTokenType.Int32:
{
int value = jsonReader.GetInt32Value();
this.WriteInt32Value(value);
}
break;
case JsonTokenType.Int64:
{
long value = jsonReader.GetInt64Value();
this.WriteInt64Value(value);
}
break;
case JsonTokenType.UInt32:
{
uint value = jsonReader.GetUInt32Value();
this.WriteUInt32Value(value);
}
break;
case JsonTokenType.Float32:
{
float value = jsonReader.GetFloat32Value();
this.WriteFloat32Value(value);
}
break;
case JsonTokenType.Float64:
{
double value = jsonReader.GetFloat64Value();
this.WriteFloat64Value(value);
}
break;
case JsonTokenType.Guid:
{
Guid value = jsonReader.GetGuidValue();
this.WriteGuidValue(value);
}
break;
case JsonTokenType.Binary:
{
IReadOnlyList <byte> value = jsonReader.GetBinaryValue();
this.WriteBinaryValue(value);
}
break;
default:
throw new ArgumentException($"Unexpected JsonTokenType: {jsonTokenType}");
}
}
}
break;
}
}
private static JsonTokenType GetValueType(JsonTokenType? current, object value)
{
if (value == null)
return JsonTokenType.Null;
else if (value is string)
return GetStringValueType(current);
else if (value is long || value is int || value is short || value is sbyte
|| value is ulong || value is uint || value is ushort || value is byte)
return JsonTokenType.Integer;
else if (value is double || value is float || value is decimal)
return JsonTokenType.Float;
else if (value is DateTime)
return JsonTokenType.Date;
else if (value is DateTimeOffset)
return JsonTokenType.Date;
else if (value is bool)
return JsonTokenType.Boolean;
throw new ArgumentException("Could not determin JSON object type for type {0}.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
}
internal abstract void Read(JsonTokenType tokenType, JsonSerializerOptions options, ref ReadStack state, ref Utf8JsonReader reader);
/// <summary>
/// Writes the beginning of a JSON array.
/// </summary>
/// <exception cref="InvalidOperationException">
/// Thrown when the depth of the JSON has exceeded the maximum depth of 1000
/// OR if this would result in an invalid JSON to be written (while validation is enabled).
/// </exception>
public void WriteStartArray()
{
WriteStart(JsonConstants.OpenBracket);
_tokenType = JsonTokenType.StartArray;
}
/// <summary> /// Writes a raw json token to the internal buffer. /// </summary> /// <param name="jsonTokenType">The JsonTokenType of the rawJsonToken</param> /// <param name="rawJsonToken">The raw json token.</param> protected abstract void WriteRawJsonToken(JsonTokenType jsonTokenType, IReadOnlyList <byte> rawJsonToken);
