Code Coverage Statistics for Source File

Newtonsoft.Json\Converters\XmlNodeConverter.cs

Symbol Coverage: 91.54% (411 of 449)

Branch Coverage: 90.23% (240 of 266)

Cyclomatic Complexity Avg: 2.81 Max:26

Code Lines: 534

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

#if !SILVERLIGHT
using System;
using System.Collections.Generic;
using System.Xml;
#if !NET20
using System.Xml.Linq;
#endif
using Newtonsoft.Json.Utilities;
using System.Linq;

namespace Newtonsoft.Json.Converters
{
  #region Wrappers
  internal class XmlDocumentWrapper : XmlNodeWrapper, IXmlDocument
  {
    private XmlDocument _document;

    public XmlDocumentWrapper(XmlDocument document)
      : base(document)
    {
      _document = document;
    }

    public IXmlNode CreateComment(string data)
    {
      return new XmlNodeWrapper(_document.CreateComment(data));
    }

    public IXmlNode CreateTextNode(string text)
    {
      return new XmlNodeWrapper(_document.CreateTextNode(text));
    }

    public IXmlNode CreateCDataSection(string data)
    {
      return new XmlNodeWrapper(_document.CreateCDataSection(data));
    }

    public IXmlNode CreateWhitespace(string text)
    {
      return new XmlNodeWrapper(_document.CreateWhitespace(text));
    }

    public IXmlNode CreateSignificantWhitespace(string text)
    {
      return new XmlNodeWrapper(_document.CreateSignificantWhitespace(text));
    }

    public IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone)
    {
      return new XmlNodeWrapper(_document.CreateXmlDeclaration(version, encoding, standalone));
    }

    public IXmlNode CreateProcessingInstruction(string target, string data)
    {
      return new XmlNodeWrapper(_document.CreateProcessingInstruction(target, data));
    }

    public IXmlElement CreateElement(string elementName)
    {
      return new XmlElementWrapper(_document.CreateElement(elementName));
    }

    public IXmlElement CreateElement(string qualifiedName, string namespaceURI)
    {
      return new XmlElementWrapper(_document.CreateElement(qualifiedName, namespaceURI));
    }

    public IXmlNode CreateAttribute(string name, string value)
    {
      XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(name));
      attribute.Value = value;

