Code Coverage Statistics for Source File

Newtonsoft.Json\Linq\JContainer.cs

Symbol Coverage: 96.77% (390 of 403)

Branch Coverage: 92.92% (223 of 240)

Cyclomatic Complexity Avg: 2.03 Max:21

Code Lines: 376

Symbol Coverage Trend

View:


#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Newtonsoft.Json.Utilities;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.ComponentModel;
using System.Collections.Specialized;
#if !SILVERLIGHT
using Newtonsoft.Json.Linq.ComponentModel;
#endif

namespace Newtonsoft.Json.Linq
{
  /// <summary>
  /// Represents a token that can contain other tokens.
  /// </summary>
  public abstract class JContainer : JToken, IList<JToken>
#if !SILVERLIGHT
    , ITypedList, IBindingList
#else
    , IList, INotifyCollectionChanged
#endif
  {
#if !SILVERLIGHT
    /// <summary>
    /// Occurs when the list changes or an item in the list changes.
    /// </summary>
    public event ListChangedEventHandler ListChanged;

    /// <summary>
    /// Occurs before an item is added to the collection.
    /// </summary>
    public event AddingNewEventHandler AddingNew;
#else
    /// <summary>
    /// Occurs when the items list of the collection has changed, or the collection is reset.
    /// </summary>
    public event NotifyCollectionChangedEventHandler CollectionChanged;
#endif

    private JToken _content;
    private object _syncRoot;
    private bool _busy;

    internal JToken Content
    {
      get { return _content; }
      set { _content = value; }
    }

    internal JContainer()
    {
    }

    internal JContainer(JContainer other)
    {
      ValidationUtils.ArgumentNotNull(other, "c");

      JToken content = other.Last;
      if (content != null)
      {
        do
        {
          content = content._next;
          Add(content.CloneToken());
        }
        while (content != other.Last);
      }
    }

    internal void CheckReentrancy()
    {
      if (_busy)
        throw new InvalidOperationException("Cannot change {0} during a collection change event.".FormatWith(CultureInfo.InvariantCulture, GetType()));
    }

 #if !SILVERLIGHT
    /// <summary>
    /// Raises the <see cref="AddingNew"/> event.
    /// </summary>
    /// <param name="e">The <see cref="AddingNewEventArgs"/> instance containing the event data.</param>
    protected virtual void OnAddingNew(AddingNewEventArgs e)
    {
      AddingNewEventHandler handler = AddingNew;
      if (handler != null)
        handler(this, e);
    }

    /// <summary>
    /// Raises the <see cref="ListChanged"/> event.
    /// </summary>
    /// <param name="e">The <see cref="ListChangedEventArgs"/> instance containing the event data.</param>
    protected virtual void OnListChanged(ListChangedEventArgs e)
    {
      ListChangedEventHandler handler = ListChanged;

      if (handler != null)
      {
        _busy = true;
        try
        {
          handler(this, e);
        }
        finally
        {
          _busy = false;
        }
      }
    }
#else
    /// <summary>
    /// Raises the <see cref="CollectionChanged"/> event.
    /// </summary>
    /// <param name="e">The <see cref="NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
      NotifyCollectionChangedEventHandler handler = CollectionChanged;

      if (handler != null)
      {
        _busy = true;
        try
        {
          handler(this, e);
        }
        finally
        {
          _busy = false;
        }
      }
    }
#endif

    /// <summary>
    /// Gets a value indicating whether this token has childen tokens.
    /// </summary>
    /// <value>
    /// 	<c>true</c> if this token has child values; otherwise, <c>false</c>.
    /// </value>
    public override bool HasValues
    {
      get { return (_content != null); }
    }

    internal bool ContentsEqual(JContainer container)
    {
      JToken t1 = First;
      JToken t2 = container.First;

      if (t1 == t2)
        return true;

      do
      {
        if (t1 == null && t2 == null)
          return true;

        if (t1 != null && t2 != null && t1.DeepEquals(t2))
        {
          t1 = (t1 != Last) ? t1.Next : null;
          t2 = (t2 != container.Last) ? t2.Next : null;
        }
        else
        {
          return false;
        }
      }
      while (true);
    }

    /// <summary>
    /// Get the first child token of this token.
    /// </summary>
    /// <value>
    /// A <see cref="JToken"/> containing the first child token of the <see cref="JToken"/>.
    /// </value>
    public override JToken First
    {
      get
      {
        if (Last == null)
          return null;

        return Last._next;
      }
    }

