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 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);