      return attribute;
    }

    public IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value)
    {
      XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(qualifiedName, namespaceURI));
      attribute.Value = value;

      return attribute;
    }

    public IXmlElement DocumentElement
    {
      get
      {
        if (_document.DocumentElement == null)
          return null;

        return new XmlElementWrapper(_document.DocumentElement);
      }
    }
  }

  internal class XmlElementWrapper : XmlNodeWrapper, IXmlElement
  {
    private XmlElement _element;

    public XmlElementWrapper(XmlElement element)
      : base(element)
    {
      _element = element;
    }

    public void SetAttributeNode(IXmlNode attribute)
    {
      XmlNodeWrapper xmlAttributeWrapper = (XmlNodeWrapper)attribute;

      _element.SetAttributeNode((XmlAttribute) xmlAttributeWrapper.WrappedNode);
    }
  }

  internal class XmlDeclarationWrapper : XmlNodeWrapper, IXmlDeclaration
  {
    private XmlDeclaration _declaration;

    public XmlDeclarationWrapper(XmlDeclaration declaration)
      : base(declaration)
    {
      _declaration = declaration;
    }

    public string Version
    {
      get { return _declaration.Version; }
    }

    public string Encoding
    {
      get { return _declaration.Encoding; }
      set { _declaration.Encoding = value; }
    }

    public string Standalone
    {
      get { return _declaration.Standalone; }
      set { _declaration.Standalone = value; }
    }
  }

  internal class XmlNodeWrapper : IXmlNode
  {
    private readonly XmlNode _node;

    public XmlNodeWrapper(XmlNode node)
    {
      _node = node;
    }

    public object WrappedNode
    {
      get { return _node; }
    }

    public XmlNodeType NodeType
    {
      get { return _node.NodeType; }
    }

    public string Name
    {
      get { return _node.Name; }
    }

    public string LocalName
    {
      get { return _node.LocalName; }
    }

    public IList<IXmlNode> ChildNodes
    {
      get { return _node.ChildNodes.Cast<XmlNode>().Select(n => WrapNode(n)).ToList(); }
    }

    private IXmlNode WrapNode(XmlNode node)
    {
      switch (node.NodeType)
      {
        case XmlNodeType.Element:
          return new XmlElementWrapper((XmlElement) node);
        case XmlNodeType.XmlDeclaration:
          return new XmlDeclarationWrapper((XmlDeclaration) node);
        default:
          return new XmlNodeWrapper(node);
      }
    }

    public IList<IXmlNode> Attributes
    {
      get
      {
        if (_node.Attributes == null)
          return null;

        return _node.Attributes.Cast<XmlAttribute>().Select(a => WrapNode(a)).ToList();
      }
    }

    public IXmlNode ParentNode
    {
      get
      {
        XmlNode node = (_node is XmlAttribute)
                         ? ((XmlAttribute) _node).OwnerElement
                         : _node.ParentNode;
        
        if (node == null)
          return null;

        return WrapNode(node);
      }
    }

    public string Value
    {
      get { return _node.Value; }
      set { _node.Value = value; }
    }

    public IXmlNode AppendChild(IXmlNode newChild)
    {
      XmlNodeWrapper xmlNodeWrapper = (XmlNodeWrapper) newChild;
      _node.AppendChild(xmlNodeWrapper._node);

      return newChild;
    }

    public string Prefix
    {
      get { return _node.Prefix; }
    }

    public string NamespaceURI
    {
      get { return _node.NamespaceURI; }
    }
  }

  internal interface IXmlDocument : IXmlNode
  {
    IXmlNode CreateComment(string text);
    IXmlNode CreateTextNode(string text);
    IXmlNode CreateCDataSection(string data);
    IXmlNode CreateWhitespace(string text);
    IXmlNode CreateSignificantWhitespace(string text);
    IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone);
    IXmlNode CreateProcessingInstruction(string target, string data);
    IXmlElement CreateElement(string elementName);
    IXmlElement CreateElement(string qualifiedName, string namespaceURI);
    IXmlNode CreateAttribute(string name, string value);
    IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value);

    IXmlElement DocumentElement { get; }
  }

  internal interface IXmlDeclaration : IXmlNode
  {
    string Version { get; }
    string Encoding { get; set; }
    string Standalone { get; set; }
  }

  internal interface IXmlElement : IXmlNode
  {
    void SetAttributeNode(IXmlNode attribute);
  }

  internal interface IXmlNode
  {
    XmlNodeType NodeType { get; }
    string LocalName { get; }
    IList<IXmlNode> ChildNodes { get; }
    IList<IXmlNode> Attributes { get; }
    IXmlNode ParentNode { get; }
    string Value { get; set; }
    IXmlNode AppendChild(IXmlNode newChild);
    string NamespaceURI { get; }
    object WrappedNode { get; }
  }

  #if !NET20
  internal class XDeclarationWrapper : XObjectWrapper, IXmlDeclaration
  {
    internal readonly XDeclaration _declaration;

    public XDeclarationWrapper(XDeclaration declaration)
      : base(null)
    {
      _declaration = declaration;
    }

    public override XmlNodeType NodeType
    {
      get { return XmlNodeType.XmlDeclaration; }
    }

    public string Version
    {
      get { return _declaration.Version; }
    }

    public string Encoding
    {
      get { return _declaration.Encoding; }
      set { _declaration.Encoding = value; }
    }

    public string Standalone
    {
      get { return _declaration.Standalone; }
      set { _declaration.Standalone = value; }
    }
  }

  internal class XDocumentWrapper : XContainerWrapper, IXmlDocument
  {
    private XDocument Document
    {
      get { return (XDocument)WrappedNode; }
    }

    public XDocumentWrapper(XDocument document)
      : base(document)
    {
    }

    public override IList<IXmlNode> ChildNodes
    {
      get
      {
        IList<IXmlNode> childNodes = base.ChildNodes;

        if (Document.Declaration != null)
          childNodes.Insert(0, new XDeclarationWrapper(Document.Declaration));

        return childNodes;
      }
    }

    public IXmlNode CreateComment(string text)
    {
      return new XObjectWrapper(new XComment(text));
    }

    public IXmlNode CreateTextNode(string text)
    {
      return new XObjectWrapper(new XText(text));
    }

    public IXmlNode CreateCDataSection(string data)
    {
      return new XObjectWrapper(new XCData(data));
    }

    public IXmlNode CreateWhitespace(string text)
    {
      return new XObjectWrapper(new XText(text));
    }

    public IXmlNode CreateSignificantWhitespace(string text)
    {
      return new XObjectWrapper(new XText(text));
    }

    public IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone)
    {
      return new XDeclarationWrapper(new XDeclaration(version, encoding, standalone));
    }

    public IXmlNode CreateProcessingInstruction(string target, string data)
    {
      return new XProcessingInstructionWrapper(new XProcessingInstruction(target, data));
    }

    public IXmlElement CreateElement(string elementName)
    {
      return new XElementWrapper(new XElement(elementName));
    }

    public IXmlElement CreateElement(string qualifiedName, string namespaceURI)
    {
      string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
      return new XElementWrapper(new XElement(XName.Get(localName, namespaceURI)));
    }

    public IXmlNode CreateAttribute(string name, string value)
    {
      return new XAttributeWrapper(new XAttribute(name, value));
    }

    public IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value)
    {
      string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
      return new XAttributeWrapper(new XAttribute(XName.Get(localName, namespaceURI), value));
    }

    public IXmlElement DocumentElement
    {
      get
      {
        if (Document.Root == null)
          return null;

        return new XElementWrapper(Document.Root);
      }
    }

    public override IXmlNode AppendChild(IXmlNode newChild)
    {
      XDeclarationWrapper declarationWrapper = newChild as XDeclarationWrapper;
      if (declarationWrapper != null)
      {
        Document.Declaration = declarationWrapper._declaration;
        return declarationWrapper;
      }
      else
      {
        return base.AppendChild(newChild);
      }
    }
  }

  internal class XTextWrapper : XObjectWrapper
  {
    private XText Text
    {
      get { return (XText)WrappedNode; }
    }

    public XTextWrapper(XText text)
      : base(text)
    {
    }

    public override string Value
    {
      get { return Text.Value; }
      set { Text.Value = value; }
    }

    public override IXmlNode ParentNode
    {
      get
      {
        if (Text.Parent == null)
          return null;
        
        return XContainerWrapper.WrapNode(Text.Parent);
      }
    }
  }

  internal class XCommentWrapper : XObjectWrapper
  {
    private XComment Text
    {
      get { return (XComment)WrappedNode; }
    }

    public XCommentWrapper(XComment text)
      : base(text)
    {
    }

    public override string Value
    {
      get { return Text.Value; }
      set { Text.Value = value; }
    }

    public override IXmlNode ParentNode
    {
      get
      {
        if (Text.Parent == null)
          return null;

        return XContainerWrapper.WrapNode(Text.Parent);
      }
    }
  }

  internal class XProcessingInstructionWrapper : XObjectWrapper
  {
    private XProcessingInstruction ProcessingInstruction
    {
      get { return (XProcessingInstruction)WrappedNode; }
    }

    public XProcessingInstructionWrapper(XProcessingInstruction processingInstruction)
      : base(processingInstruction)
    {
    }

    public override string LocalName
    {
      get { return ProcessingInstruction.Target; }
    }

    public override string Value
    {
      get { return ProcessingInstruction.Data; }
      set { ProcessingInstruction.Data = value; }
    }
  }

  internal class XContainerWrapper : XObjectWrapper
  {
    private XContainer Container
    {
      get { return (XContainer)WrappedNode; }
    }

    public XContainerWrapper(XContainer container)
      : base(container)
    {
    }

    public override IList<IXmlNode> ChildNodes
    {
      get { return Container.Nodes().Select(n => WrapNode(n)).ToList(); }
    }

    public override IXmlNode ParentNode
    {
      get
      {
        if (Container.Parent == null)
          return null;
        
        return WrapNode(Container.Parent);
      }
    }

    internal static IXmlNode WrapNode(XObject node)
    {
      if (node is XDocument)
        return new XDocumentWrapper((XDocument)node);
      else if (node is XElement)
        return new XElementWrapper((XElement)node);
      else if (node is XContainer)
        return new XContainerWrapper((XContainer)node);
      else if (node is XProcessingInstruction)
        return new XProcessingInstructionWrapper((XProcessingInstruction)node);
      else if (node is XText)
        return new XTextWrapper((XText)node);
      else if (node is XComment)
        return new XCommentWrapper((XComment)node);
      else if (node is XAttribute)
        return new XAttributeWrapper((XAttribute) node);
      else
        return new XObjectWrapper(node);
    }

    public override IXmlNode AppendChild(IXmlNode newChild)
    {
      Container.Add(newChild.WrappedNode);
      return newChild;
    }
  }

  internal class XObjectWrapper : IXmlNode
  {
    private readonly XObject _xmlObject;

    public XObjectWrapper(XObject xmlObject)
    {
      _xmlObject = xmlObject;
    }

    public object WrappedNode
    {
      get { return _xmlObject; }
    }

    public virtual XmlNodeType NodeType
    {
      get { return _xmlObject.NodeType; }
    }

    public virtual string LocalName
    {
      get { return null; }
    }

    public virtual IList<IXmlNode> ChildNodes
    {
      get { return new List<IXmlNode>(); }
    }

    public virtual IList<IXmlNode> Attributes
    {
      get { return null; }
    }

    public virtual IXmlNode ParentNode
    {
      get { return null; }
    }

    public virtual string Value
    {
      get { return null; }
      set { throw new InvalidOperationException(); }
    }

    public virtual IXmlNode AppendChild(IXmlNode newChild)
    {
      throw new InvalidOperationException();
    }

    public virtual string NamespaceURI
    {
      get { return null; }
    }
  }

  internal class XAttributeWrapper : XObjectWrapper
  {
    private XAttribute Attribute
    {
      get { return (XAttribute)WrappedNode; }
    }

    public XAttributeWrapper(XAttribute attribute)
      : base(attribute)
    {
    }

    public override string Value
    {
      get { return Attribute.Value; }
      set { Attribute.Value = value; }
    }

    public override string LocalName
    {
      get { return Attribute.Name.LocalName; }
    }

    public override string NamespaceURI
    {
      get { return Attribute.Name.NamespaceName; }
    }

    public override IXmlNode ParentNode
    {
      get
      {
        if (Attribute.Parent == null)
          return null;

        return XContainerWrapper.WrapNode(Attribute.Parent);
      }
    }
  }

  internal class XElementWrapper : XContainerWrapper, IXmlElement
  {
    private XElement Element
    {
      get { return (XElement) WrappedNode; }
    }

    public XElementWrapper(XElement element)
      : base(element)
    {
    }

    public void SetAttributeNode(IXmlNode attribute)
    {
      XObjectWrapper wrapper = (XObjectWrapper)attribute;
      Element.Add(wrapper.WrappedNode);
    }

    public override IList<IXmlNode> Attributes
    {
      get { return Element.Attributes().Select(a => new XAttributeWrapper(a)).Cast<IXmlNode>().ToList(); }
    }

    public override string Value
    {
      get { return Element.Value; }
      set { Element.Value = value; }
    }

    public override string LocalName
    {
      get { return Element.Name.LocalName; }
    }

    public override string NamespaceURI
    {
      get { return Element.Name.NamespaceName; }
    }
  }