    /// <summary>
    /// Get the last child token of this token.
    /// </summary>
    /// <value>
    /// A <see cref="JToken"/> containing the last child token of the <see cref="JToken"/>.
    /// </value>
    public override JToken Last
    {
      [DebuggerStepThrough]
      get { return _content; }
    }

    /// <summary>
    /// Returns a collection of the child tokens of this token, in document order.
    /// </summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing the child tokens of this <see cref="JToken"/>, in document order.
    /// </returns>
    public override JEnumerable<JToken> Children()
    {
      return new JEnumerable<JToken>(ChildrenInternal());
    }

    private IEnumerable<JToken> ChildrenInternal()
    {
      JToken first = First;
      JToken current = first;
      if (current == null)
        yield break;

      do
      {
        yield return current;
      }
      while ((current = current.Next) != null);
    }

    /// <summary>
    /// Returns a collection of the child values of this token, in document order.
    /// </summary>
    /// <typeparam name="T">The type to convert the values to.</typeparam>
    /// <returns>
    /// A <see cref="IEnumerable{T}"/> containing the child values of this <see cref="JToken"/>, in document order.
    /// </returns>
    public override IEnumerable<T> Values<T>()
    {
      return Children().Convert<JToken, T>();
    }

    /// <summary>
    /// Returns a collection of the descendant tokens for this token in document order.
    /// </summary>
    /// <returns>An <see cref="IEnumerable{JToken}"/> containing the descendant tokens of the <see cref="JToken"/>.</returns>
    public IEnumerable<JToken> Descendants()
    {
      foreach (JToken o in Children())
      {
        yield return o;
        JContainer c = o as JContainer;
        if (c != null)
        {
          foreach (JToken d in c.Descendants())
          {
            yield return d;
          }
        }
      }
    }

    internal bool IsMultiContent(object content)
    {
      return (content is IEnumerable && !(content is string) && !(content is JToken) && !(content is byte[]));
    }

    internal virtual void AddItem(bool isLast, JToken previous, JToken item)
    {
      CheckReentrancy();

      ValidateToken(item, null);

      item = EnsureParentToken(item);

      JToken next = (previous != null) ? previous._next : item;

      item.Parent = this;
      item.Next = next;

      if (previous != null)
        previous.Next = item;

      if (isLast || previous == null)
        _content = item;

#if !SILVERLIGHT
      if (ListChanged != null)
        OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, IndexOfItem(item)));
#else
      if (CollectionChanged != null)
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, IndexOfItem(item)));
#endif
    }

    internal JToken EnsureParentToken(JToken item)
    {
      if (item.Parent != null)
      {
        item = item.CloneToken();
      }
      else
      {
        // check whether attempting to add a token to itself
        JContainer parent = this;
        while (parent.Parent != null)
        {
          parent = parent.Parent;
        }
        if (item == parent)
        {
          item = item.CloneToken();
        }
      }
      return item;
    }

    internal void AddInternal(bool isLast, JToken previous, object content)
    {
      if (IsMultiContent(content))
      {
        IEnumerable enumerable = (IEnumerable) content;

        JToken multiPrevious = previous;
        foreach (object c in enumerable)
        {
          AddInternal(isLast, multiPrevious, c);
          multiPrevious = (multiPrevious != null) ? multiPrevious._next : Last;
        }
      }
      else
      {
        JToken item = CreateFromContent(content);

        AddItem(isLast, previous, item);
      }
    }

    internal int IndexOfItem(JToken item)
    {
      int index = 0;
      foreach (JToken token in Children())
      {
        if (token == item)
          return index;

        index++;
      }

      return -1;
    }

    internal virtual void InsertItem(int index, JToken item)
    {
      if (index == 0)
      {
        AddFirst(item);
      }
      else
      {
        JToken token = GetItem(index);
        AddInternal(false, token.Previous, item);
      }
    }

    internal virtual void RemoveItemAt(int index)
    {
      if (index < 0)
        throw new ArgumentOutOfRangeException("index", "index is less than 0.");

      CheckReentrancy();

      int currentIndex = 0;
      foreach (JToken token in Children())
      {
        if (index == currentIndex)
        {
          token.Remove();

#if !SILVERLIGHT
          OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
#else
          OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, token, index));
#endif

          return;
        }

        currentIndex++;
      }

      throw new ArgumentOutOfRangeException("index", "index is equal to or greater than Count.");
    }

    internal virtual bool RemoveItem(JToken item)
    {
      if (item == null || item.Parent != this)
        return false;

      CheckReentrancy();

      JToken content = _content;

      int itemIndex = 0;
      while (content._next != item)
      {
        itemIndex++;
        content = content._next;
      }
      if (content == item)
      {
        // token is containers last child
        _content = null;
      }
      else
      {
        if (_content == item)
        {
          _content = content;
        }
        content._next = item._next;
      }
      item.Parent = null;
      item.Next = null;

#if !SILVERLIGHT
      OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, itemIndex));
