2004-08-02 Atsushi Enomoto <atsushi@ximian.com>

	* XPathDocument.cs :
	  - For .NET 2.0, added a switch to support new XPathDocument2.
	    If switch is off, then it uses DTM.
	  - Implemented remaining 2.0 bits (except for Obsolete ones).

	To use them in XPathDocument, set environment MONO_XPATH_DOCUMENT_2=yes
	(It is still too unstable to pass all nunit tests and standalone XSLT
	tests).

svn path=/trunk/mcs/; revision=31724

diff --git a/mcs/class/System.XML/System.Xml.XPath/ChangeLog b/mcs/class/System.XML/System.Xml.XPath/ChangeLog
index 6351580aa26f4a0ef3ddf08a841029c69bb8bd96..9bf0a9d1756056bd4e925c68155931c45c8af8d6 100644 (file)
--- a/mcs/class/System.XML/System.Xml.XPath/ChangeLog
+++ b/mcs/class/System.XML/System.Xml.XPath/ChangeLog
@@ -1,3 +1,14 @@
+2004-08-02  Atsushi Enomoto  <atsushi@ximian.com>
+
+       * XPathDocument.cs :
+         - For .NET 2.0, added a switch to support new XPathDocument2. 
+           If switch is off, then it uses DTM.
+         - Implemented remaining 2.0 bits (except for Obsolete ones).
+
+       To use them in XPathDocument, set environment MONO_XPATH_DOCUMENT_2=yes
+       (It is still too unstable to pass all nunit tests and standalone XSLT
+       tests).
+
 2004-07-29  Atsushi Enomoto  <atsushi@ximian.com>
 
        * XPathNavigator.cs : Implemented ReadSubtree().

diff --git a/mcs/class/System.XML/System.Xml.XPath/XPathDocument.cs b/mcs/class/System.XML/System.Xml.XPath/XPathDocument.cs
index b765074ba46efd82a8dbfcff46ce7e49c7e93d02..bdce22707effb006873edbb58d9e05add437dbc9 100644 (file)
--- a/mcs/class/System.XML/System.Xml.XPath/XPathDocument.cs
+++ b/mcs/class/System.XML/System.Xml.XPath/XPathDocument.cs
@@ -45,18 +45,30 @@ namespace System.Xml.XPath
        [XmlSchemaProvider ("GetSchema")]
        public class XPathDocument : IXPathNavigable, IXPathEditable,
                IChangeTracking, IRevertibleChangeTracking, IXmlSerializable