#endif
  #endregion

  /// <summary>
  /// Converts an <see cref="XmlNode"/> to and from JSON.
  /// </summary>
  public class XmlNodeConverter : JsonConverter
  {
    private const string TextName = "#text";
    private const string CommentName = "#comment";
    private const string CDataName = "#cdata-section";
    private const string WhitespaceName = "#whitespace";
    private const string SignificantWhitespaceName = "#significant-whitespace";
    private const string DeclarationName = "?xml";
    private const string JsonNamespaceUri = "http://james.newtonking.com/projects/json";

    /// <summary>
    /// Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produces multiple root elements.
    /// </summary>
    /// <value>The name of the deserialize root element.</value>
    public string DeserializeRootElementName { get; set; }

    #region Writing
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="serializer">The calling serializer.</param>
    /// <param name="value">The value.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      IXmlNode node;

      if (value is XmlNode)
        node = new XmlNodeWrapper((XmlNode)value);
#if !NET20
      else if (value is XObject)
        node = XContainerWrapper.WrapNode((XObject)value);
#endif
      else
        throw new ArgumentException("Value must be an XmlNode", "value");

      XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
      PushParentNamespaces(node, manager);

      writer.WriteStartObject();
      SerializeNode(writer, node, manager, true);
      writer.WriteEndObject();
    }

    private void PushParentNamespaces(IXmlNode node, XmlNamespaceManager manager)
    {
      List<IXmlNode> parentElements = null;

      IXmlNode parent = node;
      while ((parent = parent.ParentNode) != null)
      {
        if (parent.NodeType == XmlNodeType.Element)
        {
          if (parentElements == null)
            parentElements = new List<IXmlNode>();

          parentElements.Add(parent);
        }
      }

      if (parentElements != null)
      {
        parentElements.Reverse();

        foreach (IXmlNode parentElement in parentElements)
        {
          manager.PushScope();
          foreach (IXmlNode attribute in parentElement.Attributes)
          {
            if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/" && attribute.LocalName != "xmlns")
              manager.AddNamespace(attribute.LocalName, attribute.Value);
          }
        }
      }
    }

    private string ResolveFullName(IXmlNode node, XmlNamespaceManager manager)
    {
      string prefix = (node.NamespaceURI == null || (node.LocalName == "xmlns" && node.NamespaceURI == "http://www.w3.org/2000/xmlns/"))
                        ? null
                        : manager.LookupPrefix(node.NamespaceURI);

      if (!string.IsNullOrEmpty(prefix))
        return prefix + ":" + node.LocalName;
      else
        return node.LocalName;
    }

    private string GetPropertyName(IXmlNode node, XmlNamespaceManager manager)
    {
      switch (node.NodeType)
      {
        case XmlNodeType.Attribute:
          if (node.NamespaceURI == JsonNamespaceUri)
            return "$" + node.LocalName;
          else
            return "@" + ResolveFullName(node, manager);
        case XmlNodeType.CDATA:
          return CDataName;
        case XmlNodeType.Comment:
          return CommentName;
        case XmlNodeType.Element:
          return ResolveFullName(node, manager);
        case XmlNodeType.ProcessingInstruction:
          return "?" + ResolveFullName(node, manager);
        case XmlNodeType.XmlDeclaration:
          return DeclarationName;
        case XmlNodeType.SignificantWhitespace:
          return SignificantWhitespaceName;
        case XmlNodeType.Text:
          return TextName;
        case XmlNodeType.Whitespace:
          return WhitespaceName;
        default:
          throw new JsonSerializationException("Unexpected XmlNodeType when getting node name: " + node.NodeType);
      }
    }

    private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager)
    {
      // group nodes together by name
      Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();

      for (int i = 0; i < node.ChildNodes.Count; i++)
      {
        IXmlNode childNode = node.ChildNodes[i];
        string nodeName = GetPropertyName(childNode, manager);

        List<IXmlNode> nodes;
        if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
        {
          nodes = new List<IXmlNode>();
          nodesGroupedByName.Add(nodeName, nodes);
        }

        nodes.Add(childNode);
      }

      // loop through grouped nodes. write single name instances as normal,
      // write multiple names together in an array
      foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName)
      {
        List<IXmlNode> groupedNodes = nodeNameGroup.Value;
        bool writeArray;

        if (groupedNodes.Count == 1)
        {
          IXmlNode singleNode = groupedNodes[0];
          IXmlNode jsonArrayAttribute = (singleNode.Attributes != null)
            ? singleNode.Attributes.SingleOrDefault(a => a.LocalName == "Array" && a.NamespaceURI == JsonNamespaceUri)
            : null;
          if (jsonArrayAttribute != null)
            writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value);
          else
            writeArray = false;
        }
        else
        {
          writeArray = true;
        }

        if (!writeArray)
        {
          SerializeNode(writer, groupedNodes[0], manager, true);
        }
        else
        {
          string elementNames = nodeNameGroup.Key;
          writer.WritePropertyName(elementNames);
          writer.WriteStartArray();

          for (int i = 0; i < groupedNodes.Count; i++)
          {
            SerializeNode(writer, groupedNodes[i], manager, false);
          }

          writer.WriteEndArray();
        }
      }
    }

    private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
    {
      switch (node.NodeType)
      {
        case XmlNodeType.Document:
        case XmlNodeType.DocumentFragment:
          SerializeGroupedNodes(writer, node, manager);
          break;
        case XmlNodeType.Element:
          foreach (IXmlNode attribute in node.Attributes)
          {
            if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/")
            {
              string prefix = (attribute.LocalName != "xmlns")
                                ? attribute.LocalName
                                : string.Empty;

              manager.AddNamespace(prefix, attribute.Value);
            }
          }

          if (writePropertyName)
            writer.WritePropertyName(GetPropertyName(node, manager));

          if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1
                  && node.ChildNodes[0].NodeType == XmlNodeType.Text)
          {
            // write elements with a single text child as a name value pair
            writer.WriteValue(node.ChildNodes[0].Value);
          }
          else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
          {
            // empty element
            writer.WriteNull();
          }
          else
          {
            writer.WriteStartObject();

            for (int i = 0; i < node.Attributes.Count; i++)
            {
              SerializeNode(writer, node.Attributes[i], manager, true);
            }

            SerializeGroupedNodes(writer, node, manager);

            writer.WriteEndObject();
          }

          break;
        case XmlNodeType.Comment:
          if (writePropertyName)
            writer.WriteComment(node.Value);
          break;
        case XmlNodeType.Attribute:
        case XmlNodeType.Text:
        case XmlNodeType.CDATA:
        case XmlNodeType.ProcessingInstruction:
        case XmlNodeType.Whitespace:
        case XmlNodeType.SignificantWhitespace:
          if (node.NamespaceURI == "http://www.w3.org/2000/xmlns/" && node.Value == JsonNamespaceUri)
            return;

          if (node.NamespaceURI == JsonNamespaceUri)
          {
            if (node.LocalName == "Array")
              return;
          }

          if (writePropertyName)
            writer.WritePropertyName(GetPropertyName(node, manager));
          writer.WriteValue(node.Value);
          break;
        case XmlNodeType.XmlDeclaration:
          IXmlDeclaration declaration = (IXmlDeclaration)node;
          writer.WritePropertyName(GetPropertyName(node, manager));
          writer.WriteStartObject();

          if (!string.IsNullOrEmpty(declaration.Version))
          {
            writer.WritePropertyName("@version");
            writer.WriteValue(declaration.Version);
          }
          if (!string.IsNullOrEmpty(declaration.Encoding))
          {
            writer.WritePropertyName("@encoding");
            writer.WriteValue(declaration.Encoding);
          }
          if (!string.IsNullOrEmpty(declaration.Standalone))
          {
            writer.WritePropertyName("@standalone");
            writer.WriteValue(declaration.Standalone);
          }

          writer.WriteEndObject();
          break;
        default:
          throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
      }
    }
    #endregion

    #region Reading
    /// <summary>
    /// Reads the JSON representation of the object.
    /// </summary>
    /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
    /// <param name="objectType">Type of the object.</param>
    /// <param name="existingValue">The existing value of object being read.</param>
    /// <param name="serializer">The calling serializer.</param>
    /// <returns>The object value.</returns>
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
      XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
      IXmlDocument document;
      IXmlNode rootNode;

      if (typeof (XmlNode).IsAssignableFrom(objectType))
      {
        if (objectType != typeof (XmlDocument))
          throw new JsonSerializationException("XmlNodeConverter only supports deserializing XmlDocuments");

        XmlDocument d = new XmlDocument();
        document = new XmlDocumentWrapper(d);
        rootNode = document;
      }
