X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.XML%2FSystem.Xml%2FXmlDocument.cs;h=e54a1ed4dcc9111d7104a74683a9c7453010063a;hb=daa30f4735aa3e56cd6331ead4e6378fcedcfcb1;hp=e73e079402033570365f67a8b0c17ae75622903b;hpb=f0499ad934fe84bf9b6c3d1267730c5854edfb32;p=mono.git diff --git a/mcs/class/System.XML/System.Xml/XmlDocument.cs b/mcs/class/System.XML/System.Xml/XmlDocument.cs index e73e0794020..e54a1ed4dcc 100644 --- a/mcs/class/System.XML/System.Xml/XmlDocument.cs +++ b/mcs/class/System.XML/System.Xml/XmlDocument.cs @@ -1,30 +1,65 @@ -// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- // // System.Xml.XmlDocument // -// Author: +// Authors: // Daniel Weber (daniel-weber@austin.rr.com) +// Kral Ferch +// Jason Diamond +// Miguel de Icaza (miguel@ximian.com) +// Duncan Mak (duncan@ximian.com) +// Atsushi Enomoto (ginga@kit.hi-ho.ne.jp) // // (C) 2001 Daniel Weber +// (C) 2002 Kral Ferch, Jason Diamond, Miguel de Icaza, Duncan Mak, +// Atsushi Enomoto +// using System; using System.IO; +using System.Text; +using System.Xml.XPath; +using System.Diagnostics; +using System.Collections; namespace System.Xml { - - public delegate void XmlNodeChangedEventHandler (XmlNodeChangedEventArgs args); - - /// - /// Abstract class XmlNodeList. - /// public class XmlDocument : XmlNode { - // Private data members - XmlResolver _resolver = null; + #region Fields + + XmlLinkedNode lastLinkedChild; + XmlNameTable nameTable; + string baseURI = String.Empty; + XmlImplementation implementation; + bool preserveWhitespace = false; + WeakReference reusableXmlTextReader; + + #endregion + + #region Constructors + + public XmlDocument () : this (null, null) + { + } + + protected internal XmlDocument (XmlImplementation imp) : this (imp, null) + { + } + + public XmlDocument (XmlNameTable nt) : this (null, nt) + { + } + + XmlDocument (XmlImplementation impl, XmlNameTable nt) : base (null) + { + implementation = (impl != null) ? impl : new XmlImplementation (); + nameTable = (nt != null) ? nt : implementation.internalNameTable; + AddDefaultNameTableKeys (); + } + #endregion + + #region Events - // Public events - //=========================================================================== public event XmlNodeChangedEventHandler NodeChanged; public event XmlNodeChangedEventHandler NodeChanging; @@ -37,29 +72,31 @@ namespace System.Xml public event XmlNodeChangedEventHandler NodeRemoving; - // public properties + #endregion - /// - /// Get the base URI for this document (the location from where the document was loaded) - /// - /// If a document was loaded with doc.Load("c:\tmp\mydoc.xml"), - /// then BaseURI would hold "c:\tmp\mydoc.xml" - public override string BaseURI - { - get - { - // TODO - implement XmlDocument.BaseURI {get;} - throw new NotImplementedException("BaseURI.get not implemented"); + #region Properties + + public override string BaseURI { + get { + return baseURI; } } - /// - /// Get the root element for the document. If no root exists, null is returned. - /// - public XmlElement DocumentElement - { - get - { + // Used to read 'InnerXml's for its descendants at any place. + internal XmlTextReader ReusableReader { + get { + if(reusableXmlTextReader == null) + reusableXmlTextReader = new WeakReference (null); + if(!reusableXmlTextReader.IsAlive) { + XmlTextReader reader = new XmlTextReader ((TextReader)null); + reusableXmlTextReader.Target = reader; + } + return (XmlTextReader)reusableXmlTextReader.Target; + } + } + + public XmlElement DocumentElement { + get { XmlNode node = FirstChild; while (node != null) { @@ -72,440 +109,783 @@ namespace System.Xml } } - /// - /// Gets the node containing the DOCTYPE declaration. - /// - public virtual XmlDocumentType DocumentType - { - get - { - // TODO - implement XmlDocument.DocumentType - throw new NotImplementedException("XmlDocument.DocumentType not implemented"); + [MonoTODO("It doesn't have internal subset object model.")] + public virtual XmlDocumentType DocumentType { + get { + foreach(XmlNode n in this.ChildNodes) { + if(n.NodeType == XmlNodeType.DocumentType) + return (XmlDocumentType)n; + } + return null; } } + public XmlImplementation Implementation { + get { return implementation; } + } - /// - /// Get the XmlImplemenation for the current document. - /// - public XmlImplementation Implementation - { - get - { - // TODO - implement XmlDocument.Implementation - throw new NotImplementedException("Implementation not implemented"); + public override string InnerXml { + get { + return base.InnerXml; + } + set { // reason for overriding + this.LoadXml (value); } } + public override bool IsReadOnly { + get { return false; } + } - /// - /// Get/Set the markup representing the children of the document. - /// - public override string InnerXml - { - get - { - // TODO - implement XmlDocument.InnerXml {get;} - throw new NotImplementedException("InnerXml get not implemented"); + internal override XmlLinkedNode LastLinkedChild { + get { + return lastLinkedChild; } - set - { - // TODO - implement XmlDocument.InnerXml {set;} - throw new NotImplementedException("InnerXml set not implemented"); + + set { + lastLinkedChild = value; } } + + public override string LocalName { + get { return "#document"; } + } - /// - /// Get a value indicating if the document is read-only. - /// - public override bool IsReadOnly - { - get - { - return false; - } + public override string Name { + get { return "#document"; } } - /// - /// Get the local name of the node. For documents, returns "#document" - /// - public override string LocalName { - get - { - return "#document"; - } + public XmlNameTable NameTable { + get { return nameTable; } } - /// - /// Get the qualified name of the node. For documents, returns "#document" - /// - public override string Name - { - get - { - return "#document"; - } + public override XmlNodeType NodeType { + get { return XmlNodeType.Document; } } - public XmlNameTable NameTable - { - get - { - // TODO - implement XmlDocument.NameTable {get;} - throw new NotImplementedException("NameTable get not implemented"); + internal override XPathNodeType XPathNodeType { + get { + return XPathNodeType.Root; } } + public override XmlDocument OwnerDocument { + get { return null; } + } - public override XmlNodeType NodeType - { - get - { - return XmlNodeType.Document; - } + public bool PreserveWhitespace { + get { return preserveWhitespace; } + set { preserveWhitespace = value; } } - /// - /// Returns OwnerDocument. For an XmlDocument, this property is always null. - /// - public override XmlDocument OwnerDocument - { - get - { - return null; - } + internal override string XmlLang { + get { return String.Empty; } } - public bool PreserveWhitespace - { - get - { - // TODO - implement XmlDocument.PreserveWhitespace {get;} - throw new NotImplementedException("PreserveWhitespace get not implemented"); - } - set - { - // TODO - implement XmlDocument.PreserveWhitespace {set;} - throw new NotImplementedException("PreserveWhitespace set not implemented"); + [MonoTODO] + public virtual XmlResolver XmlResolver { + set { throw new NotImplementedException (); } + } + + internal override XmlSpace XmlSpace { + get { + return XmlSpace.None; } } - public XmlResolver XmlResolver + #endregion + + #region Methods + + [MonoTODO("Should BaseURI be cloned?")] + public override XmlNode CloneNode (bool deep) { - set + XmlDocument doc = implementation.CreateDocument (); + doc.PreserveWhitespace = PreserveWhitespace; // required? + if(deep) { - // TODO - Finish/test XmlDocument.XmlResolver {set;} - _resolver = value; + foreach(XmlNode n in ChildNodes) + doc.AppendChild (doc.ImportNode (n, deep)); } + return doc; } - // Public Methods - //=========================================================================== - public override XmlNode CloneNode(bool deep) + public XmlAttribute CreateAttribute (string name) { - // TODO - implement XmlDocument.CloneNode(bool) - throw new NotImplementedException("CloneNode(bool) not implemented"); + return CreateAttribute (name, String.Empty); } - public XmlAttribute CreateAttribute(string name) + public XmlAttribute CreateAttribute (string qualifiedName, string namespaceURI) { - // TODO - implement XmlDocument.CreateAttribute(string name) - throw new NotImplementedException("CreateAttribute(string name) not implemented"); + string prefix; + string localName; + + ParseName (qualifiedName, out prefix, out localName); + + return CreateAttribute (prefix, localName, namespaceURI); } - public XmlAttribute CreateAttribute(string qualifiedName,string namespaceURI) + public virtual XmlAttribute CreateAttribute (string prefix, string localName, string namespaceURI) { - // TODO - implement XmlDocument.CreateAttribute(string, string) - throw new NotImplementedException("CreateAttribute(string, string) not implemented"); + if ((localName == null) || (localName == String.Empty)) + throw new ArgumentException ("The attribute local name cannot be empty."); + + return new XmlAttribute (prefix, localName, namespaceURI, this); } - public virtual XmlAttribute CreateAttribute( - string prefix, - string localName, - string namespaceURI - ) + public virtual XmlCDataSection CreateCDataSection (string data) { - // TODO - implement XmlDocument.CreateAttribute(prefix, localName, namespaceURI) - throw new NotImplementedException("CreateAttribute(prefix, localName, namespaceURI) not implemented"); + return new XmlCDataSection (data, this); } - public virtual XmlCDataSection CreateCDataSection(string data) + public virtual XmlComment CreateComment (string data) { - // TODO - implement XmlDocument.CreateCDataSection(string data) - throw new NotImplementedException("CreateCDataSection(string data) not implemented"); + return new XmlComment (data, this); } - - public virtual XmlComment CreateComment(string data) + [MonoTODO] + protected internal virtual XmlAttribute CreateDefaultAttribute (string prefix, string localName, string namespaceURI) { - // TODO - implement XmlDocument.CreateComment(string data) - throw new NotImplementedException("CreateComment(string data) not implemented"); + throw new NotImplementedException (); } - public virtual XmlDocumentFragment CreateDocumentFragment() + public virtual XmlDocumentFragment CreateDocumentFragment () { - // TODO - implement XmlDocument.CreateDocumentFragment - throw new NotImplementedException("CreateDocumentFragment not implemented"); + return new XmlDocumentFragment (this); } - public virtual XmlDocumentType CreateDocumentType( - string name, - string publicId, - string systemId, - string internalSubset - ) + public virtual XmlDocumentType CreateDocumentType (string name, string publicId, + string systemId, string internalSubset) { - // TODO - implement XmlDocument.CreateDocumentType - throw new NotImplementedException("CreateDocumentType not implemented"); + return new XmlDocumentType (name, publicId, systemId, internalSubset, this); } - public XmlElement CreateElement(string name) + public XmlElement CreateElement (string name) { - // TODO - implement XmlDocument.CreateElement(string name) - throw new NotImplementedException("CreateElement(string name) not implemented"); + return CreateElement (name, String.Empty); } - public XmlElement CreateElement( - string qualifiedName, - string namespaceURI - ) + public XmlElement CreateElement ( + string qualifiedName, + string namespaceURI) { - // TODO - implement XmlDocument.CreateElement(string qualifiedName, string namespaceURI) - throw new NotImplementedException("CreateElement(string qualifiedName, string namespaceURI) not implemented"); + string prefix; + string localName; + + ParseName (qualifiedName, out prefix, out localName); + + return CreateElement (prefix, localName, namespaceURI); } - public virtual XmlElement CreateElement( + public virtual XmlElement CreateElement ( string prefix, string localName, - string namespaceURI - ) + string namespaceURI) { - return new XmlElement(prefix, localName, namespaceURI, this); + if ((localName == null) || (localName == String.Empty)) + throw new ArgumentException ("The local name for elements or attributes cannot be null or an empty string."); + CheckName (localName); + return new XmlElement (prefix != null ? prefix : String.Empty, localName, namespaceURI != null ? namespaceURI : String.Empty, this); } + public virtual XmlEntityReference CreateEntityReference (string name) + { + return new XmlEntityReference (name, this); + } - public virtual XmlEntityReference CreateEntityReference(string name) + [MonoTODO] + internal protected virtual XPathNavigator CreateNavigator (XmlNode node) { - // TODO - implement XmlDocument.CreateEntityReference - throw new NotImplementedException("XmlDocument.CreateEntityReference not implemented."); + throw new NotImplementedException (); } - public virtual XmlNode CreateNode( + public virtual XmlNode CreateNode ( string nodeTypeString, string name, - string namespaceURI - ) + string namespaceURI) { - // TODO - implement XmlDocument.CreateNode(string, string, string) - throw new NotImplementedException("XmlDocument.CreateNode not implemented."); + return CreateNode (GetNodeTypeFromString (nodeTypeString), name, namespaceURI); } - public virtual XmlNode CreateNode( + public virtual XmlNode CreateNode ( XmlNodeType type, string name, - string namespaceURI - ) + string namespaceURI) { - // TODO - implement XmlDocument.CreateNode(XmlNodeType, string, string) - throw new NotImplementedException("XmlDocument.CreateNode not implemented."); + string prefix = null; + string localName = name; + + if ((type == XmlNodeType.Attribute) || (type == XmlNodeType.Element) || (type == XmlNodeType.EntityReference)) + ParseName (name, out prefix, out localName); + + return CreateNode (type, prefix, localName, namespaceURI); } - public virtual XmlNode CreateNode( + public virtual XmlNode CreateNode ( XmlNodeType type, string prefix, string name, - string namespaceURI - ) - { - // TODO - implement XmlDocument.CreateNode(XmlNodeType, string, string, string) - throw new NotImplementedException("XmlDocument.CreateNode not implemented."); + string namespaceURI) + { + switch (type) { + case XmlNodeType.Attribute: return CreateAttribute (prefix, name, namespaceURI); + case XmlNodeType.CDATA: return CreateCDataSection (null); + case XmlNodeType.Comment: return CreateComment (null); + case XmlNodeType.Document: return new XmlDocument (); // TODO - test to see which constructor to use, i.e. use existing NameTable or not. + case XmlNodeType.DocumentFragment: return CreateDocumentFragment (); + case XmlNodeType.DocumentType: return CreateDocumentType (null, null, null, null); + case XmlNodeType.Element: return CreateElement (prefix, name, namespaceURI); + case XmlNodeType.EntityReference: return CreateEntityReference (null); + case XmlNodeType.ProcessingInstruction: return CreateProcessingInstruction (null, null); + case XmlNodeType.SignificantWhitespace: return CreateSignificantWhitespace (String.Empty); + case XmlNodeType.Text: return CreateTextNode (null); + case XmlNodeType.Whitespace: return CreateWhitespace (String.Empty); + case XmlNodeType.XmlDeclaration: return CreateXmlDeclaration ("1.0", null, null); + default: throw new ArgumentOutOfRangeException(String.Format("{0}\nParameter name: {1}", + "Specified argument was out of the range of valid values", type.ToString ())); + } } - public virtual XmlProcessingInstruction CreateProcessingInstruction( + public virtual XmlProcessingInstruction CreateProcessingInstruction ( string target, - string data - ) + string data) { - // TODO - implement XmlDocument.CreateProcessingInstruction - throw new NotImplementedException("XmlDocument.CreateProcessingInstruction not implemented."); + return new XmlProcessingInstruction (target, data, this); } - public virtual XmlSignificantWhitespace CreateSignificantWhitespace(string text ) + public virtual XmlSignificantWhitespace CreateSignificantWhitespace (string text) { - // TODO - implement XmlDocument.CreateSignificantWhitespace - throw new NotImplementedException("XmlDocument.CreateSignificantWhitespace not implemented."); + foreach (char c in text) + if ((c != ' ') && (c != '\r') && (c != '\n') && (c != '\t')) + throw new ArgumentException ("Invalid whitespace characters."); + + return new XmlSignificantWhitespace (text, this); } - public virtual XmlText CreateTextNode(string text) + public virtual XmlText CreateTextNode (string text) { - // TODO - implement XmlDocument.CreateTextNode - throw new NotImplementedException("XmlDocument.CreateTextNode not implemented."); + return new XmlText (text, this); } - public virtual XmlWhitespace CreateWhitespace(string text) + public virtual XmlWhitespace CreateWhitespace (string text) { - // TODO - implement XmlDocument.CreateWhitespace - throw new NotImplementedException("XmlDocument.CreateWhitespace not implemented."); + foreach (char c in text) + if ((c != ' ') && (c != '\r') && (c != '\n') && (c != '\t')) + throw new ArgumentException ("Invalid whitespace characters."); + + return new XmlWhitespace (text, this); } - public virtual XmlDeclaration CreateXmlDeclaration( - string version, - string encoding, - string standalone - ) + public virtual XmlDeclaration CreateXmlDeclaration (string version, string encoding, + string standalone) { - // TODO - implement XmlDocument.CreateXmlDeclaration - throw new NotImplementedException("XmlDocument.CreateXmlDeclaration not implemented."); - } + if (version != "1.0") + throw new ArgumentException ("version string is not correct."); - public virtual XmlElement GetElementById(string elementId) - { - // TODO - implement XmlDocument.GetElementById - throw new NotImplementedException("XmlDocument.GetElementById not implemented."); - } + if ((standalone != null && standalone != String.Empty) && !((standalone == "yes") || (standalone == "no"))) + throw new ArgumentException ("standalone string is not correct."); - public virtual XmlNodeList GetElementsByTagName(string name) - { - // TODO - implement XmlDocument.GetElementsByTagName(name) - throw new NotImplementedException("XmlDocument.GetElementsByTagName not implemented."); + return new XmlDeclaration (version, encoding, standalone, this); } - public virtual XmlNodeList GetElementsByTagName( - string localName, - string namespaceURI - ) + [MonoTODO] + public virtual XmlElement GetElementById (string elementId) { - // TODO - implement XmlDocument.GetElementsByTagName(localName, namespaceURI) - throw new NotImplementedException("XmlDocument.GetElementsByTagName not implemented."); + throw new NotImplementedException (); } - public virtual XmlNode ImportNode( - XmlNode node, - bool deep - ) + public virtual XmlNodeList GetElementsByTagName (string name) { - // TODO - implement XmlDocument.ImportNode - throw new NotImplementedException("XmlDocument.ImportNode not implemented."); + ArrayList nodeArrayList = new ArrayList (); + this.searchNodesRecursively (this, name, nodeArrayList); + return new XmlNodeArrayList (nodeArrayList); } - public virtual void Load(Stream inStream) + private void searchNodesRecursively (XmlNode argNode, string argName, + ArrayList argArrayList) { - // TODO - implement XmlDocument.Load(Stream) - throw new NotImplementedException("XmlDocument.Load(Stream) not implemented."); + XmlNodeList xmlNodeList = argNode.ChildNodes; + foreach (XmlNode node in xmlNodeList){ + if (node.Name.Equals (argName)) + argArrayList.Add (node); + else + this.searchNodesRecursively (node, argName, argArrayList); + } } - public virtual void Load(string filename) + private void searchNodesRecursively (XmlNode argNode, string argName, string argNamespaceURI, + ArrayList argArrayList) { - // TODO - implement XmlDocument.Load(string) - throw new NotImplementedException("XmlDocument.Load(string) not implemented."); + XmlNodeList xmlNodeList = argNode.ChildNodes; + foreach (XmlNode node in xmlNodeList){ + if (node.LocalName.Equals (argName) && node.NamespaceURI.Equals (argNamespaceURI)) + argArrayList.Add (node); + else + this.searchNodesRecursively (node, argName, argNamespaceURI, argArrayList); + } } - public virtual void Load(TextReader txtReader) + public virtual XmlNodeList GetElementsByTagName (string localName, string namespaceURI) { - // TODO - implement XmlDocument.Load(TextReader) - throw new NotImplementedException("XmlDocument.Load(TextReader) not implemented."); + ArrayList nodeArrayList = new ArrayList (); + this.searchNodesRecursively (this, localName, namespaceURI, nodeArrayList); + return new XmlNodeArrayList (nodeArrayList); } - public virtual void Load(XmlReader reader) + private XmlNodeType GetNodeTypeFromString (string nodeTypeString) { - // TODO - implement XmlDocument.Load(XmlReader) - throw new NotImplementedException("XmlDocument.Load(XmlReader) not implemented."); + switch (nodeTypeString) { + case "attribute": return XmlNodeType.Attribute; + case "cdatasection": return XmlNodeType.CDATA; + case "comment": return XmlNodeType.Comment; + case "document": return XmlNodeType.Document; + case "documentfragment": return XmlNodeType.DocumentFragment; + case "documenttype": return XmlNodeType.DocumentType; + case "element": return XmlNodeType.Element; + case "entityreference": return XmlNodeType.EntityReference; + case "processinginstruction": return XmlNodeType.ProcessingInstruction; + case "significantwhitespace": return XmlNodeType.SignificantWhitespace; + case "text": return XmlNodeType.Text; + case "whitespace": return XmlNodeType.Whitespace; + default: + throw new ArgumentException(String.Format("The string doesn't represent any node type : {0}.", nodeTypeString)); + } } - public virtual void LoadXml(string xml) + [MonoTODO("default attributes (of imported doc); Entity; Notation")] + public virtual XmlNode ImportNode (XmlNode node, bool deep) { - // TODO - implement XmlDocument.LoadXml - throw new NotImplementedException("XmlDocument.LoadXml not implemented."); + switch(node.NodeType) + { + case XmlNodeType.Attribute: + { + XmlAttribute src_att = node as XmlAttribute; + XmlAttribute dst_att = this.CreateAttribute (src_att.Prefix, src_att.LocalName, src_att.NamespaceURI); + dst_att.Value = src_att.Value; // always explicitly specified (whether source is specified or not) + return dst_att; + } + + case XmlNodeType.CDATA: + return this.CreateCDataSection (node.Value); + + case XmlNodeType.Comment: + return this.CreateComment (node.Value); + + case XmlNodeType.Document: + throw new XmlException ("Document cannot be imported."); + + case XmlNodeType.DocumentFragment: + { + XmlDocumentFragment df = this.CreateDocumentFragment (); + if(deep) + { + foreach(XmlNode n in node.ChildNodes) + { + df.AppendChild (this.ImportNode (n, deep)); + } + } + return df; + } + + case XmlNodeType.DocumentType: + throw new XmlException ("DocumentType cannot be imported."); + + case XmlNodeType.Element: + { + XmlElement src = (XmlElement)node; + XmlElement dst = this.CreateElement (src.Prefix, src.LocalName, src.NamespaceURI); + foreach(XmlAttribute attr in src.Attributes) + { + if(attr.Specified) // copies only specified attributes + dst.SetAttributeNode ((XmlAttribute)this.ImportNode (attr, deep)); + if(DocumentType != null) + { + // TODO: create default attribute values + } + } + if(deep) + { + foreach(XmlNode n in src.ChildNodes) + dst.AppendChild (this.ImportNode (n, deep)); + } + return dst; + } + + case XmlNodeType.EndElement: + throw new XmlException ("Illegal ImportNode call for NodeType.EndElement"); + case XmlNodeType.EndEntity: + throw new XmlException ("Illegal ImportNode call for NodeType.EndEntity"); + + case XmlNodeType.Entity: + throw new NotImplementedException (); // TODO + + case XmlNodeType.EntityReference: + return this.CreateEntityReference (node.Name); + + case XmlNodeType.None: + throw new XmlException ("Illegal ImportNode call for NodeType.None"); + + case XmlNodeType.Notation: + throw new NotImplementedException (); // TODO + + case XmlNodeType.ProcessingInstruction: + XmlProcessingInstruction pi = node as XmlProcessingInstruction; + return this.CreateProcessingInstruction (pi.Target, pi.Data); + + case XmlNodeType.SignificantWhitespace: + return this.CreateSignificantWhitespace (node.Value); + + case XmlNodeType.Text: + return this.CreateTextNode (node.Value); + + case XmlNodeType.Whitespace: + return this.CreateWhitespace (node.Value); + + case XmlNodeType.XmlDeclaration: + XmlDeclaration srcDecl = node as XmlDeclaration; + return this.CreateXmlDeclaration (srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone); + + default: + throw new NotImplementedException (); + } } - public virtual void Save(Stream outStream) + public virtual void Load (Stream inStream) { - // TODO - implement XmlDocument.Save(Stream) - throw new NotImplementedException("XmlDocument.Save(Stream) not implemented."); + XmlReader xmlReader = new XmlTextReader (inStream); + Load (xmlReader); } - public virtual void Save(string filename) + public virtual void Load (string filename) { - // TODO - implement XmlDocument.Save(string) - throw new NotImplementedException("XmlDocument.Save(string) not implemented."); + baseURI = filename; + XmlReader xmlReader = new XmlTextReader (new StreamReader (filename)); + Load (xmlReader); } - public virtual void Save(TextWriter writer) + public virtual void Load (TextReader txtReader) { - // TODO - implement XmlDocument.Save(TextWriter) - throw new NotImplementedException("XmlDocument.Save(TextWriter) not implemented."); + Load (new XmlTextReader (txtReader)); } - public virtual void Save(XmlWriter writer) + public virtual void Load (XmlReader xmlReader) { - // TODO - implement XmlDocument.Save(XmlWriter) - throw new NotImplementedException("XmlDocument.Save(XmlWriter) not implemented."); + // Reset our document + // For now this just means removing all our children but later this + // may turn out o need to call a private method that resets other things + // like properties we have, etc. + RemoveAll (); + + // create all contents with use of ReadNode() + do { + XmlNode n = ReadNode (xmlReader); + if(n == null) break; + AppendChild (n); + } while (true); } - public override void WriteContentTo(XmlWriter w) + public virtual void LoadXml (string xml) { - // TODO - implement XmlDocument.WriteContentTo - throw new NotImplementedException("XmlDocument.WriteContentTo not implemented."); + XmlReader xmlReader = new XmlTextReader (new StringReader (xml)); + Load (xmlReader); } - public override void WriteTo(XmlWriter w) + internal void onNodeChanged (XmlNode node, XmlNode Parent) { - // TODO - implement XmlDocument.WriteTo - throw new NotImplementedException("XmlDocument.WriteTo not implemented."); + if (NodeChanged != null) + NodeChanged (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Change, + node, Parent, Parent)); } - - // Internal functions - //=========================================================================== internal void onNodeChanging(XmlNode node, XmlNode Parent) { - if (NodeInserting != null) - NodeChanging( new XmlNodeChangedEventArgs(XmlNodeChangedAction.Change, + if (NodeChanging != null) + NodeChanging (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Change, node, Parent, Parent)); } - internal void onNodeChanged(XmlNode node, XmlNode Parent) + internal void onNodeInserted (XmlNode node, XmlNode newParent) { - if (NodeChanged != null) - NodeInserted( new XmlNodeChangedEventArgs(XmlNodeChangedAction.Change, - node, Parent, Parent)); + if (NodeInserted != null) + NodeInserted (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Insert, + node, null, newParent)); } - internal void onNodeInserting(XmlNode node, XmlNode newParent) + internal void onNodeInserting (XmlNode node, XmlNode newParent) { if (NodeInserting != null) - NodeInserting( new XmlNodeChangedEventArgs(XmlNodeChangedAction.Insert, + NodeInserting (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Insert, node, null, newParent)); } - internal void onNodeInserted(XmlNode node, XmlNode newParent) + internal void onNodeRemoved (XmlNode node, XmlNode oldParent) { - if (NodeInserted != null) - NodeInserted( new XmlNodeChangedEventArgs(XmlNodeChangedAction.Insert, - node, null, newParent)); + if (NodeRemoved != null) + NodeRemoved (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Remove, + node, oldParent, null)); } - internal void onNodeRemoving(XmlNode node, XmlNode oldParent) + internal void onNodeRemoving (XmlNode node, XmlNode oldParent) { if (NodeRemoving != null) - NodeRemoving(new XmlNodeChangedEventArgs(XmlNodeChangedAction.Remove, + NodeRemoving (node, new XmlNodeChangedEventArgs + (XmlNodeChangedAction.Remove, node, oldParent, null)); } - internal void onNodeRemoved(XmlNode node, XmlNode oldParent) + private void ParseName (string name, out string prefix, out string localName) { - if (NodeRemoved != null) - NodeRemoved(new XmlNodeChangedEventArgs(XmlNodeChangedAction.Remove, - node, oldParent, null)); + int indexOfColon = name.IndexOf (':'); + + if (indexOfColon != -1) { + prefix = name.Substring (0, indexOfColon); + localName = name.Substring (indexOfColon + 1); + } else { + prefix = ""; + localName = name; + } + } + + // Checks that Element's name is valid + private void CheckName (String name) + { + // TODO: others validations? + if (name.IndexOf (" ") >= 0) + throw new XmlException ("The ' ' characted cannot be included in a name"); + } + // Reads XmlReader and creates Attribute Node. + private XmlAttribute ReadAttributeNode(XmlReader reader) + { + if(reader.NodeType == XmlNodeType.Element) + reader.MoveToFirstAttribute (); + else if(reader.NodeType != XmlNodeType.Attribute) + throw new InvalidOperationException ("bad position to read attribute."); + XmlAttribute attribute = CreateAttribute (reader.Prefix, reader.LocalName, reader.NamespaceURI); + ReadAttributeNodeValue (reader, attribute); + return attribute; } - // Constructors - //=========================================================================== - public XmlDocument() : base(null) + // Reads attribute from XmlReader and then creates attribute value children. XmlAttribute also uses this. + internal void ReadAttributeNodeValue(XmlReader reader, XmlAttribute attribute) { + while(reader.ReadAttributeValue ()) { + if(reader.NodeType == XmlNodeType.EntityReference) + // FIXME: if DocumentType is available, then try to resolve it. + attribute.AppendChild (CreateEntityReference (reader.Name)); + // FIXME: else if(NodeType == EndEntity) -- reset BaseURI and so on -- ; + else + // (IMHO) Children of Attribute is likely restricted to Text and EntityReference. + attribute.AppendChild (CreateTextNode (reader.Value)); + } } + [MonoTODO("DTD parser is not completed.")] + public virtual XmlNode ReadNode(XmlReader reader) + { + // This logic was formerly defined in 'XmlNode.ConstructDOM()' + + XmlNode resultNode = null; + XmlNode newNode = null; + XmlNode currentNode = null; + // It was originally XmlDocument.Load(reader reader) when mcs was v0.16. + int startDepth = reader.Depth; + bool atStart = true; + bool ignoredWhitespace; + + do { + ignoredWhitespace = false; + reader.Read (); + // This complicated check is because we shouldn't make + // improper additional XmlReader.Read() by this method itself. + if(atStart && (reader.NodeType == XmlNodeType.EndElement || + reader.NodeType == XmlNodeType.EndEntity)) + throw new InvalidOperationException ("the XmlReader now holds invalid position."); + atStart = false; + switch (reader.NodeType) { + + case XmlNodeType.Attribute: + newNode = ReadAttributeNode (reader); + break; + + case XmlNodeType.CDATA: + newNode = CreateCDataSection (reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.Comment: + newNode = CreateComment (reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.Element: + XmlElement element = CreateElement (reader.Prefix, reader.LocalName, reader.NamespaceURI); + element.IsEmpty = reader.IsEmptyElement; + if(currentNode != null) + currentNode.AppendChild (element); + else + resultNode = element; + + // set the element's attributes. + while (reader.MoveToNextAttribute ()) { + element.SetAttributeNode (ReadAttributeNode (reader)); + } + + reader.MoveToElement (); + + if (!reader.IsEmptyElement) + currentNode = element; + + break; + + case XmlNodeType.EndElement: + if(currentNode.Name != reader.Name) + throw new XmlException ("mismatch end tag."); + currentNode = currentNode.ParentNode; + break; + + case XmlNodeType.EndEntity: + break; // no operation + + case XmlNodeType.ProcessingInstruction: + newNode = CreateProcessingInstruction (reader.Name, reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.Text: + newNode = CreateTextNode (reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.XmlDeclaration: + // empty strings are dummy, then gives over setting value contents to setter. + newNode = CreateXmlDeclaration ("1.0" , String.Empty, String.Empty); + ((XmlDeclaration)newNode).Value = reader.Value; + if(currentNode != null) + throw new XmlException ("XmlDeclaration at invalid position."); + break; + + case XmlNodeType.DocumentType: + // This logic is kinda hack;-) + XmlTextReader xtReader = reader as XmlTextReader; + if(xtReader == null) { + xtReader = new XmlTextReader (reader.ReadOuterXml (), + XmlNodeType.DocumentType, + new XmlParserContext (NameTable, ConstructNamespaceManager(), XmlLang, XmlSpace)); + xtReader.Read (); + } + newNode = CreateDocumentType (xtReader.Name, + xtReader.GetAttribute ("PUBLIC"), + xtReader.GetAttribute ("SYSTEM"), + xtReader.Value); + if(currentNode != null) + throw new XmlException ("XmlDocumentType at invalid position."); + break; + + case XmlNodeType.EntityReference: + newNode = CreateEntityReference (reader.Name); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.SignificantWhitespace: + newNode = CreateSignificantWhitespace (reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + break; + + case XmlNodeType.Whitespace: + if(PreserveWhitespace) { + newNode = CreateWhitespace (reader.Value); + if(currentNode != null) + currentNode.AppendChild (newNode); + } + else + ignoredWhitespace = true; + break; + } + } while(ignoredWhitespace || + reader.Depth > startDepth || + // This complicated condition is because reader.Depth was set + // before XmlTextReader.depth increments ;-) + (reader.Depth == startDepth && reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement == false) + ); + return resultNode != null ? resultNode : newNode; + } + public virtual void Save(Stream outStream) + { + XmlTextWriter xmlWriter = new XmlTextWriter (outStream, Encoding.UTF8); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Close (); + } + + public virtual void Save (string filename) + { + XmlTextWriter xmlWriter = new XmlTextWriter (filename, Encoding.UTF8); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Close (); + } + + [MonoTODO] + public virtual void Save (TextWriter writer) + { + XmlTextWriter xmlWriter = new XmlTextWriter (writer); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Flush (); + } + + public virtual void Save (XmlWriter xmlWriter) + { + // + // This should preserve white space if PreserveWhiteSpace is true + // + WriteContentTo (xmlWriter); + xmlWriter.Flush (); + } + + public override void WriteContentTo (XmlWriter w) + { + foreach(XmlNode childNode in ChildNodes) { + childNode.WriteTo (w); + } + } + + public override void WriteTo (XmlWriter w) + { + WriteContentTo (w); + } + + private void AddDefaultNameTableKeys () + { + // The following keys are default of MS .NET Framework + nameTable.Add ("#text"); + nameTable.Add ("xml"); + nameTable.Add ("xmlns"); + nameTable.Add ("#entity"); + nameTable.Add ("#document-fragment"); + nameTable.Add ("#comment"); + nameTable.Add ("space"); + nameTable.Add ("id"); + nameTable.Add ("#whitespace"); + nameTable.Add ("http://www.w3.org/2000/xmlns/"); + nameTable.Add ("#cdata-section"); + nameTable.Add ("lang"); + nameTable.Add ("#document"); + nameTable.Add ("#significant-whitespace"); + } + #endregion } }