-#else
-       public class XPathDocument : IXPathNavigable
-#endif
        {
-               DTMXPathDocument document;
-#if NET_2_0
-               XPathEditableDocument editable;
-#endif
+               // FIXME: In the future this switch will disappear.
+               // Regardless of this switch, those constructors that does 
+               // not take input document use editable XPathDocument.
+               static bool useEditable;
 
-#region Constructors
+               static XPathDocument ()
+               {
+                       // FIXME: remove when new XPathDocument2 got more 
+                       // stable. This environment value is temporary.
+                       if (Environment.GetEnvironmentVariable ("MONO_XPATH_DOCUMENT_2") == "yes")
+                               useEditable = true;
+               }
 
-#if NET_2_0
+               XPathDocument2Editable editable;
+               DTMXPathDocument dtm;
+
+               XmlSchemaSet schemas;
+
+               // save parameters
+               Encoding encoding;
+               bool preserveWhitespace;
+
+#region Constructors
                [MonoTODO]
                public XPathDocument ()
                        : this (new NameTable ())
@@ -66,7 +78,9 @@ namespace System.Xml.XPath
                [MonoTODO]
                public XPathDocument (XmlNameTable nameTable)
                {
-                       editable = new XPathEditableDocument (new XmlDocument (nameTable));
+                       editable = new XPathDocument2Editable (new XPathDocument2 (nameTable));
+
+                       InitializeEvents ();
                }
 
                public XPathDocument (Stream stream)
@@ -148,66 +162,47 @@ namespace System.Xml.XPath
                {
                        Initialize (reader, space, acceptChangesOnLoad);
                }
-#else
-               public XPathDocument (Stream stream)
-               {
-                       XmlValidatingReader vr = new XmlValidatingReader (new XmlTextReader (stream));
-                       vr.ValidationType = ValidationType.None;
-                       Initialize (vr, XmlSpace.None);
-               }
 
-               public XPathDocument (string uri) 
-                       : this (uri, XmlSpace.None)
-               {
-               }
-
-               public XPathDocument (TextReader reader)
-               {
-                       XmlValidatingReader vr = new XmlValidatingReader (new XmlTextReader (reader));
-                       vr.ValidationType = ValidationType.None;
-                       Initialize (vr, XmlSpace.None);
-               }
-
-               public XPathDocument (XmlReader reader)
-                       : this (reader, XmlSpace.None)
-               {
-               }
-
-               public XPathDocument (string uri, XmlSpace space)
+               private void Initialize (XmlReader reader, XmlSpace space, bool acceptChangesOnLoad)
                {
-                       XmlValidatingReader vr = null;
-                       try {
-                               vr = new XmlValidatingReader (new XmlTextReader (uri));
-                               vr.ValidationType = ValidationType.None;
-                               Initialize (vr, space);
-                       } finally {
-                               if (vr != null)
-                                       vr.Close ();
-                       }
+                       if (useEditable)
+                               InitializeEditable (reader, space, acceptChangesOnLoad);
+                       else
+                               dtm = new DTMXPathDocumentBuilder (reader, space).CreateDocument ();
                }
 
-               public XPathDocument (XmlReader reader, XmlSpace space)
+               private void InitializeEditable (XmlReader reader, XmlSpace space, bool acceptChangesOnLoad)
                {
-                       Initialize (reader, space);
-               }
-#endif
+                       XmlReaderSettings settings = new XmlReaderSettings ();
+                       settings.NameTable = reader.NameTable;
+                       settings.IgnoreWhitespace = (space == XmlSpace.Preserve);
+                       XmlReader r = XmlReader.Create (reader, settings);
+                       XPathDocument2 doc = new XPathDocument2 ();
+                       doc.Load (r, space);
+                       editable = new XPathDocument2Editable (doc);
+                       if (acceptChangesOnLoad)
+                               AcceptChanges ();
+                       this.preserveWhitespace = space == XmlSpace.Preserve;
+                       this.schemas = reader.Settings != null ? reader.Settings.Schemas : null;
 
-               private void Initialize (XmlReader reader, XmlSpace space)
-               {
-                       document = new DTMXPathDocumentBuilder (reader, space).CreateDocument ();
+                       InitializeEvents ();
                }
-
-               private void Initialize (XmlReader reader, XmlSpace space, bool acceptChangesOnLoad)
+               
+               private void InitializeEvents ()
                {
-                       document = new DTMXPathDocumentBuilder (reader, space).CreateDocument ();
+                       editable.ChangeRejected += this.ChangeRejected;
+                       editable.ItemUpdated += this.ItemUpdated;
+                       editable.ItemUpdating += this.ItemUpdating;
+                       editable.ItemInserted += this.ItemInserted;
+                       editable.ItemInserting += this.ItemInserting;
+                       editable.ItemDeleted += this.ItemDeleted;
+                       editable.ItemDeleting += this.ItemDeleting;
+                       editable.RejectingChange += this.RejectingChange;
                }
-
 #endregion
 
 #region Events
 
-#if NET_2_0
-
                public event NodeChangedEventHandler ChangeRejected;
 
                public event NodeChangedEventHandler ItemUpdated;
@@ -224,59 +219,46 @@ namespace System.Xml.XPath
 
                public event NodeChangedEventHandler RejectingChange;
 
-#endif // NET_2_0
-
 #endregion // Events
 
 #region Properties
 
-#if NET_2_0
-
                [MonoTODO]
                public bool EnableChangeTracking {
-                       get { throw new NotImplementedException (); }
-                       set { throw new NotImplementedException (); }
+                       get { return editable.EnableChangeTracking; }
+                       set { editable.EnableChangeTracking = value; }
                }
 
-               [MonoTODO]
                public Encoding Encoding {
-                       get { throw new NotImplementedException (); }
-                       set { throw new NotImplementedException (); }
+                       get { return encoding; }
+                       set { encoding = value; }
                }
 
                [MonoTODO]
                bool IChangeTracking.IsChanged {
-                       get { throw new NotImplementedException (); }
+                       get { return editable.IsChanged; }
                }
 
-               [MonoTODO]
                public XmlNameTable NameTable {
-                       get { throw new NotImplementedException (); }
+                       get { return editable.NameTable; }
                }
 
-               [MonoTODO]
                public bool PreserveWhiteSpace {
-                       get { throw new NotImplementedException (); }
+                       get { return preserveWhitespace; }
                }
 
-               [MonoTODO]
                public XmlSchemaSet Schemas {
-                       get { throw new NotImplementedException (); }
-                       set { throw new NotImplementedException (); }
+                       get { return schemas; }
+                       set { schemas = value; }
                }
 
-#endif // NET_2_0
-
 #endregion // Properies
 
-
 #region Methods
-
-#if NET_2_0
                [MonoTODO]
                public void AcceptChanges ()
                {
-                       throw new NotImplementedException ();
+                       editable.AcceptChanges ();
                }
 
                /* It will disappear in 2.0 RTM
@@ -287,21 +269,18 @@ namespace System.Xml.XPath
                }
                */
 
-               [MonoTODO]
                public XPathEditableNavigator CreateEditor ()
                {
-                       if (editable == null)
-                               throw new NotImplementedException ();
                        return editable.CreateEditor ();
                }
 
-               [MonoTODO ("This code is only for compatibility.")]
+               [MonoTODO ("Remove switch")]
                public XPathNavigator CreateNavigator ()
                {
-                       if (editable == null)
-                               return document.CreateNavigator ();
-                       else
+                       if (editable != null)
                                return editable.CreateNavigator ();
+                       else
+                               return dtm.CreateNavigator ();
                }
 
                public XmlWriter CreateWriter ()
@@ -312,7 +291,7 @@ namespace System.Xml.XPath
                [MonoTODO]
                public virtual XmlSchema GetSchema ()
                {
-                       throw new NotImplementedException ();
+                       return editable.GetSchema ();
                }
 
                [MonoTODO]
@@ -324,11 +303,10 @@ namespace System.Xml.XPath
                [MonoTODO]
                public bool HasChanges ()
                {
-                       if (editable == null)
-                               throw new NotImplementedException ();
                        return editable.HasChanges ();
                }
 
+               /* It will disappear in 2.0 RTM
                [Obsolete]
                [MonoTODO]
                public void LoadXml (string xml)  
@@ -338,33 +316,29 @@ namespace System.Xml.XPath
 //                     if (acceptChangesOnLoad)
 //                             AcceptChanges ();
                }
+               */
 
-               [MonoTODO]
                public void ReadXml (XmlReader reader)
                {
-                       if (editable == null)
-                               throw new NotImplementedException ();
                        editable.ReadXml (reader);
                }
 
                [MonoTODO]
                public void RejectChanges ()
                {
-                       if (editable == null)
-                               throw new NotImplementedException ();
                        editable.RejectChanges ();
                }
 
                [MonoTODO ("Confirm writer settings etc.")]
                public void Save (Stream stream)
                {
-                       Save (new XmlTextWriter (stream, null));
+                       Save (new XmlTextWriter (stream, encoding));
                }
 
                [MonoTODO ("Confirm writer settings etc.")]
                public void Save (string filename)
                {
-                       using (XmlWriter w = new XmlTextWriter (filename, null)) {
+                       using (XmlWriter w = new XmlTextWriter (filename, encoding)) {
                                Save (w);
                        }
                }
@@ -378,64 +352,132 @@ namespace System.Xml.XPath
                [MonoTODO]
                public void Save (XmlWriter writer)
                {
-                       throw new NotImplementedException ();
+                       writer.WriteNode (CreateNavigator ().ReadSubtree (), false);
                }
 
                [MonoTODO]
                public XPathNodeIterator SelectNodes (string xpath)
                {
-                       return SelectNodes (xpath, null);
+                       return CreateEditor ().Select (xpath);
                }
 
                [MonoTODO]
                public XPathNodeIterator SelectNodes (XPathExpression expr)
                {
-                       throw new NotImplementedException ();
+                       return CreateEditor ().Select (expr);
                }
 
                [MonoTODO]
                public XPathNodeIterator SelectNodes (string xpath ,IXmlNamespaceResolver nsResolver)
                {
-                       throw new NotImplementedException ();
+                       return CreateEditor ().Select (xpath, nsResolver);
                }
 
                [MonoTODO]
                public XPathEditableNavigator SelectSingleNode (string xpath)
                {
-                       return SelectSingleNode (xpath, null);
+                       XPathNodeIterator iter = CreateEditor ().Select (xpath);
+                       if (iter.MoveNext ())
+                               return (XPathEditableNavigator) iter.Current;
+                       else
+                               return null;
                }
 
                [MonoTODO]
                public XPathEditableNavigator SelectSingleNode (XPathExpression expr)
                {
-                       throw new NotImplementedException ();
+                       XPathNodeIterator iter = CreateEditor ().Select (expr);
+                       if (iter.MoveNext ())
+                               return (XPathEditableNavigator) iter.Current;
+                       else
+                               return null;
                }
 
                [MonoTODO]
                public XPathEditableNavigator SelectSingleNode (string xpath ,IXmlNamespaceResolver nsResolver)
                {
-                       throw new NotImplementedException ();
+                       XPathNodeIterator iter = CreateEditor ().Select (xpath, nsResolver);
+                       if (iter.MoveNext ())
+                               return (XPathEditableNavigator) iter.Current;
+                       else
+                               return null;
                }
 
                [MonoTODO]
                public void WriteXml (XmlWriter writer)
                {
-                       throw new NotImplementedException ();
+                       Save (writer);
                }
+#endregion
+       }
+
 
 #else // !NET_2_0
 
-               public XPathNavigator CreateNavigator ()
+       public class XPathDocument : IXPathNavigable
+       {
+               DTMXPathDocument document;
+
+               public XPathDocument (Stream stream)
                {
-                       return document.CreateNavigator ();
+                       XmlValidatingReader vr = new XmlValidatingReader (new XmlTextReader (stream));
+                       vr.ValidationType = ValidationType.None;
+                       Initialize (vr, XmlSpace.None);
                }
 
-#endif
+               public XPathDocument (string uri) 
+                       : this (uri, XmlSpace.None)
+               {
+               }
 
-#endregion
+               public XPathDocument (TextReader reader)
+               {
+                       XmlValidatingReader vr = new XmlValidatingReader (new XmlTextReader (reader));
+                       vr.ValidationType = ValidationType.None;
+                       Initialize (vr, XmlSpace.None);
+               }
 
+               public XPathDocument (XmlReader reader)
+                       : this (reader, XmlSpace.None)
+               {
+               }
+
+               public XPathDocument (string uri, XmlSpace space)
+               {
+                       XmlValidatingReader vr = null;
+                       try {
+                               vr = new XmlValidatingReader (new XmlTextReader (uri));
+                               vr.ValidationType = ValidationType.None;
+                               Initialize (vr, space);
+                       } finally {
+                               if (vr != null)
+                                       vr.Close ();
+                       }
+               }
+
+               public XPathDocument (XmlReader reader, XmlSpace space)
+               {
+                       Initialize (reader, space);
+               }
+
+               private void Initialize (XmlReader reader, XmlSpace space)
+               {
+                       document = new DTMXPathDocumentBuilder (reader, space).CreateDocument ();
+               }
+
+               private void Initialize (XmlReader reader, XmlSpace space, bool acceptChangesOnLoad)
+               {
+                       document = new DTMXPathDocumentBuilder (reader, space).CreateDocument ();
+               }
+
+               public XPathNavigator CreateNavigator ()
+               {
+                       return document.CreateNavigator ();
+               }
        }
 
+#endif
+
 }