#else
      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, itemIndex));
#endif

      return true;
    }

    internal virtual JToken GetItem(int index)
    {
      return Children().ElementAt(index);
    }

    internal virtual void SetItem(int index, JToken item)
    {
      CheckReentrancy();

      JToken token = GetItem(index);
      token.Replace(item);

#if !SILVERLIGHT
      OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
#else
      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, token, index));
#endif
    }

    internal virtual void ClearItems()
    {
      CheckReentrancy();

      while (_content != null)
      {
        JToken o = _content;

        JToken next = o._next;
        if (o != _content || next != o._next)
          throw new InvalidOperationException("This operation was corrupted by external code.");

        if (next != o)
          o._next = next._next;
        else
          _content = null;

        next.Parent = null;
        next._next = null;
      }

#if !SILVERLIGHT
      OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
#else
      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
#endif
    }

    internal virtual void ReplaceItem(JToken existing, JToken replacement)
    {
      if (existing == null || existing.Parent != this)
        return;

      if (IsTokenUnchanged(existing, replacement))
        return;

      CheckReentrancy();

      replacement = EnsureParentToken(replacement);

      ValidateToken(replacement, existing);

      JToken content = _content;

      int itemIndex = 0;
      while (content._next != existing)
      {
        itemIndex++;
        content = content._next;
      }

      if (content == existing)
      {
        // token is containers last child
        _content = replacement;
        replacement._next = replacement;
      }
      else
      {
        if (_content == existing)
        {
          _content = replacement;
        }
        content._next = replacement;
        replacement._next = existing._next;
      }

      replacement.Parent = this;

      existing.Parent = null;
      existing.Next = null;

#if !SILVERLIGHT
      OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, itemIndex));
#else
      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, replacement, existing, itemIndex));