#if !NET20
      else if (typeof(XObject).IsAssignableFrom(objectType))
      {
        if (objectType != typeof (XDocument) && objectType != typeof (XElement))
          throw new JsonSerializationException("XmlNodeConverter only supports deserializing XDocument or XElement.");

        XDocument d = new XDocument();
        document = new XDocumentWrapper(d);
        rootNode = document;
      }
#endif
      else
      {
        throw new JsonSerializationException("Unexpected type when converting XML: " + objectType);
      }

      if (reader.TokenType != JsonToken.StartObject)
        throw new JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");

      if (!string.IsNullOrEmpty(DeserializeRootElementName))
      {
        //rootNode = document.CreateElement(DeserializeRootElementName);
        //document.AppendChild(rootNode);
        ReadElement(reader, document, rootNode, DeserializeRootElementName, manager);
      }
      else
      {
        reader.Read();
        DeserializeNode(reader, document, manager, rootNode);
      }

#if !NET20
      if (objectType == typeof(XElement))
      {
        XElement element = (XElement)document.DocumentElement.WrappedNode;
        element.Remove();

        return element;
      }
#endif

      return document.WrappedNode;
    }

    private void DeserializeValue(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, string propertyName, IXmlNode currentNode)
    {
      switch (propertyName)
      {
        case TextName:
          currentNode.AppendChild(document.CreateTextNode(reader.Value.ToString()));
          break;
        case CDataName:
          currentNode.AppendChild(document.CreateCDataSection(reader.Value.ToString()));
          break;
        case WhitespaceName:
          currentNode.AppendChild(document.CreateWhitespace(reader.Value.ToString()));
          break;
        case SignificantWhitespaceName:
          currentNode.AppendChild(document.CreateSignificantWhitespace(reader.Value.ToString()));
          break;
        default:
          // processing instructions and the xml declaration start with ?
          if (!string.IsNullOrEmpty(propertyName) && propertyName[0] == '?')
          {
            CreateInstruction(reader, document, currentNode, propertyName);
          }
          else
          {
            if (reader.TokenType == JsonToken.StartArray)
            {
              ReadArrayElements(reader, document, propertyName, currentNode, manager);
              return;
            }

            // have to wait until attributes have been parsed before creating element
            // attributes may contain namespace info used by the element
            ReadElement(reader, document, currentNode, propertyName, manager);
          }
          break;
      }
    }

    private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
    {
      Dictionary<string, string> attributeNameValues = ReadAttributeElements(reader, manager);

      string elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);

      IXmlElement element = CreateElement(propertyName, document, elementPrefix, manager);

      currentNode.AppendChild(element);

      // add attributes to newly created element
      foreach (KeyValuePair<string, string> nameValue in attributeNameValues)
      {
        string attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);

        IXmlNode attribute = (!string.IsNullOrEmpty(attributePrefix))
                               ? document.CreateAttribute(nameValue.Key, manager.LookupNamespace(attributePrefix), nameValue.Value)
                               : document.CreateAttribute(nameValue.Key, nameValue.Value);

        element.SetAttributeNode(attribute);
      }

      if (reader.TokenType == JsonToken.String)
      {
        element.AppendChild(document.CreateTextNode(reader.Value.ToString()));
      }
      else if (reader.TokenType == JsonToken.Integer)
      {
        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
      }
      else if (reader.TokenType == JsonToken.Float)
      {
        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
      }
      else if (reader.TokenType == JsonToken.Boolean)
      {
        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
      }
      else if (reader.TokenType == JsonToken.Date)
      {
        DateTime d = (DateTime)reader.Value;
        element.AppendChild(document.CreateTextNode(XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind))));
      }
      else if (reader.TokenType == JsonToken.Null)
      {
        // empty element. do nothing
      }
      else
      {
        // finished element will have no children to deserialize
        if (reader.TokenType != JsonToken.EndObject)
        {
          manager.PushScope();

          DeserializeNode(reader, document, manager, element);

          manager.PopScope();
        }
      }
    }

    private void ReadArrayElements(JsonReader reader, IXmlDocument document, string propertyName, IXmlNode currentNode, XmlNamespaceManager manager)
    {
      string elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);

      IXmlElement nestedArrayElement = CreateElement(propertyName, document, elementPrefix, manager);

      currentNode.AppendChild(nestedArrayElement);

      while (reader.Read() && reader.TokenType != JsonToken.EndArray)
      {
        DeserializeValue(reader, document, manager, propertyName, nestedArrayElement);
      }
    }

    private Dictionary<string, string> ReadAttributeElements(JsonReader reader, XmlNamespaceManager manager)
    {
      Dictionary<string, string> attributeNameValues = new Dictionary<string, string>();
      bool finishedAttributes = false;
      bool finishedElement = false;

      // a string token means the element only has a single text child
      if (reader.TokenType != JsonToken.String
          && reader.TokenType != JsonToken.Null
          && reader.TokenType != JsonToken.Boolean
          && reader.TokenType != JsonToken.Integer
          && reader.TokenType != JsonToken.Float
          && reader.TokenType != JsonToken.Date
          && reader.TokenType != JsonToken.StartConstructor)
      {
        // read properties until first non-attribute is encountered
        while (!finishedAttributes && !finishedElement && reader.Read())
        {
          switch (reader.TokenType)
          {
            case JsonToken.PropertyName:
              string attributeName = reader.Value.ToString();
              string attributeValue;
              char firstChar = attributeName[0];

              switch (firstChar)
              {
                case '@':
                  attributeName = attributeName.Substring(1);
                  reader.Read();
                  attributeValue = reader.Value.ToString();
                  attributeNameValues.Add(attributeName, attributeValue);

                  string namespacePrefix;
                  if (IsNamespaceAttribute(attributeName, out namespacePrefix))
                  {
                    manager.AddNamespace(namespacePrefix, attributeValue);
                  }
                  break;
                case '$':
                  attributeName = attributeName.Substring(1);
                  reader.Read();
                  attributeValue = reader.Value.ToString();

                  // check that JsonNamespaceUri is in scope
                  // if it isn't then add it to document and namespace manager
                  string jsonPrefix = manager.LookupPrefix(JsonNamespaceUri);
                  if (jsonPrefix == null)
                  {
                    // ensure that the prefix used is free
                    int? i = null;
                    while (manager.LookupNamespace("json" + i) != null)
                    {
                      i = i.GetValueOrDefault() + 1;
                    }
                    jsonPrefix = "json" + i;

                    attributeNameValues.Add("xmlns:" + jsonPrefix, JsonNamespaceUri);
                    manager.AddNamespace(jsonPrefix, JsonNamespaceUri);
                  }

                  attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue);
                  break;
                default:
                  finishedAttributes = true;
                  break;
              }
              break;
            case JsonToken.EndObject:
              finishedElement = true;
              break;
            default:
              throw new JsonSerializationException("Unexpected JsonToken: " + reader.TokenType);
          }
        }
      }

      return attributeNameValues;
    }

    private void CreateInstruction(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName)
    {
      if (propertyName == DeclarationName)
      {
        string version = null;
        string encoding = null;
        string standalone = null;
        while (reader.Read() && reader.TokenType != JsonToken.EndObject)
        {
          switch (reader.Value.ToString())
          {
            case "@version":
              reader.Read();
              version = reader.Value.ToString();
              break;
            case "@encoding":
              reader.Read();
              encoding = reader.Value.ToString();
              break;
            case "@standalone":
              reader.Read();
              standalone = reader.Value.ToString();
              break;
            default:
              throw new JsonSerializationException("Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
          }
        }

        IXmlNode declaration = document.CreateXmlDeclaration(version, encoding, standalone);
        currentNode.AppendChild(declaration);
      }
      else
      {
        IXmlNode instruction = document.CreateProcessingInstruction(propertyName.Substring(1), reader.Value.ToString());
        currentNode.AppendChild(instruction);
      }
    }

    private IXmlElement CreateElement(string elementName, IXmlDocument document, string elementPrefix, XmlNamespaceManager manager)
    {
      return (!string.IsNullOrEmpty(elementPrefix))
               ? document.CreateElement(elementName, manager.LookupNamespace(elementPrefix))
               : document.CreateElement(elementName);
    }

    private void DeserializeNode(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, IXmlNode currentNode)
    {
      do
      {
        switch (reader.TokenType)
        {
          case JsonToken.PropertyName:
            if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
              throw new JsonSerializationException("JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.");

            string propertyName = reader.Value.ToString();
            reader.Read();

            if (reader.TokenType == JsonToken.StartArray)
            {
              while (reader.Read() && reader.TokenType != JsonToken.EndArray)
              {
                DeserializeValue(reader, document, manager, propertyName, currentNode);
              }
            }
            else
            {
              DeserializeValue(reader, document, manager, propertyName, currentNode);
            }
            break;
          case JsonToken.StartConstructor:
            string constructorName = reader.Value.ToString();

            while (reader.Read() && reader.TokenType != JsonToken.EndConstructor)
            {
              DeserializeValue(reader, document, manager, constructorName, currentNode);
            }
            break;
          case JsonToken.Comment:
            currentNode.AppendChild(document.CreateComment((string)reader.Value));
            break;
          case JsonToken.EndObject:
          case JsonToken.EndArray:
            return;
          default:
            throw new JsonSerializationException("Unexpected JsonToken when deserializing node: " + reader.TokenType);
        }
      } while (reader.TokenType == JsonToken.PropertyName || reader.Read());
      // don't read if current token is a property. token was already read when parsing element attributes
    }

    /// <summary>
    /// Checks if the attributeName is a namespace attribute.
    /// </summary>
    /// <param name="attributeName">Attribute name to test.</param>
    /// <param name="prefix">The attribute name prefix if it has one, otherwise an empty string.</param>
    /// <returns>True if attribute name is for a namespace attribute, otherwise false.</returns>
    private bool IsNamespaceAttribute(string attributeName, out string prefix)
    {
      if (attributeName.StartsWith("xmlns", StringComparison.Ordinal))
      {
        if (attributeName.Length == 5)
        {
          prefix = string.Empty;
          return true;
        }
        else if (attributeName[5] == ':')
        {
          prefix = attributeName.Substring(6, attributeName.Length - 6);
          return true;
        }
      }
      prefix = null;
      return false;
    }

    private IEnumerable<IXmlNode> ValueAttributes(IEnumerable<IXmlNode> c)
    {
      return c.Where(a => a.NamespaceURI != JsonNamespaceUri);
    }
    #endregion

    /// <summary>
    /// Determines whether this instance can convert the specified value type.
    /// </summary>
    /// <param name="valueType">Type of the value.</param>
    /// <returns>
    /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
    /// </returns>
    public override bool CanConvert(Type valueType)
    {
      if (typeof(XmlNode).IsAssignableFrom(valueType))
        return true;
#if !NET20
      if (typeof(XObject).IsAssignableFrom(valueType))
        return true;
#endif

      return false;
    }
  }
}
#endif

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		#if !SILVERLIGHT
27		using System;
28		using System.Collections.Generic;
29		using System.Xml;
30		#if !NET20
31		using System.Xml.Linq;
32		#endif
33		using Newtonsoft.Json.Utilities;
34		using System.Linq;
35
36		namespace Newtonsoft.Json.Converters
37		{
38		#region Wrappers
39		internal class XmlDocumentWrapper : XmlNodeWrapper, IXmlDocument
40		{
41		private XmlDocument _document;
42
43	17	public XmlDocumentWrapper(XmlDocument document)
44	17	: base(document)
45		{
46	17	_document = document;
47	17	}
48
49		public IXmlNode CreateComment(string data)
50		{
51	1	return new XmlNodeWrapper(_document.CreateComment(data));
52	1	}
53
54		public IXmlNode CreateTextNode(string text)
55		{
56	41	return new XmlNodeWrapper(_document.CreateTextNode(text));
57	41	}
58
59		public IXmlNode CreateCDataSection(string data)
60		{
61	1	return new XmlNodeWrapper(_document.CreateCDataSection(data));
62	1	}
63
64		public IXmlNode CreateWhitespace(string text)
65		{
66	0	return new XmlNodeWrapper(_document.CreateWhitespace(text));
67	0	}
68
69		public IXmlNode CreateSignificantWhitespace(string text)
70		{
71	0	return new XmlNodeWrapper(_document.CreateSignificantWhitespace(text));
72	0	}
73
74		public IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone)
75		{
76	7	return new XmlNodeWrapper(_document.CreateXmlDeclaration(version, encoding, standalone));
77	7	}
78
79		public IXmlNode CreateProcessingInstruction(string target, string data)
80		{
81	0	return new XmlNodeWrapper(_document.CreateProcessingInstruction(target, data));
82	0	}
83
84		public IXmlElement CreateElement(string elementName)
85		{
86	77	return new XmlElementWrapper(_document.CreateElement(elementName));
87	77	}
88
89		public IXmlElement CreateElement(string qualifiedName, string namespaceURI)
90		{
91	10	return new XmlElementWrapper(_document.CreateElement(qualifiedName, namespaceURI));
92	10	}
93
94		public IXmlNode CreateAttribute(string name, string value)
95		{
96	29	XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(name));
97	29	attribute.Value = value;
98
99	29	return attribute;
100	29	}
101
102		public IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value)
103		{
104	8	XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(qualifiedName, namespaceURI));
105	8	attribute.Value = value;
106
107	8	return attribute;
108	8	}
109
110		public IXmlElement DocumentElement
111		{
112		get
113		{
114	21	if (_document.DocumentElement == null)
115	19	return null;
116
117	2	return new XmlElementWrapper(_document.DocumentElement);
118	21	}
119		}
120		}
121
122		internal class XmlElementWrapper : XmlNodeWrapper, IXmlElement
123		{
124		private XmlElement _element;
125
126	509	public XmlElementWrapper(XmlElement element)
127	509	: base(element)
128		{
129	509	_element = element;
130	509	}
131
132		public void SetAttributeNode(IXmlNode attribute)
133		{
134	37	XmlNodeWrapper xmlAttributeWrapper = (XmlNodeWrapper)attribute;
135
136	37	_element.SetAttributeNode((XmlAttribute) xmlAttributeWrapper.WrappedNode);
137	37	}
138		}
139
140		internal class XmlDeclarationWrapper : XmlNodeWrapper, IXmlDeclaration
141		{
142		private XmlDeclaration _declaration;
143
144	27	public XmlDeclarationWrapper(XmlDeclaration declaration)
145	27	: base(declaration)
146		{
147	27	_declaration = declaration;
148	27	}
149
150		public string Version
151		{
152	10	get { return _declaration.Version; }
153		}
154
155		public string Encoding
156		{
157	6	get { return _declaration.Encoding; }
158	0	set { _declaration.Encoding = value; }
159		}
160
161		public string Standalone
162		{
163	9	get { return _declaration.Standalone; }
164	0	set { _declaration.Standalone = value; }
165		}
166		}
167
168		internal class XmlNodeWrapper : IXmlNode
169		{
170		private readonly XmlNode _node;
171
172	1192	public XmlNodeWrapper(XmlNode node)
173		{
174	1192	_node = node;
175	1192	}
176
177		public object WrappedNode
178		{
179	51	get { return _node; }
180		}
181
182		public XmlNodeType NodeType
183		{
184	439	get { return _node.NodeType; }
185		}
186
187		public string Name
188		{
189	0	get { return _node.Name; }
190		}
191
192		public string LocalName
193		{
194	376	get { return _node.LocalName; }
195		}
196
197		public IList<IXmlNode> ChildNodes
198		{
199	355	get { return _node.ChildNodes.Cast<XmlNode>().Select(n => WrapNode(n)).ToList(); }
200		}
201
202		private IXmlNode WrapNode(XmlNode node)
203		{
204	981	switch (node.NodeType)
205		{
206		case XmlNodeType.Element:
207	420	return new XmlElementWrapper((XmlElement) node);
208		case XmlNodeType.XmlDeclaration:
209	27	return new XmlDeclarationWrapper((XmlDeclaration) node);
210		default:
211	534	return new XmlNodeWrapper(node);
212		}
213	981	}
214
215		public IList<IXmlNode> Attributes
216		{
217		get
218		{
219	388	if (_node.Attributes == null)
220	15	return null;
221
222	373	return _node.Attributes.Cast<XmlAttribute>().Select(a => WrapNode(a)).ToList();
223	388	}
224		}
225
226		public IXmlNode ParentNode
227		{
228		get
229		{
230	22	XmlNode node = (_node is XmlAttribute)
231	22	? ((XmlAttribute) _node).OwnerElement
232	22	: _node.ParentNode;
233
234	22	if (node == null)
235	18	return null;
236
237	4	return WrapNode(node);
238	22	}
239		}
240
241		public string Value
242		{
243	105	get { return _node.Value; }
244	37	set { _node.Value = value; }
245		}
246
247		public IXmlNode AppendChild(IXmlNode newChild)
248		{
249	137	XmlNodeWrapper xmlNodeWrapper = (XmlNodeWrapper) newChild;
250	137	_node.AppendChild(xmlNodeWrapper._node);
251
252	137	return newChild;
253	137	}
254
255		public string Prefix
256		{
257	0	get { return _node.Prefix; }
258		}
259
260		public string NamespaceURI
261		{
262	590	get { return _node.NamespaceURI; }
263		}
264		}
265
266		internal interface IXmlDocument : IXmlNode
267		{
268		IXmlNode CreateComment(string text);
269		IXmlNode CreateTextNode(string text);
270		IXmlNode CreateCDataSection(string data);
271		IXmlNode CreateWhitespace(string text);
272		IXmlNode CreateSignificantWhitespace(string text);
273		IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone);
274		IXmlNode CreateProcessingInstruction(string target, string data);
275		IXmlElement CreateElement(string elementName);
276		IXmlElement CreateElement(string qualifiedName, string namespaceURI);
277		IXmlNode CreateAttribute(string name, string value);
278		IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value);
279
280		IXmlElement DocumentElement { get; }
281		}
282
283		internal interface IXmlDeclaration : IXmlNode
284		{
285		string Version { get; }
286		string Encoding { get; set; }
287		string Standalone { get; set; }
288		}
289
290		internal interface IXmlElement : IXmlNode
291		{
292		void SetAttributeNode(IXmlNode attribute);
293		}
294
295		internal interface IXmlNode
296		{
297		XmlNodeType NodeType { get; }
298		string LocalName { get; }
299		IList<IXmlNode> ChildNodes { get; }
300		IList<IXmlNode> Attributes { get; }
301		IXmlNode ParentNode { get; }
302		string Value { get; set; }
303		IXmlNode AppendChild(IXmlNode newChild);
304		string NamespaceURI { get; }
305		object WrappedNode { get; }
306		}
307
308		#if !NET20
309		internal class XDeclarationWrapper : XObjectWrapper, IXmlDeclaration
310		{
311		internal readonly XDeclaration _declaration;
312
313	34	public XDeclarationWrapper(XDeclaration declaration)
314	34	: base(null)
315		{
316	34	_declaration = declaration;
317	34	}
318
319		public override XmlNodeType NodeType
320		{
321	15	get { return XmlNodeType.XmlDeclaration; }
322		}
323
324		public string Version
325		{
326	10	get { return _declaration.Version; }
327		}
328
329		public string Encoding
330		{
331	6	get { return _declaration.Encoding; }
332	0	set { _declaration.Encoding = value; }
333		}
334
335		public string Standalone
336		{
337	9	get { return _declaration.Standalone; }
338	0	set { _declaration.Standalone = value; }
339		}
340		}
341
342		internal class XDocumentWrapper : XContainerWrapper, IXmlDocument
343		{
344		private XDocument Document
345		{
346	108	get { return (XDocument)WrappedNode; }
347		}
348
349	29	public XDocumentWrapper(XDocument document)
350	29	: base(document)
351		{
352	29	}
353
354		public override IList<IXmlNode> ChildNodes
355		{
356		get
357		{
358	51	IList<IXmlNode> childNodes = base.ChildNodes;
359
360	51	if (Document.Declaration != null)
361	27	childNodes.Insert(0, new XDeclarationWrapper(Document.Declaration));
362
363	51	return childNodes;
364	51	}
365		}
366
367		public IXmlNode CreateComment(string text)
368		{
369	1	return new XObjectWrapper(new XComment(text));
370	1	}
371
372		public IXmlNode CreateTextNode(string text)
373		{
374	41	return new XObjectWrapper(new XText(text));
375	41	}
376
377		public IXmlNode CreateCDataSection(string data)
378		{
379	1	return new XObjectWrapper(new XCData(data));
380	1	}
381
382		public IXmlNode CreateWhitespace(string text)
383		{
384	0	return new XObjectWrapper(new XText(text));
385	0	}
386
387		public IXmlNode CreateSignificantWhitespace(string text)
388		{
389	0	return new XObjectWrapper(new XText(text));
390	0	}
391
392		public IXmlNode CreateXmlDeclaration(string version, string encoding, string standalone)
393		{
394	7	return new XDeclarationWrapper(new XDeclaration(version, encoding, standalone));
395	7	}
396
397		public IXmlNode CreateProcessingInstruction(string target, string data)
398		{
399	0	return new XProcessingInstructionWrapper(new XProcessingInstruction(target, data));
400	0	}
401
402		public IXmlElement CreateElement(string elementName)
403		{
404	77	return new XElementWrapper(new XElement(elementName));
405	77	}
406
407		public IXmlElement CreateElement(string qualifiedName, string namespaceURI)
408		{
409	10	string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
410	10	return new XElementWrapper(new XElement(XName.Get(localName, namespaceURI)));
411	10	}
412
413		public IXmlNode CreateAttribute(string name, string value)
414		{
415	29	return new XAttributeWrapper(new XAttribute(name, value));
416	29	}
417
418		public IXmlNode CreateAttribute(string qualifiedName, string namespaceURI, string value)
419		{
420	10	string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
421	10	return new XAttributeWrapper(new XAttribute(XName.Get(localName, namespaceURI), value));
422	10	}
423
424		public IXmlElement DocumentElement
425		{
426		get
427		{
428	21	if (Document.Root == null)
429	19	return null;
430
431	2	return new XElementWrapper(Document.Root);
432	21	}
433		}
434
435		public override IXmlNode AppendChild(IXmlNode newChild)
436		{
437	23	XDeclarationWrapper declarationWrapper = newChild as XDeclarationWrapper;
438	23	if (declarationWrapper != null)
439		{
440	7	Document.Declaration = declarationWrapper._declaration;
441	7	return declarationWrapper;
442		}
443		else
444		{
445	16	return base.AppendChild(newChild);
446		}
447	23	}
448		}
449
450		internal class XTextWrapper : XObjectWrapper
451		{
452		private XText Text
453		{
454	32	get { return (XText)WrappedNode; }
455		}
456
457	107	public XTextWrapper(XText text)
458	107	: base(text)
459		{
460	107	}
461
462		public override string Value
463		{
464	32	get { return Text.Value; }
465	0	set { Text.Value = value; }
466		}
467
468		public override IXmlNode ParentNode
469		{
470		get
471		{
472	0	if (Text.Parent == null)
473	0	return null;
474
475	0	return XContainerWrapper.WrapNode(Text.Parent);
476	0	}
477		}
478		}
479
480		internal class XCommentWrapper : XObjectWrapper
481		{
482		private XComment Text
483		{
484	1	get { return (XComment)WrappedNode; }
485		}
486
487	6	public XCommentWrapper(XComment text)
488	6	: base(text)
489		{
490	6	}
491
492		public override string Value
493		{
494	1	get { return Text.Value; }
495	0	set { Text.Value = value; }
496		}
497
498		public override IXmlNode ParentNode
499		{
500		get