X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.XML%2FSystem.Xml%2FXmlDocument.cs;h=fcf8d9b17b98b2b68f143a51db5e66d43264f648;hb=5a8beb8931ee636c5dbbb169739242a8f8446f55;hp=0fd361d683f2585a7dd61f13131f8049427f6262;hpb=cc63806f23d224ad6ea46485edd831afee937a3c;p=mono.git diff --git a/mcs/class/System.XML/System.Xml/XmlDocument.cs b/mcs/class/System.XML/System.Xml/XmlDocument.cs index 0fd361d683f..fcf8d9b17b9 100644 --- a/mcs/class/System.XML/System.Xml/XmlDocument.cs +++ b/mcs/class/System.XML/System.Xml/XmlDocument.cs @@ -1,15 +1,26 @@ // // 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; +using Mono.Xml.Native; namespace System.Xml { @@ -19,24 +30,33 @@ namespace System.Xml XmlLinkedNode lastLinkedChild; XmlNameTable nameTable; + string baseURI = String.Empty; + XmlImplementation implementation; + bool preserveWhitespace = false; + WeakReference reusableXmlTextReader; #endregion #region Constructors - public XmlDocument () : base (null) { } + public XmlDocument () : this (null, null) + { + } - [MonoTODO] - protected internal XmlDocument (XmlImplementation imp) : base (null) + protected internal XmlDocument (XmlImplementation imp) : this (imp, null) { - throw new NotImplementedException (); } - public XmlDocument (NameTable nt) : base (null) + public XmlDocument (XmlNameTable nt) : this (null, nt) { - nameTable = nt; } + XmlDocument (XmlImplementation impl, XmlNameTable nt) : base (null) + { + implementation = (impl != null) ? impl : new XmlImplementation (); + nameTable = (nt != null) ? nt : implementation.internalNameTable; + AddDefaultNameTableKeys (); + } #endregion #region Events @@ -57,9 +77,23 @@ namespace System.Xml #region Properties - [MonoTODO] public override string BaseURI { - get { throw new NotImplementedException(); } + get { + return baseURI; + } + } + + // 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 { @@ -76,20 +110,28 @@ namespace System.Xml } } - [MonoTODO] + [MonoTODO("It doesn't have internal subset object model.")] public virtual XmlDocumentType DocumentType { - get { throw new NotImplementedException(); } + get { + foreach(XmlNode n in this.ChildNodes) { + if(n.NodeType == XmlNodeType.DocumentType) + return (XmlDocumentType)n; + } + return null; + } } - [MonoTODO] public XmlImplementation Implementation { - get { throw new NotImplementedException(); } + get { return implementation; } } - [MonoTODO] public override string InnerXml { - get { throw new NotImplementedException(); } - set { throw new NotImplementedException(); } + get { + return base.InnerXml; + } + set { // reason for overriding + this.LoadXml (value); + } } public override bool IsReadOnly { @@ -122,61 +164,73 @@ namespace System.Xml get { return XmlNodeType.Document; } } + internal override XPathNodeType XPathNodeType { + get { + return XPathNodeType.Root; + } + } + public override XmlDocument OwnerDocument { get { return null; } } - [MonoTODO] public bool PreserveWhitespace { - get { throw new NotImplementedException(); } - set { throw new NotImplementedException(); } + get { return preserveWhitespace; } + set { preserveWhitespace = value; } + } + + internal override string XmlLang { + get { return String.Empty; } } [MonoTODO] public virtual XmlResolver XmlResolver { - set { throw new NotImplementedException(); } + set { throw new NotImplementedException (); } + } + + internal override XmlSpace XmlSpace { + get { + return XmlSpace.None; + } } #endregion #region Methods - [MonoTODO] + [MonoTODO("Should BaseURI be cloned?")] public override XmlNode CloneNode (bool deep) { - throw new NotImplementedException (); + XmlDocument doc = implementation.CreateDocument (); + doc.PreserveWhitespace = PreserveWhitespace; // required? + if(deep) + { + foreach(XmlNode n in ChildNodes) + doc.AppendChild (doc.ImportNode (n, deep)); + } + return doc; } - [MonoTODO] public XmlAttribute CreateAttribute (string name) { - int indexOfColon = name.IndexOf (':'); - - if (indexOfColon == -1) - return CreateAttribute (String.Empty, name, String.Empty); - - string prefix = name.Substring (0, indexOfColon); - string localName = name.Substring (indexOfColon + 1); - - return CreateAttribute (prefix, localName, String.Empty); + return CreateAttribute (name, String.Empty); } - [MonoTODO] public XmlAttribute CreateAttribute (string qualifiedName, string namespaceURI) { - int indexOfColon = qualifiedName.IndexOf (':'); - - if (indexOfColon == -1) - return CreateAttribute (String.Empty, qualifiedName, String.Empty); + string prefix; + string localName; - string prefix = qualifiedName.Substring (0, indexOfColon); - string localName = qualifiedName.Substring (indexOfColon + 1); + ParseName (qualifiedName, out prefix, out localName); - return CreateAttribute (prefix, localName, String.Empty); + return CreateAttribute (prefix, localName, namespaceURI); } public virtual XmlAttribute CreateAttribute (string prefix, string localName, string namespaceURI) { + if ((localName == null) || (localName == String.Empty)) + throw new ArgumentException ("The attribute local name cannot be empty."); + return new XmlAttribute (prefix, localName, namespaceURI, this); } @@ -187,7 +241,7 @@ namespace System.Xml public virtual XmlComment CreateComment (string data) { - return new XmlComment(data, this); + return new XmlComment (data, this); } [MonoTODO] @@ -196,10 +250,9 @@ namespace System.Xml throw new NotImplementedException (); } - [MonoTODO] public virtual XmlDocumentFragment CreateDocumentFragment () { - throw new NotImplementedException (); + return new XmlDocumentFragment (this); } public virtual XmlDocumentType CreateDocumentType (string name, string publicId, @@ -210,30 +263,18 @@ namespace System.Xml public XmlElement CreateElement (string name) { - int indexOfColon = name.IndexOf (':'); - - if (indexOfColon == -1) - return CreateElement (String.Empty, name, String.Empty); - - string prefix = name.Substring (0, indexOfColon); - string localName = name.Substring (indexOfColon + 1); - - return CreateElement (prefix, localName, String.Empty); + return CreateElement (name, String.Empty); } - [MonoTODO] public XmlElement CreateElement ( string qualifiedName, string namespaceURI) { - int indexOfColon = qualifiedName.IndexOf (':'); - - if (indexOfColon == -1) - return CreateElement (String.Empty, qualifiedName, namespaceURI); - - string prefix = qualifiedName.Substring (0, indexOfColon); - string localName = qualifiedName.Substring (indexOfColon + 1); + string prefix; + string localName; + ParseName (qualifiedName, out prefix, out localName); + return CreateElement (prefix, localName, namespaceURI); } @@ -242,47 +283,68 @@ namespace System.Xml string localName, 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); } - [MonoTODO] public virtual XmlEntityReference CreateEntityReference (string name) { - throw new NotImplementedException (); + return new XmlEntityReference (name, this); } [MonoTODO] - protected internal virtual XPathNavigator CreateNavigator (XmlNode node) + internal protected virtual XPathNavigator CreateNavigator (XmlNode node) { throw new NotImplementedException (); } - [MonoTODO] public virtual XmlNode CreateNode ( string nodeTypeString, string name, string namespaceURI) { - throw new NotImplementedException (); + return CreateNode (GetNodeTypeFromString (nodeTypeString), name, namespaceURI); } - [MonoTODO] public virtual XmlNode CreateNode ( XmlNodeType type, string name, string namespaceURI) { - throw new NotImplementedException (); + 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); } - [MonoTODO] public virtual XmlNode CreateNode ( XmlNodeType type, string prefix, string name, string namespaceURI) { - throw new NotImplementedException (); + 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 ( @@ -321,9 +383,9 @@ namespace System.Xml if (version != "1.0") throw new ArgumentException ("version string is not correct."); - if ((standalone != null) && !((standalone == "yes") || (standalone == "no"))) + if ((standalone != null && standalone != String.Empty) && !((standalone == "yes") || (standalone == "no"))) throw new ArgumentException ("standalone string is not correct."); - + return new XmlDeclaration (version, encoding, standalone, this); } @@ -333,40 +395,176 @@ namespace System.Xml throw new NotImplementedException (); } - [MonoTODO] public virtual XmlNodeList GetElementsByTagName (string name) { - throw new NotImplementedException (); + ArrayList nodeArrayList = new ArrayList (); + this.searchNodesRecursively (this, name, nodeArrayList); + return new XmlNodeArrayList (nodeArrayList); + } + + private void searchNodesRecursively (XmlNode argNode, string argName, + ArrayList argArrayList) + { + XmlNodeList xmlNodeList = argNode.ChildNodes; + foreach (XmlNode node in xmlNodeList){ + if (node.Name.Equals (argName)) + argArrayList.Add (node); + else + this.searchNodesRecursively (node, argName, argArrayList); + } + } + + private void searchNodesRecursively (XmlNode argNode, string argName, string argNamespaceURI, + ArrayList argArrayList) + { + 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); + } } - [MonoTODO] public virtual XmlNodeList GetElementsByTagName (string localName, string namespaceURI) { - throw new NotImplementedException(); + ArrayList nodeArrayList = new ArrayList (); + this.searchNodesRecursively (this, localName, namespaceURI, nodeArrayList); + return new XmlNodeArrayList (nodeArrayList); + } + + private XmlNodeType GetNodeTypeFromString (string nodeTypeString) + { + 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)); + } } - [MonoTODO] + [MonoTODO("default attributes (of imported doc); Entity; Notation")] public virtual XmlNode ImportNode (XmlNode node, bool deep) { - throw new NotImplementedException (); + 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 (); + } } - [MonoTODO] public virtual void Load (Stream inStream) { - throw new NotImplementedException (); + XmlReader xmlReader = new XmlTextReader (new XmlInputStream (inStream)); + Load (xmlReader); } public virtual void Load (string filename) { - XmlReader xmlReader = new XmlTextReader (new StreamReader (filename)); - Load (xmlReader); + Load (new XmlTextReader (filename)); } - [MonoTODO] public virtual void Load (TextReader txtReader) { - throw new NotImplementedException (); + Load (new XmlTextReader (txtReader)); } public virtual void Load (XmlReader xmlReader) @@ -377,54 +575,12 @@ namespace System.Xml // like properties we have, etc. RemoveAll (); - XmlNode currentNode = this; - XmlNode newNode; - - while (xmlReader.Read ()) - { - switch (xmlReader.NodeType) { - - case XmlNodeType.CDATA: - newNode = CreateCDataSection(xmlReader.Value); - currentNode.AppendChild (newNode); - break; - - case XmlNodeType.Comment: - newNode = CreateComment (xmlReader.Value); - currentNode.AppendChild (newNode); - break; - - case XmlNodeType.Element: - XmlElement element = CreateElement (xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI); - currentNode.AppendChild (element); - - // set the element's attributes. - while (xmlReader.MoveToNextAttribute ()) - element.SetAttribute (xmlReader.Name, xmlReader.Value); - - xmlReader.MoveToElement (); - - // if this element isn't empty, push it onto our "stack". - if (!xmlReader.IsEmptyElement) - currentNode = element; - - break; - - case XmlNodeType.EndElement: - currentNode = currentNode.ParentNode; - break; - - case XmlNodeType.ProcessingInstruction: - newNode = CreateProcessingInstruction (xmlReader.Name, xmlReader.Value); - currentNode.AppendChild (newNode); - break; - - case XmlNodeType.Text: - newNode = CreateTextNode (xmlReader.Value); - currentNode.AppendChild (newNode); - break; - } - } + // create all contents with use of ReadNode() + do { + XmlNode n = ReadNode (xmlReader); + if(n == null) break; + AppendChild (n); + } while (true); } public virtual void LoadXml (string xml) @@ -436,14 +592,14 @@ namespace System.Xml internal void onNodeChanged (XmlNode node, XmlNode Parent) { if (NodeChanged != null) - NodeInserted (node, new XmlNodeChangedEventArgs + NodeChanged (node, new XmlNodeChangedEventArgs (XmlNodeChangedAction.Change, node, Parent, Parent)); } internal void onNodeChanging(XmlNode node, XmlNode Parent) { - if (NodeInserting != null) + if (NodeChanging != null) NodeChanging (node, new XmlNodeChangedEventArgs (XmlNodeChangedAction.Change, node, Parent, Parent)); @@ -481,47 +637,254 @@ namespace System.Xml node, oldParent, null)); } - [MonoTODO] + private void ParseName (string name, out string prefix, out string localName) + { + 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; + } + + // 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) { - throw new NotImplementedException (); + // This logic was formerly defined in 'XmlNode.ConstructDOM()' + + XmlNode resultNode = null; + XmlNode newNode = null; + XmlNode currentNode = null; + + if (reader.ReadState == ReadState.Initial) + reader.Read (); + + // It was originally XmlDocument.Load(reader reader) when mcs was v0.16. + int startDepth = reader.Depth; +// bool atStart = true; + bool ignoredWhitespace; + bool reachedEOF = false; + + do { + ignoredWhitespace = false; + if (reader.NodeType == XmlNodeType.None) + if (reachedEOF) + throw new Exception ("XML Reader reached to end while reading node."); + else + reachedEOF = true; + 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 == null || 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; + } + reader.Read (); + } while (ignoredWhitespace || reader.Depth > startDepth || + (reader.Depth == startDepth && reader.NodeType == XmlNodeType.EndElement)); + return resultNode != null ? resultNode : newNode; } - [MonoTODO] public virtual void Save(Stream outStream) { - throw new NotImplementedException (); + XmlTextWriter xmlWriter = new XmlTextWriter (outStream, Encoding.UTF8); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Close (); } - [MonoTODO] public virtual void Save (string filename) { - throw new NotImplementedException (); + XmlTextWriter xmlWriter = new XmlTextWriter (filename, Encoding.UTF8); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Close (); } [MonoTODO] public virtual void Save (TextWriter writer) { - throw new NotImplementedException (); + XmlTextWriter xmlWriter = new XmlTextWriter (writer); + xmlWriter.Formatting = Formatting.Indented; + WriteContentTo (xmlWriter); + xmlWriter.Flush (); } - [MonoTODO] - public virtual void Save (XmlWriter writer) + public virtual void Save (XmlWriter xmlWriter) { - throw new NotImplementedException (); + // + // 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); + foreach(XmlNode childNode in ChildNodes) { + childNode.WriteTo (w); + } } public override void WriteTo (XmlWriter w) { - WriteContentTo(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 } }