#endif
    }

    internal virtual bool ContainsItem(JToken item)
    {
      return (IndexOfItem(item) != -1);
    }

    internal virtual void CopyItemsTo(Array array, int arrayIndex)
    {
      if (array == null)
        throw new ArgumentNullException("array");
      if (arrayIndex < 0)
        throw new ArgumentOutOfRangeException("arrayIndex", "arrayIndex is less than 0.");
      if (arrayIndex >= array.Length)
        throw new ArgumentException("arrayIndex is equal to or greater than the length of array.");
      if (CountItems() > array.Length - arrayIndex)
        throw new ArgumentException("The number of elements in the source JObject is greater than the available space from arrayIndex to the end of the destination array.");

      int index = 0;
      foreach (JToken token in Children())
      {
        array.SetValue(token, arrayIndex + index);
        index++;
      }
    }

    internal virtual int CountItems()
    {
      return Children().Count();
    }

    internal static bool IsTokenUnchanged(JToken currentValue, JToken newValue)
    {
      JValue v1 = currentValue as JValue;
      if (v1 != null)
      {
        // null will get turned into a JValue of type null
        if (v1.Type == JTokenType.Null && newValue == null)
          return true;

        return v1.Equals(newValue);
      }

      return false;
    }

    internal virtual void ValidateToken(JToken o, JToken existing)
    {
      ValidationUtils.ArgumentNotNull(o, "o");

      if (o.Type == JTokenType.Property)
        throw new ArgumentException("Can not add {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, o.GetType(), GetType()));
    }

    /// <summary>
    /// Adds the specified content as children of this <see cref="JToken"/>.
    /// </summary>
    /// <param name="content">The content to be added.</param>
    public void Add(object content)
    {
      AddInternal(true, Last, content);
    }

    /// <summary>
    /// Adds the specified content as the first children of this <see cref="JToken"/>.
    /// </summary>
    /// <param name="content">The content to be added.</param>
    public void AddFirst(object content)
    {
      AddInternal(false, Last, content);
    }

    internal JToken CreateFromContent(object content)
    {
      if (content is JToken)
        return (JToken)content;
      
      return new JValue(content);
    }

    /// <summary>
    /// Creates an <see cref="JsonWriter"/> that can be used to add tokens to the <see cref="JToken"/>.
    /// </summary>
    /// <returns>An <see cref="JsonWriter"/> that is ready to have content written to it.</returns>
    public JsonWriter CreateWriter()
    {
      return new JTokenWriter(this);
    }

    /// <summary>
    /// Replaces the children nodes of this token with the specified content.
    /// </summary>
    /// <param name="content">The content.</param>
    public void ReplaceAll(object content)
    {
      ClearItems();
      Add(content);
    }

    /// <summary>
    /// Removes the child nodes from this token.
    /// </summary>
    public void RemoveAll()
    {
      ClearItems();
    }

    internal void ReadContentFrom(JsonReader r)
    {
      ValidationUtils.ArgumentNotNull(r, "r");
      IJsonLineInfo lineInfo = r as IJsonLineInfo;

      JContainer parent = this;

      do
      {
        if (parent is JProperty && ((JProperty)parent).Value != null)
        {
          if (parent == this)
            return;

          parent = parent.Parent;
        }

        switch (r.TokenType)
        {
          case JsonToken.None:
            // new reader. move to actual content
            break;
          case JsonToken.StartArray:
            JArray a = new JArray();
            a.SetLineInfo(lineInfo);
            parent.Add(a);
            parent = a;
            break;

          case JsonToken.EndArray:
            if (parent == this)
              return;

            parent = parent.Parent;
            break;
          case JsonToken.StartObject:
            JObject o = new JObject();
            o.SetLineInfo(lineInfo);
            parent.Add(o);
            parent = o;
            break;
          case JsonToken.EndObject:
            if (parent == this)
              return;

            parent = parent.Parent;
            break;
          case JsonToken.StartConstructor:
            JConstructor constructor = new JConstructor(r.Value.ToString());
            constructor.SetLineInfo(constructor);
            parent.Add(constructor);
            parent = constructor;
            break;
          case JsonToken.EndConstructor:
            if (parent == this)
              return;

            parent = parent.Parent;
            break;
          case JsonToken.String:
          case JsonToken.Integer:
          case JsonToken.Float:
          case JsonToken.Date:
          case JsonToken.Boolean:
          case JsonToken.Bytes:
            JValue v = new JValue(r.Value);
            v.SetLineInfo(lineInfo);
            parent.Add(v);
            break;
          case JsonToken.Comment:
            v = JValue.CreateComment(r.Value.ToString());
            v.SetLineInfo(lineInfo);
            parent.Add(v);
            break;
          case JsonToken.Null:
            v = new JValue(null, JTokenType.Null);
            v.SetLineInfo(lineInfo);
            parent.Add(v);
            break;
          case JsonToken.Undefined:
            v = new JValue(null, JTokenType.Undefined);
            v.SetLineInfo(lineInfo);
            parent.Add(v);
            break;
          case JsonToken.PropertyName:
            string propertyName = r.Value.ToString();
            JProperty property = new JProperty(propertyName);
            property.SetLineInfo(lineInfo);
            JObject parentObject = (JObject) parent;
            // handle multiple properties with the same name in JSON
            JProperty existingPropertyWithName = parentObject.Property(propertyName);
            if (existingPropertyWithName == null)
              parent.Add(property);
            else
              existingPropertyWithName.Replace(property);
            parent = property;
            break;
          default:
            throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".FormatWith(CultureInfo.InvariantCulture, r.TokenType));
        }
      }
      while (r.Read());
    }

    internal int ContentsHashCode()
    {
      int hashCode = 0;
      foreach (JToken item in Children())
      {
        hashCode ^= item.GetDeepHashCode();
      }
      return hashCode;
    }

#if !SILVERLIGHT
    string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
    {
      return string.Empty;
    }

    PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
    {
      JObject o = First as JObject;
      if (o != null)
      {
        // explicitly use constructor because compact framework has no provider
        JTypeDescriptor descriptor = new JTypeDescriptor(o);
        return descriptor.GetProperties();
      }

      return null;
    }
#endif

    #region IList<JToken> Members

    int IList<JToken>.IndexOf(JToken item)
    {
      return IndexOfItem(item);
    }

    void IList<JToken>.Insert(int index, JToken item)
    {
      InsertItem(index, item);
    }

    void IList<JToken>.RemoveAt(int index)
    {
      RemoveItemAt(index);
    }

    JToken IList<JToken>.this[int index]
    {
      get { return GetItem(index); }
      set { SetItem(index, value); }
    }

    #endregion

    #region ICollection<JToken> Members

    void ICollection<JToken>.Add(JToken item)
    {
      Add(item);
    }

    void ICollection<JToken>.Clear()
    {
      ClearItems();
    }

    bool ICollection<JToken>.Contains(JToken item)
    {
      return ContainsItem(item);
    }

    void ICollection<JToken>.CopyTo(JToken[] array, int arrayIndex)
    {
      CopyItemsTo(array, arrayIndex);
    }

    int ICollection<JToken>.Count
    {
      get { return CountItems(); }
    }

    bool ICollection<JToken>.IsReadOnly
    {
      get { return false; }
    }

    bool ICollection<JToken>.Remove(JToken item)
    {
      return RemoveItem(item);
    }

    #endregion

    private JToken EnsureValue(object value)
    {
      if (value == null)
        return null;

      if (value is JToken)
        return (JToken) value;

      throw new ArgumentException("Argument is not a JToken.");
    }

    #region IList Members

    int IList.Add(object value)
    {
      Add(EnsureValue(value));
      return CountItems() - 1;
    }

    void IList.Clear()
    {
      ClearItems();
    }

    bool IList.Contains(object value)
    {
      return ContainsItem(EnsureValue(value));
    }

    int IList.IndexOf(object value)
    {
      return IndexOfItem(EnsureValue(value));
    }

    void IList.Insert(int index, object value)
    {
      InsertItem(index, EnsureValue(value));
    }

    bool IList.IsFixedSize
    {
      get { return false; }
    }

    bool IList.IsReadOnly
    {
      get { return false; }
    }

    void IList.Remove(object value)
    {
      RemoveItem(EnsureValue(value));
    }

    void IList.RemoveAt(int index)
    {
      RemoveItemAt(index);
    }

    object IList.this[int index]
    {
      get { return GetItem(index); }
      set { SetItem(index, EnsureValue(value)); }
    }

    #endregion

    #region ICollection Members

    void ICollection.CopyTo(Array array, int index)
    {
      CopyItemsTo(array, index);
    }

    int ICollection.Count
    {
      get { return CountItems(); }
    }

    bool ICollection.IsSynchronized
    {
      get { return false; }
    }

    object ICollection.SyncRoot
    {
      get
      {
        if (_syncRoot == null)
          Interlocked.CompareExchange(ref _syncRoot, new object(), null);

        return _syncRoot;
      }

    }

    #endregion

    #region IBindingList Members

#if !SILVERLIGHT
    void IBindingList.AddIndex(PropertyDescriptor property)
    {
    }

    object IBindingList.AddNew()
    {
      AddingNewEventArgs args = new AddingNewEventArgs();
      OnAddingNew(args);

      if (args.NewObject == null)
        throw new Exception("Could not determine new value to add to '{0}'.".FormatWith(CultureInfo.InvariantCulture, GetType()));

      if (!(args.NewObject is JToken))
        throw new Exception("New item to be added to collection must be compatible with {0}.".FormatWith(CultureInfo.InvariantCulture, typeof (JToken)));

      JToken newItem = (JToken)args.NewObject;
      Add(newItem);

      return newItem;
    }

    bool IBindingList.AllowEdit
    {
      get { return true; }
    }

    bool IBindingList.AllowNew
    {
      get { return true; }
    }

    bool IBindingList.AllowRemove
    {
      get { return true; }
    }

    void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
    {
      throw new NotSupportedException();
    }

    int IBindingList.Find(PropertyDescriptor property, object key)
    {
      throw new NotSupportedException();
    }

    bool IBindingList.IsSorted
    {
      get { return false; }
    }

    void IBindingList.RemoveIndex(PropertyDescriptor property)
    {
    }

    void IBindingList.RemoveSort()
    {
      throw new NotSupportedException();
    }

    ListSortDirection IBindingList.SortDirection
    {
      get { return ListSortDirection.Ascending; }
    }

    PropertyDescriptor IBindingList.SortProperty
    {
      get { return null; }
    }

    bool IBindingList.SupportsChangeNotification
    {
      get { return true; }
    }

    bool IBindingList.SupportsSearching
    {
      get { return false; }
    }

    bool IBindingList.SupportsSorting
    {
      get { return false; }
    }
#endif

    #endregion
  }
}

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		using System;
27		using System.Collections.Generic;
28		using System.Linq;
29		using System.Threading;
30		using Newtonsoft.Json.Utilities;
31		using System.Collections;
32		using System.Diagnostics;
33		using System.Globalization;
34		using System.ComponentModel;
35		using System.Collections.Specialized;
36		#if !SILVERLIGHT
37		using Newtonsoft.Json.Linq.ComponentModel;
38		#endif
39
40		namespace Newtonsoft.Json.Linq
41		{
42		/// <summary>
43		/// Represents a token that can contain other tokens.
44		/// </summary>
45		public abstract class JContainer : JToken, IList<JToken>
46		#if !SILVERLIGHT
47		, ITypedList, IBindingList
48		#else
49		, IList, INotifyCollectionChanged
50		#endif
51		{
52		#if !SILVERLIGHT
53		/// <summary>
54		/// Occurs when the list changes or an item in the list changes.
55		/// </summary>
56		public event ListChangedEventHandler ListChanged;
57
58		/// <summary>
59		/// Occurs before an item is added to the collection.
60		/// </summary>
61		public event AddingNewEventHandler AddingNew;
62		#else
63		/// <summary>
64		/// Occurs when the items list of the collection has changed, or the collection is reset.
65		/// </summary>
66		public event NotifyCollectionChangedEventHandler CollectionChanged;
67		#endif
68
69		private JToken _content;
70		private object _syncRoot;
71		private bool _busy;
72
73		internal JToken Content
74		{
75	4740	get { return _content; }
76	706	set { _content = value; }
77		}
78
79	1196	internal JContainer()
80		{
81	1196	}
82
83	12	internal JContainer(JContainer other)
84		{
85	12	ValidationUtils.ArgumentNotNull(other, "c");
86
87	12	JToken content = other.Last;
88	12	if (content != null)
89		{
90		do
91		{
92	16	content = content._next;
93	16	Add(content.CloneToken());
94		}
95	16	while (content != other.Last);
96		}
97	12	}
98
99		internal void CheckReentrancy()
100		{
101	2058	if (_busy)
102	0	throw new InvalidOperationException("Cannot change {0} during a collection change event.".FormatWith(CultureInfo.InvariantCulture, GetType()));
103	2058	}
104
105		#if !SILVERLIGHT
106		/// <summary>
107		/// Raises the <see cref="AddingNew"/> event.
108		/// </summary>
109		/// <param name="e">The <see cref="AddingNewEventArgs"/> instance containing the event data.</param>
110		protected virtual void OnAddingNew(AddingNewEventArgs e)
111		{
112	2	AddingNewEventHandler handler = AddingNew;
113	2	if (handler != null)
114	1	handler(this, e);
115	2	}
116
117		/// <summary>
118		/// Raises the <see cref="ListChanged"/> event.
119		/// </summary>
120		/// <param name="e">The <see cref="ListChangedEventArgs"/> instance containing the event data.</param>
121		protected virtual void OnListChanged(ListChangedEventArgs e)
122		{
123	68	ListChangedEventHandler handler = ListChanged;
124
125	68	if (handler != null)
126		{
127	5	_busy = true;
128		try
129		{
130	5	handler(this, e);
131		}
132		finally
133		{
134	5	_busy = false;
135		}
136		}
137	68	}
138		#else
139		/// <summary>
140		/// Raises the <see cref="CollectionChanged"/> event.
141		/// </summary>
142		/// <param name="e">The <see cref="NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
143		protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
144		{
145		NotifyCollectionChangedEventHandler handler = CollectionChanged;
146
147		if (handler != null)
148		{
149		_busy = true;
150		try
151		{
152		handler(this, e);
153		}
154		finally
155		{
156		_busy = false;
157		}
158		}
159		}
160		#endif
161
162		/// <summary>
163		/// Gets a value indicating whether this token has childen tokens.
164		/// </summary>
165		/// <value>
166		/// <c>true</c> if this token has child values; otherwise, <c>false</c>.
167		/// </value>
168		public override bool HasValues
169		{
170	1	get { return (_content != null); }
171		}
172
173		internal bool ContentsEqual(JContainer container)
174		{
175	38	JToken t1 = First;
176	38	JToken t2 = container.First;
177
178	38	if (t1 == t2)
179	5	return true;
180
181		do
182		{
183	95	if (t1 == null && t2 == null)
184	33	return true;
185
186	62	if (t1 != null && t2 != null && t1.DeepEquals(t2))
187		{
188	62	t1 = (t1 != Last) ? t1.Next : null;
189	62	t2 = (t2 != container.Last) ? t2.Next : null;
190		}
191		else
192		{
193	0	return false;
194		}
195		}
196	62	while (true);
197	38	}
198
199		/// <summary>
200		/// Get the first child token of this token.
201		/// </summary>
202		/// <value>
203		/// A <see cref="JToken"/> containing the first child token of the <see cref="JToken"/>.
204		/// </value>
205		public override JToken First
206		{
207		get
208		{
209	6517	if (Last == null)
210	421	return null;
211
212	6096	return Last._next;
213	6517	}
214		}
215
216		/// <summary>
217		/// Get the last child token of this token.
218		/// </summary>
219		/// <value>
220		/// A <see cref="JToken"/> containing the last child token of the <see cref="JToken"/>.
221		/// </value>
222		public override JToken Last
223		{
224		[DebuggerStepThrough]
225	14532	get { return _content; }
226		}
227
228		/// <summary>
229		/// Returns a collection of the child tokens of this token, in document order.
230		/// </summary>
231		/// <returns>
232		/// An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing the child tokens of this <see cref="JToken"/>, in document order.
233		/// </returns>
234		public override JEnumerable<JToken> Children()
235		{
236	1999	return new JEnumerable<JToken>(ChildrenInternal());
237	1999	}
238
239		private IEnumerable<JToken> ChildrenInternal()
240		{
241	1994	JToken first = First;
242	1994	JToken current = first;
243	1994	if (current == null)
244	407	yield break;
245
246		do
247		{
248	4153	yield return current;
249		}
250	3895	while ((current = current.Next) != null);
251		}
252
253		/// <summary>
254		/// Returns a collection of the child values of this token, in document order.
255		/// </summary>
256		/// <typeparam name="T">The type to convert the values to.</typeparam>
257		/// <returns>
258		/// A <see cref="IEnumerable{T}"/> containing the child values of this <see cref="JToken"/>, in document order.
259		/// </returns>
260		public override IEnumerable<T> Values<T>()
261		{
262	1	return Children().Convert<JToken, T>();
263	1	}
264
265		/// <summary>
266		/// Returns a collection of the descendant tokens for this token in document order.
267		/// </summary>
268		/// <returns>An <see cref="IEnumerable{JToken}"/> containing the descendant tokens of the <see cref="JToken"/>.</returns>
269		public IEnumerable<JToken> Descendants()
270		{
271	54	foreach (JToken o in Children())
272		{
273	99	yield return o;
274	99	JContainer c = o as JContainer;
275	99	if (c != null)
276		{
277	52	foreach (JToken d in c.Descendants())
278		{
279	298	yield return d;
280		}
281		}
282		}
283		}
284
285		internal bool IsMultiContent(object content)
286		{
287	2111	return (content is IEnumerable && !(content is string) && !(content is JToken) && !(content is byte[]));
288	2111	}
289
290		internal virtual void AddItem(bool isLast, JToken previous, JToken item)
291		{
292	1272	CheckReentrancy();
293
294	1272	ValidateToken(item, null);
295
296	1264	item = EnsureParentToken(item);
297
298	1264	JToken next = (previous != null) ? previous._next : item;
299
300	1264	item.Parent = this;
301	1264	item.Next = next;
302
303	1264	if (previous != null)
304	814	previous.Next = item;
305
306	1264	if (isLast \|\| previous == null)
307	1251	_content = item;
308
309		#if !SILVERLIGHT
310	1264	if (ListChanged != null)
311	1	OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, IndexOfItem(item)));
312		#else
313		if (CollectionChanged != null)
314		OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, IndexOfItem(item)));
315		#endif
316	1264	}
317
318		internal JToken EnsureParentToken(JToken item)
319		{
320	1996	if (item.Parent != null)
321		{
322	4	item = item.CloneToken();
323		}
324		else
325		{
326		// check whether attempting to add a token to itself
327	1992	JContainer parent = this;
328	5187	while (parent.Parent != null)
329		{
330	3195	parent = parent.Parent;
331		}
332	1992	if (item == parent)
333		{
334	1	item = item.CloneToken();
335		}
336		}
337	1996	return item;
338	1996	}
339
340		internal void AddInternal(bool isLast, JToken previous, object content)
341		{
342	1895	if (IsMultiContent(content))
343		{
344	131	IEnumerable enumerable = (IEnumerable) content;
345
346	131	JToken multiPrevious = previous;
347	131	foreach (object c in enumerable)
348		{
349	366	AddInternal(isLast, multiPrevious, c);
350	366	multiPrevious = (multiPrevious != null) ? multiPrevious._next : Last;
351		}
352		}
353		else
354		{
355	1764	JToken item = CreateFromContent(content);
356
357	1764	AddItem(isLast, previous, item);
358		}
359	1885	}
360
361		internal int IndexOfItem(JToken item)
362		{
363	51	int index = 0;
364	51	foreach (JToken token in Children())
365		{
366	73	if (token == item)
367	35	return index;
368
369	38	index++;
370		}
371
372	16	return -1;
373	51	}
374
375		internal virtual void InsertItem(int index, JToken item)
376		{
377	8	if (index == 0)
378		{
379	3	AddFirst(item);
380		}
381		else
382		{
383	5	JToken token = GetItem(index);
384	3	AddInternal(false, token.Previous, item);
385		}
386	6	}
387
388		internal virtual void RemoveItemAt(int index)
389		{
390	6	if (index < 0)
391	1	throw new ArgumentOutOfRangeException("index", "index is less than 0.");
392
393	5	CheckReentrancy();
394
395	5	int currentIndex = 0;
396	5	foreach (JToken token in Children())
397		{
398	5	if (index == currentIndex)
399		{
400	4	token.Remove();
401
402		#if !SILVERLIGHT
403	4	OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
404		#else
405		OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, token, index));
406		#endif
407
408	4	return;
409		}
410
411	1	currentIndex++;
412		}
413
414	1	throw new ArgumentOutOfRangeException("index", "index is equal to or greater than Count.");
415	4	}
416
417		internal virtual bool RemoveItem(JToken item)
418		{
419	25	if (item == null \|\| item.Parent != this)
420	7	return false;
421
422	18	CheckReentrancy();
423
424	18	JToken content = _content;
425
426	18	int itemIndex = 0;
427	21	while (content._next != item)
428		{
429	3	itemIndex++;
430	3	content = content._next;
431		}
432	18	if (content == item)
433		{
434		// token is containers last child
435	8	_content = null;
436		}
437		else
438		{
439	10	if (_content == item)
440		{
441	2	_content = content;
442		}
443	10	content._next = item._next;
444		}
445	18	item.Parent = null;
446	18	item.Next = null;
447
448		#if !SILVERLIGHT
449	18	OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, itemIndex));
450		#else
451		OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, itemIndex));
452		#endif
453
454	18	return true;
455	25	}
456
457		internal virtual JToken GetItem(int index)
458		{
459	159	return Children().ElementAt(index);
460	157	}
461
462		internal virtual void SetItem(int index, JToken item)
463		{
464	11	CheckReentrancy();
465
466	11	JToken token = GetItem(index);
467	11	token.Replace(item);
468
469		#if !SILVERLIGHT
470	8	OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
471		#else
472		OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, token, index));
473		#endif
474	8	}
475
476		internal virtual void ClearItems()
477		{
478	6	CheckReentrancy();
479
480	17	while (_content != null)
481		{
482	11	JToken o = _content;
483
484	11	JToken next = o._next;
485	11	if (o != _content \|\| next != o._next)
486	0	throw new InvalidOperationException("This operation was corrupted by external code.");
487
488	11	if (next != o)
489	5	o._next = next._next;
490		else
491	6	_content = null;
492
493	11	next.Parent = null;
494	11	next._next = null;
495		}
496
497		#if !SILVERLIGHT
498	6	OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
499		#else
500		OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));