Beispiel #1
0
        internal static void MergeEnumerableContent(
            JContainer target,
            IEnumerable content,
            JsonMergeSettings settings)
        {
            switch (settings.MergeArrayHandling)
            {
            case MergeArrayHandling.Concat:
                IEnumerator enumerator1 = content.GetEnumerator();
                try {
                    while (enumerator1.MoveNext())
                    {
                        JToken current = (JToken)enumerator1.Current;
                        target.Add((object)current);
                    }

                    break;
                } finally {
                    (enumerator1 as IDisposable)?.Dispose();
                }

            case MergeArrayHandling.Union:
                Dictionary <JToken, bool> dictionary =
                    new Dictionary <JToken, bool>((IEqualityComparer <JToken>)JToken.EqualityComparer);
                foreach (JToken index in (IEnumerable <JToken>)target)
                {
                    dictionary[index] = true;
                }
                IEnumerator enumerator2 = content.GetEnumerator();
                try {
                    while (enumerator2.MoveNext())
                    {
                        JToken current = (JToken)enumerator2.Current;
                        if (!dictionary.ContainsKey(current))
                        {
                            dictionary[current] = true;
                            target.Add((object)current);
                        }
                    }

                    break;
                } finally {
                    (enumerator2 as IDisposable)?.Dispose();
                }

            case MergeArrayHandling.Replace:
                target.ClearItems();
                IEnumerator enumerator3 = content.GetEnumerator();
                try {
                    while (enumerator3.MoveNext())
                    {
                        JToken current = (JToken)enumerator3.Current;
                        target.Add((object)current);
                    }

                    break;
                } finally {
                    (enumerator3 as IDisposable)?.Dispose();
                }

            case MergeArrayHandling.Merge:
                int         num         = 0;
                IEnumerator enumerator4 = content.GetEnumerator();
                try {
                    while (enumerator4.MoveNext())
                    {
                        object current = enumerator4.Current;
                        if (num < target.Count)
                        {
                            JContainer jcontainer = target[(object)num] as JContainer;
                            if (jcontainer != null)
                            {
                                jcontainer.Merge(current, settings);
                            }
                            else if (current != null)
                            {
                                JToken fromContent = JContainer.CreateFromContent(current);
                                if (fromContent.Type != JTokenType.Null)
                                {
                                    target[(object)num] = fromContent;
                                }
                            }
                        }
                        else
                        {
                            target.Add(current);
                        }

                        ++num;
                    }

                    break;
                } finally {
                    (enumerator4 as IDisposable)?.Dispose();
                }

            default:
                throw new ArgumentOutOfRangeException(nameof(settings), "Unexpected merge array handling when merging JSON.");
            }
        }
Beispiel #2
0
        internal void ReadContentFrom(JsonReader r, JsonLoadSettings settings)
        {
            ValidationUtils.ArgumentNotNull((object)r, nameof(r));
            IJsonLineInfo lineInfo   = r as IJsonLineInfo;
            JContainer    jcontainer = this;

            do
            {
                if ((jcontainer as JProperty)?.Value != null)
                {
                    if (jcontainer == this)
                    {
                        break;
                    }
                    jcontainer = jcontainer.Parent;
                }

                switch (r.TokenType)
                {
                case JsonToken.None:
                    continue;

                case JsonToken.StartObject:
                    JObject jobject = new JObject();
                    jobject.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)jobject);
                    jcontainer = (JContainer)jobject;
                    goto case JsonToken.None;

                case JsonToken.StartArray:
                    JArray jarray = new JArray();
                    jarray.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)jarray);
                    jcontainer = (JContainer)jarray;
                    goto case JsonToken.None;

                case JsonToken.StartConstructor:
                    JConstructor jconstructor = new JConstructor(r.Value.ToString());
                    jconstructor.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)jconstructor);
                    jcontainer = (JContainer)jconstructor;
                    goto case JsonToken.None;

                case JsonToken.PropertyName:
                    string    name       = r.Value.ToString();
                    JProperty jproperty1 = new JProperty(name);
                    jproperty1.SetLineInfo(lineInfo, settings);
                    JProperty jproperty2 = ((JObject)jcontainer).Property(name);
                    if (jproperty2 == null)
                    {
                        jcontainer.Add((object)jproperty1);
                    }
                    else
                    {
                        jproperty2.Replace((JToken)jproperty1);
                    }
                    jcontainer = (JContainer)jproperty1;
                    goto case JsonToken.None;

                case JsonToken.Comment:
                    if (settings != null && settings.CommentHandling == CommentHandling.Load)
                    {
                        JValue comment = JValue.CreateComment(r.Value.ToString());
                        comment.SetLineInfo(lineInfo, settings);
                        jcontainer.Add((object)comment);
                        goto case JsonToken.None;
                    }
                    else
                    {
                        goto case JsonToken.None;
                    }

                case JsonToken.Integer:
                case JsonToken.Float:
                case JsonToken.String:
                case JsonToken.Boolean:
                case JsonToken.Date:
                case JsonToken.Bytes:
                    JValue jvalue1 = new JValue(r.Value);
                    jvalue1.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)jvalue1);
                    goto case JsonToken.None;

                case JsonToken.Null:
                    JValue jvalue2 = JValue.CreateNull();
                    jvalue2.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)jvalue2);
                    goto case JsonToken.None;

                case JsonToken.Undefined:
                    JValue undefined = JValue.CreateUndefined();
                    undefined.SetLineInfo(lineInfo, settings);
                    jcontainer.Add((object)undefined);
                    goto case JsonToken.None;

                case JsonToken.EndObject:
                    if (jcontainer == this)
                    {
                        return;
                    }
                    jcontainer = jcontainer.Parent;
                    goto case JsonToken.None;

                case JsonToken.EndArray:
                    if (jcontainer == this)
                    {
                        return;
                    }
                    jcontainer = jcontainer.Parent;
                    goto case JsonToken.None;

                case JsonToken.EndConstructor:
                    if (jcontainer == this)
                    {
                        return;
                    }
                    jcontainer = jcontainer.Parent;
                    goto case JsonToken.None;

                default:
                    throw new InvalidOperationException(
                              "The JsonReader should not be on a token of type {0}.".FormatWith(
                                  (IFormatProvider)CultureInfo.InvariantCulture, (object)r.TokenType));
                }
            } while (r.Read());
        }