internal static JsonTokenInfo[] GetTokensFromObjectNode(IJsonNavigatorNode node, IJsonNavigator navigator, bool performCorrectnessCheck)
        {
            // Get the tokens through .GetObjectProperties
            List <JsonTokenInfo>         tokensFromGetProperties = new List <JsonTokenInfo>();
            IEnumerable <ObjectProperty> properties = navigator.GetObjectProperties(node);

            tokensFromGetProperties.Add(JsonTokenInfo.ObjectStart());
            foreach (ObjectProperty property in properties)
            {
                string fieldname = navigator.GetStringValue(property.NameNode);
                tokensFromGetProperties.Add(JsonTokenInfo.FieldName(fieldname));
                tokensFromGetProperties.AddRange(JsonNavigatorTests.GetTokensFromNode(property.ValueNode, navigator, performCorrectnessCheck));
            }
            tokensFromGetProperties.Add(JsonTokenInfo.ObjectEnd());

            if (performCorrectnessCheck)
            {
                // Get the tokens again through .TryGetObjectProperty
                List <JsonTokenInfo> tokensFromTryGetProperty = new List <JsonTokenInfo>();

                tokensFromTryGetProperty.Add(JsonTokenInfo.ObjectStart());
                foreach (ObjectProperty objectProperty in properties)
                {
                    ObjectProperty propertyFromTryGetProperty;
                    string         fieldname = navigator.GetStringValue(objectProperty.NameNode);
                    if (navigator.TryGetObjectProperty(node, fieldname, out propertyFromTryGetProperty))
                    {
                        tokensFromTryGetProperty.Add(JsonTokenInfo.FieldName(fieldname));
                        tokensFromTryGetProperty.AddRange(JsonNavigatorTests.GetTokensFromNode(propertyFromTryGetProperty.ValueNode, navigator, performCorrectnessCheck));
                    }
                    else
                    {
                        Assert.Fail($"Failed to get object property with name: {fieldname}");
                    }
                }
                tokensFromTryGetProperty.Add(JsonTokenInfo.ObjectEnd());
                Assert.AreEqual(properties.Count(), navigator.GetObjectPropertyCount(node));
                Assert.IsTrue(tokensFromGetProperties.SequenceEqual(tokensFromTryGetProperty));
            }

            return(tokensFromGetProperties.ToArray());
        }
示例#2
0
            static void Navigate(IJsonNavigator navigator, IJsonNavigatorNode node)
            {
                switch (navigator.GetNodeType(node))
                {
                case JsonNodeType.Null:
                case JsonNodeType.False:
                case JsonNodeType.True:
                case JsonNodeType.Number64:
                case JsonNodeType.Int8:
                case JsonNodeType.Int16:
                case JsonNodeType.Int32:
                case JsonNodeType.Int64:
                case JsonNodeType.UInt32:
                case JsonNodeType.Float32:
                case JsonNodeType.Float64:
                case JsonNodeType.String:
                case JsonNodeType.Binary:
                case JsonNodeType.Guid:
                    break;

                case JsonNodeType.Array:
                    foreach (IJsonNavigatorNode arrayItem in navigator.GetArrayItems(node))
                    {
                        Navigate(navigator, arrayItem);
                    }
                    break;

                case JsonNodeType.Object:
                    foreach (ObjectProperty objectProperty in navigator.GetObjectProperties(node))
                    {
                        IJsonNavigatorNode nameNode  = objectProperty.NameNode;
                        IJsonNavigatorNode valueNode = objectProperty.ValueNode;
                        Navigate(navigator, valueNode);
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException($"Unknown {nameof(JsonNodeType)}: '{navigator.GetNodeType(node)}.'");
                }
            }
示例#3
0
        /// <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:
                    double 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}");
                }
            }
        }