-// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
-// System.Xml.XmlNode
+// System.Xml.XmlProcessingInstruction
//
// Author:
-// Daniel Weber (daniel-weber@austin.rr.com)
+// Kral Ferch <kral_ferch@hotmail.com>
+//
+// (C) 2002 Kral Ferch
//
-// (C) 2001 Daniel Weber
using System;
using System.Collections;
using System.Xml.XPath;
-namespace System.Xml
+namespace System.Xml
{
- public abstract class XmlNode : ICloneable, IEnumerable, IXPathNavigable
+ public abstract class XmlNode : ICloneable, IEnumerable, IXPathNavigable
{
- //======= Private data members ==============================================
- private XmlNodeListAsArrayList _childNodes;
- protected XmlDocument FOwnerDocument;
- protected XmlNode _parent;
-
- // Names of node
- // for <foo:bar xmlns:foo="http://www.foobar.com/schema/foobar">... </foo:bar>
- // qualified name: foo:bar
- // namespaceURI = "http://www.foobar.com/schema/foobar"
- // localName = bar
- // prefix = foo
- // Note that namespaces can be nested (child namespace != parent namespace)
- // namespaces are optional
- protected string Fname;
- protected string FnamespaceURI;
- protected string Fprefix;
- protected string FlocalName;
-
- // baseURI holds the location from which the document was loaded
- // If the node was created from a document at c:\tmp.xml, then that's what will be here
- protected string FbaseURI;
-
- // value of the node (overriden in classes that do something different)
- // default behavior is just to store it
- protected string Fvalue;
-
- //=====================================================================
- // ============ Properties ============================================
- //=====================================================================
- /// <summary>
- /// Get the XmlAttributeCollection representing the attributes
- /// on the node type. Returns null if the node type is not XmlElement.
- /// </summary>
- public virtual XmlAttributeCollection Attributes
- {
- get
- {
- return null;
- }
- }
- /// <summary>
- /// Return the base Uniform Resource Indicator (URI) used to resolve
- /// this node, or String.Empty.
- /// </summary>
- public virtual string BaseURI
+ XmlDocument ownerDocument;
+ XmlNode parentNode;
+
+ #region Constructors
+
+ protected internal XmlNode(XmlDocument ownerDocument)
{
- get
- {
- return FbaseURI;
- }
+ this.ownerDocument = ownerDocument;
+ }
+ #endregion
+
+ #region Properties
+
+ public virtual XmlAttributeCollection Attributes
+ {
+ get { return null; }
}
- /// <summary>
- /// Return all child nodes of this node. If there are no children,
- /// return an empty XmlNodeList;
- /// </summary>
- public virtual XmlNodeList ChildNodes
+
+ [MonoTODO]
+ public virtual string BaseURI
{
- get
- {
- if (_childNodes == null)
- _childNodes = new XmlNodeListAsArrayList();
+ get { throw new NotImplementedException (); }
+ }
- return _childNodes as XmlNodeList;
- }
+ [MonoTODO]
+ public virtual XmlNodeList ChildNodes
+ {
+ get { throw new NotImplementedException (); }
}
-
- /// <summary>
- /// Return first child node as XmlNode or null
- /// if the node has no children
- /// </summary>
- public virtual XmlNode FirstChild
+
+ public virtual XmlNode FirstChild
{
- get
- {
- if (ChildNodes.Count == 0)
+ get {
+ if (LastChild != null) {
+ return LastLinkedChild.NextLinkedSibling;
+ }
+ else {
return null;
- else
- return ChildNodes[0];
+ }
}
}
- /// <summary>
- /// Return true if the node has children
- /// </summary>
- public virtual bool HasChildNodes
+ public virtual bool HasChildNodes
{
- get
- {
- if (ChildNodes.Count == 0)
- return true;
- else
- return false;
- }
+ get { return LastChild != null; }
}
- /// <summary>
- /// Get or Set the concatenated values of node and children
- /// </summary>
+ [MonoTODO]
public virtual string InnerText
{
- get
- {
- // TODO - implement set InnerText()
- throw new NotImplementedException();
- }
-
- set
- {
- // TODO - implement set InnerText()
- throw new NotImplementedException();
- }
+ get { throw new NotImplementedException (); }
+ set { throw new NotImplementedException (); }
}
- /// <summary>
- /// Get/Set the XML representing just the child nodes of this node
- /// </summary>
+ [MonoTODO]
public virtual string InnerXml
{
- get
- {
- // TODO - implement set InnerXml()
- throw new NotImplementedException();
- }
-
- set
- {
- // TODO - implement set InnerXml()
- throw new NotImplementedException();
- }
+ get { throw new NotImplementedException (); }
+ set { throw new NotImplementedException (); }
}
- /// <summary>
- /// Property Get - true if node is read-only
- /// </summary>
+ [MonoTODO]
public virtual bool IsReadOnly
{
- get
- {
- return OwnerDocument.IsReadOnly;
- }
+ get { throw new NotImplementedException (); }
}
- /// <summary>
- /// Return the child element named [string]. Returns XmlElement
- /// Indexer for XmlNode class.
- /// </summary>
- [System.Runtime.CompilerServices.IndexerNameAttribute("Item")]
- public virtual XmlElement this [String index]
+ [MonoTODO]
+ public virtual XmlElement this[string name]
{
- get
- {
- // TODO - implement XmlNode.Item(string)
- throw new NotImplementedException();
- }
+ get { throw new NotImplementedException (); }
+ }
+
+ [MonoTODO]
+ public virtual XmlElement this[string localname, string ns]
+ {
+ get { throw new NotImplementedException (); }
}
- /// <summary>
- /// Get the last child node, or null if there are no nodes
- /// </summary>
public virtual XmlNode LastChild
{
- get
- {
- if (_childNodes.Count == 0)
- return null;
- else
- return _childNodes.Item(_childNodes.Count - 1);
- }
+ get { return LastLinkedChild; }
+ }
+ internal virtual XmlLinkedNode LastLinkedChild
+ {
+ get { return null; }
+ set { }
}
- /// <summary>
- /// Returns the local name of the node with qualifiers removed
- /// LocalName of ns:elementName = "elementName"
- /// </summary>
- public abstract string LocalName {get;}
+ [MonoTODO]
+ public abstract string LocalName
+ {
+ get;
+ }
- /// <summary>
- /// Get the qualified node name
- /// derived classes must implement as behavior varies
- /// by tag type.
- /// </summary>
- public abstract string Name { get; }
+ [MonoTODO]
+ public abstract string Name
+ {
+ get;
+ }
- /// <summary>
- /// Get the namespace URI or String.Empty if none
- /// </summary>
+ [MonoTODO]
public virtual string NamespaceURI
{
- get
- {
- // TODO - implement Namespace URI, or determine abstractness
- throw new NotImplementedException("XmlNode.NamespaceURI not implemented");
- }
+ get { throw new NotImplementedException (); }
}
- /// <summary>
- /// Get the node immediatelly following this node, or null
- /// </summary>
- public virtual XmlNode NextSibling
+ public virtual XmlNode NextSibling
{
- get
- {
-
- if (_parent != null)
- {
- XmlNodeListAsArrayList children = _parent.ChildNodes as XmlNodeListAsArrayList;
- int ourIndex = children.data.IndexOf(this);
- return children[ourIndex + 1];
- }
- else
- return null;
- }
+ get { return null; }
}
- public virtual XmlNodeType NodeType
+ [MonoTODO]
+ public abstract XmlNodeType NodeType
{
- get
- {
- return XmlNodeType.None;
- }
+ get;
}
- /// <summary>
- /// Return the string representing this node and all it's children
- /// </summary>
+ [MonoTODO]
public virtual string OuterXml
{
- get
- {
- // TODO - implement OuterXml {get;}
- throw new NotImplementedException();
- }
+ get { throw new NotImplementedException (); }
}
- /// <summary>
- /// Return owning document.
- /// If this nodeType is a document, return null
- /// </summary>
public virtual XmlDocument OwnerDocument
{
- get
- {
- return FOwnerDocument;
- }
+ get { return ownerDocument; }
}
- /// <summary>
- /// Returns the parent node, or null
- /// Return value depends on superclass node type
- /// </summary>
public virtual XmlNode ParentNode
{
- get
- {
- return _parent;
- }
+ get { return parentNode; }
}
-
- /// <summary>
- /// set/get the namespace prefix for this node, or
- /// string.empty if it does not exist
- /// </summary>
- public virtual string Prefix
+
+ [MonoTODO]
+ public virtual string Prefix
{
- get
- {
- return Fprefix;
- }
-
- set
- {
- // TODO - validation on XmlNode.Prefix {set;}? (no)
- Fprefix = value;
- }
+ get { throw new NotImplementedException (); }
+ set { throw new NotImplementedException (); }
}
- /// <summary>
- /// The preceding XmlNode or null
- /// </summary>
- public virtual XmlNode PreviousSibling {
- get
- {
- if (_parent != null)
- {
- XmlNodeListAsArrayList children = _parent.ChildNodes as XmlNodeListAsArrayList;
- int ourIndex = children.data.IndexOf(this);
- return children[ourIndex - 1];
- }
- else
- return null;
- }
+ public virtual XmlNode PreviousSibling
+ {
+ get { return null; }
+ }
+
+ [MonoTODO]
+ public virtual string Value
+ {
+ get { throw new NotImplementedException (); }
+ set { throw new NotImplementedException (); }
}
- /// <summary>
- /// Get/Set the value for this node
- /// </summary>
- public virtual string Value
+ #endregion
+
+ #region Methods
+
+ public virtual XmlNode AppendChild (XmlNode newChild)
{
- get
- {
- return Fvalue;
+ if ((NodeType == XmlNodeType.Document) || (NodeType == XmlNodeType.Element)) {
+ LastLinkedChild = (XmlLinkedNode) newChild;
+ return LastChild;
}
-
- set
- {
- Fvalue = value;
+ else {
+ throw new InvalidOperationException();
}
}
- //=====================================================================
- //======= Methods =====================================================
- //=====================================================================
- /// <summary>
- /// Appends the specified node to the end of the child node list
- /// </summary>
- /// <param name="newChild"></param>
- /// <returns></returns>
- public virtual XmlNode AppendChild (XmlNode newChild)
+ [MonoTODO]
+ public virtual XmlNode Clone ()
{
- ((XmlNodeListAsArrayList)ChildNodes).Add(newChild);
- return newChild;
- }
-
- /// <summary>
- /// Return a clone of this node
- /// </summary>
- /// <returns></returns>
- public virtual object Clone()
- {
- // TODO - implement XmlNode.Clone() as object
- throw new NotImplementedException("object XmlNode.Clone() not implmented");
- }
-
- /// <summary>
- /// Return a clone of the node
- /// </summary>
- /// <param name="deep">Make copy of all children</param>
- /// <returns>Cloned node</returns>
- public abstract XmlNode CloneNode( bool deep);
-
- /// <summary>
- /// Return an XPathNavigator for navigating this node
- /// </summary>
- /// <returns></returns>
- public System.Xml.XPath.XPathNavigator CreateNavigator()
- {
- // TODO - implement CreateNavigator()
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Provide support for "for each"
- /// </summary>
- /// <returns></returns>
- public IEnumerator GetEnumerator()
- {
- return _childNodes.data.GetEnumerator();
- }
-
- /// <summary>
- /// Look up the closest namespace for this node that is in scope for the given prefix
- /// </summary>
- /// <param name="prefix"></param>
- /// <returns>Namespace URI</returns>
- public virtual string GetNamespaceOfPrefix(string prefix)
- {
- // TODO - implement GetNamespaceOfPrefix()
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Get the closest xmlns declaration for the given namespace URI that is in scope.
- /// Returns the prefix defined in that declaration.
- /// </summary>
- /// <param name="namespaceURI"></param>
- /// <returns></returns>
- public virtual string GetPrefixOfNamespace(string namespaceURI)
- {
- // TODO - implement GetPrefixOfNamespace
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Insert newChild directly after the reference node.
- /// If refChild is null, newChild is inserted at the beginning of childnodes.
- /// If newChild is a document fragment, all nodes are inserted after refChild.
- /// If newChild is already in the tree, it is first removed.
- /// </summary>
- /// <exception cref="ArgumentException">NewChild was created from differant document.
- /// RefChild not a child of this node or null.
- /// Node is read-only</exception>
- /// <exception cref="InvalidOperationException">Node is of type that does not have children
- /// Node to insert is an ancestor of this node.</exception>
- /// <param name="newChild">Child node to insert.</param>
- /// <param name="refChild">Reference node to insert after</param>
- /// <returns>Removed node, or null if no node removed.</returns>
- public virtual XmlNode InsertAfter(XmlNode newChild, XmlNode refChild)
- {
- // Checks parent not ancestor, arguments valid, etc. Throws exception on error
- InsertionCheck(newChild, refChild);
-
- // Scan the node list, looking for refChild and seeing if newChild is in the list
- // Note that if refNode is null (prepend), we don't want to do the .Equals(null)
- XmlNode retval = null;
- int refNodeIndex = -1;
-
- for (int i = 0; i < _childNodes.Count; i++)
- {
- XmlNode e = _childNodes.data[i] as XmlNode;
- if (e.Equals(newChild))
- {
- retval = e;
- FOwnerDocument.onNodeRemoving(newChild, newChild.ParentNode);
- _childNodes.data.RemoveAt(i);
- newChild.setParent(null);
- FOwnerDocument.onNodeRemoved(newChild, null);
- break;
-
- }
+ throw new NotImplementedException ();
+ }
- if ( (refChild != null ) & ( e.Equals(refChild) ) )
- {
- refNodeIndex = i;
+ public abstract XmlNode CloneNode (bool deep);
- if (retval != null)
- break;
- }
- }
+ [MonoTODO]
+ public XPathNavigator CreateNavigator ()
+ {
+ throw new NotImplementedException ();
+ }
- if ( ( refNodeIndex == -1 ) & (refChild != null) )
- throw new ArgumentException("Reference node not found (and not null) in call to XmlNode.InsertAfter()");
-
- FOwnerDocument.onNodeInserting(newChild, this);
-
- if (refChild == null)
- refNodeIndex = 0;
- else
- refNodeIndex++; // insert after reference...
-
- if (newChild.NodeType == XmlNodeType.DocumentFragment)
- {
- // Insert all children, starting from refNodeIndex (0,1,2...n)
- for (int i = 0; i < newChild.ChildNodes.Count; i++)
- {
- XmlNode e = newChild.ChildNodes[i] as XmlNode;
- FOwnerDocument.onNodeInserting(e, this);
- _childNodes.data.Insert(refNodeIndex, newChild.ChildNodes[i]);
- e.setParent(this);
- FOwnerDocument.onNodeInserted(newChild, this);
- refNodeIndex ++;
- }
- }
- else
- {
- FOwnerDocument.onNodeInserting(newChild, this);
- _childNodes.data.Insert(refNodeIndex, newChild);
- newChild.setParent(this);
- FOwnerDocument.onNodeInserted(newChild, this);
- }
+ [MonoTODO]
+ public IEnumerator GetEnumerator ()
+ {
+ throw new NotImplementedException ();
+ }
- return retval;
- }
-
- /// <summary>
- /// Insert newChild directly before the reference node.
- /// If refChild is null, newChild is inserted at the end of childnodes.
- /// If newChild is a document fragment, all nodes are inserted before refChild.
- /// If newChild is already in the tree, it is first removed.
- /// </summary>
- /// <exception cref="ArgumentException">NewChild was created from different document.
- /// RefChild not a child of this node, or is null.
- /// Node is read-only</exception>
- /// <exception cref="InvalidOperationException">Node is of type that does not have children.
- /// Node to insert is an ancestor of this node.</exception>
- /// <param name="newChild">Child node to insert.</param>
- /// <param name="refChild">Reference node to insert after</param>
- /// <returns>Removed node, or null if no node removed.</returns>
- public virtual XmlNode InsertBefore(XmlNode newChild, XmlNode refChild)
- {
- // Checks parent not ancestor, arguments valid, etc. Throws exception on error
- InsertionCheck(newChild, refChild);
-
- // Scan the node list, looking for refChild and seeing if newChild is in the list
- XmlNode retval = null;
- int refNodeIndex = -1;
-
- for (int i = 0; i < _childNodes.Count; i++)
- {
- XmlNode e = _childNodes.data[i] as XmlNode;
- if (e.Equals(newChild))
- {
- retval = e;
- FOwnerDocument.onNodeRemoving(newChild, newChild.ParentNode);
- _childNodes.data.RemoveAt(i);
- newChild.setParent(null);
- FOwnerDocument.onNodeRemoved(newChild, null);
- break;
- }
+ [MonoTODO]
+ public virtual string GetNamespaceOfPrefix (string prefix)
+ {
+ throw new NotImplementedException ();
+ }
- if ( (refChild != null ) & ( e.Equals(refChild) ) )
- {
- refNodeIndex = i;
+ [MonoTODO]
+ public virtual string GetPrefixOfNamespace (string namespaceURI)
+ {
+ throw new NotImplementedException ();
+ }
- if (retval != null)
- break;
- }
- }
+ object ICloneable.Clone ()
+ {
+ return Clone ();
+ }
- if ( ( refNodeIndex == -1 ) & (refChild != null) )
- throw new ArgumentException("Reference node not found (and not null) in call to XmlNode.InsertAfter()");
-
- if (refChild == null)
- refNodeIndex = _childNodes.Count;
-
- if (newChild.NodeType == XmlNodeType.DocumentFragment)
- {
- // Insert all children, starting from refNodeIndex (0,1,2...n)
- for (int i = 0; i < newChild.ChildNodes.Count; i++)
- {
- XmlNode e = newChild.ChildNodes[i] as XmlNode;
- FOwnerDocument.onNodeInserting(e, this);
- _childNodes.data.Insert(refNodeIndex, newChild.ChildNodes[i]);
- e.setParent(this);
- FOwnerDocument.onNodeInserted(newChild, this);
- refNodeIndex ++;
- }
- }
- else
- {
- newChild.OwnerDocument.onNodeInserting(newChild, this);
- _childNodes.data.Insert(refNodeIndex, newChild);
- newChild.setParent(this);
- newChild.OwnerDocument.onNodeInserted(newChild, this);
- }
+ IEnumerator IEnumerable.GetEnumerator ()
+ {
+ return GetEnumerator ();
+ }
- return retval;
+ [MonoTODO]
+ public virtual XmlNode InsertAfter (XmlNode newChild, XmlNode refChild)
+ {
+ throw new NotImplementedException ();
}
- /// <summary>
- /// Put all nodes under this node in "normal" form
- /// Whatever that means...
- /// </summary>
- public virtual void Normalize()
+ [MonoTODO]
+ public virtual XmlNode InsertBefore (XmlNode newChild, XmlNode refChild)
{
- // TODO - Implement Normalize()
- throw new NotImplementedException();
+ throw new NotImplementedException ();
}
- /// <summary>
- /// Add the specified child to the beginning of the child node list
- /// </summary>
- /// <param name="newChild">Node to add</param>
- /// <returns>The node added</returns>
- public virtual XmlNode PrependChild(XmlNode newChild)
+ [MonoTODO]
+ public virtual void Normalize ()
{
- return InsertAfter(newChild, null);
+ throw new NotImplementedException ();
}
- /// <summary>
- /// Remove all children and attributes
- /// </summary>
- public virtual void RemoveAll()
+ [MonoTODO]
+ public virtual XmlNode PrependChild (XmlNode newChild)
{
- if (_childNodes == null)
- return;
- else
- {
- // Remove in order, 0..n
- while (_childNodes.Count > 0)
- {
- XmlNode e = _childNodes[0];
- FOwnerDocument.onNodeRemoving(e, this);
- e.setParent(null);
- _childNodes.data.RemoveAt(0);
- FOwnerDocument.onNodeRemoved(e, null);
- }
- }
+ throw new NotImplementedException ();
}
- /// <summary>
- /// Remove specified child node
- /// </summary>
- /// <param name="oldChild"></param>
- /// <returns>Removed node</returns>
- public virtual XmlNode RemoveChild(XmlNode oldChild)
+ public virtual void RemoveAll ()
{
- // TODO - implement RemoveChild(oldChild)
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Select a list of nodes matching the xpath
- /// </summary>
- /// <param name="xpath"></param>
- /// <returns>matching nodes</returns>
- public XmlNodeList SelectNodes( string xpath)
- {
- // TODO - imlement SelectNodes(xpath)
- throw new NotImplementedException();
+ LastLinkedChild = null;
}
-
- /// <summary>
- /// Select a list of nodes matching the xpath. Any prefixes are resolved
- /// using the passed namespace manager
- /// </summary>
- /// <param name="xpath"></param>
- /// <param name="nsmgr"></param>
- /// <returns></returns>
- public XmlNodeList SelectNodes(string xpath, XmlNamespaceManager nsmgr)
- {
- // TODO - implement SelectNodes(xpath, nsmgr)
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Selects the first node that matches xpath
- /// </summary>
- /// <param name="?"></param>
- /// <returns></returns>
- public XmlNode SelectSingleNode(string xpatch)
- {
- // TODO - implement SelectSingeNode(xpath)
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Returns the first node that matches xpath
- /// Uses the passed namespace manager to resolve namespace URI's
- /// </summary>
- /// <param name="xpath"></param>
- /// <param name="nsmgr"></param>
- /// <returns></returns>
- public XmlNode SelectSingleNode(string xpath, XmlNamespaceManager nsmgr)
- {
- // Implement SelectSingleNode(xpath, nsmgr)
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Tests if the DOM implementation supports the passed feature
- /// </summary>
- /// <param name="feature"></param>
- /// <param name="version"></param>
- /// <returns></returns>
- public virtual bool Supports(string feature, string version)
- {
- //TODO - implement Supports(feature, version)
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Returns a string representation of the current node and it's children
- /// </summary>
- /// <returns></returns>
- public override string ToString()
- {
- // TODO - implement ToString()
- throw new NotImplementedException();
- }
-
- /// <summary>
- /// Saves all children of the current node to the passed writer
- /// </summary>
- /// <param name="w"></param>
- public abstract void WriteContentTo(XmlWriter w);
-
- /// <summary>
- /// Saves the current node to writer w
- /// </summary>
- /// <param name="w"></param>
- public abstract void WriteTo(XmlWriter w);
-
- //======= Internal methods ===============================================
- /// <summary>
- /// accessor {set;} for parentNode only visible internally.
- /// </summary>
- /// <param name="newParent">new parent node.</param>
- internal void setParent( XmlNode newParent)
- {
- _parent = newParent;
- }
-
- //======= Protected methods ==============================================
-
- //======= Private Methods ===================================================
- /// <summary>
- /// Helper function to perform checks required before insrting a node.
- /// Throws applicable exceptions on error.
- /// </summary>
- /// <param name="newChild"></param>
- /// <param name="refChild"></param>
- private void InsertionCheck( XmlNode newChild, XmlNode refChild)
- {
- if (newChild == null)
- throw new ArgumentNullException("Null newNode passed to InsertAfter()");
-
- if (newChild.Equals(this))
- throw new ArgumentException("Cannot insert node onto itself");
-
- if (NodeType != XmlNodeType.Document && !FOwnerDocument.Equals( newChild.OwnerDocument) )
- throw new ArgumentException("Reference node has different owner document than this node");
-
- XmlDocument ownerDocument = newChild.OwnerDocument;
-
- if (ownerDocument.IsReadOnly )
- throw new ArgumentException("Operation not supported - tree is read-only");
-
- //Check that insert node is not in our path to the root
- XmlNode curParent = _parent;
- while ( (curParent != null) & (! ownerDocument.Equals(curParent) ))
- {
- if (curParent.Equals(newChild) )
- throw new ArgumentException("Cannot insert ancestor a node");
- curParent = curParent.ParentNode;
- }
+
+ [MonoTODO]
+ public virtual XmlNode RemoveChild (XmlNode oldChild)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ public virtual XmlNode ReplaceChild (XmlNode newChild, XmlNode oldChild)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ public virtual XmlNodeList SelectNodes (string xpath)
+ {
+ throw new NotImplementedException ();
}
- // Constructors
- //===========================================================================
- //When we're first created, we won't know parent, etc.
- internal XmlNode( XmlDocument aOwnerDoc )
+ [MonoTODO]
+ public virtual XmlNodeList SelectNodes (string xpath, XmlNamespaceManager nsmgr)
{
- // Don't create childnodes object, since not all derived classes have children
- FOwnerDocument = aOwnerDoc;
+ throw new NotImplementedException ();
}
- } // XmlNode
-} // using namespace System.Xml
+ [MonoTODO]
+ public virtual XmlNode SelectSingleNode (string xpath)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ public virtual XmlNode SelectSingleNode (string xpath, XmlNamespaceManager nsmgr)
+ {
+ throw new NotImplementedException ();
+ }
+
+ internal void SetParentNode (XmlNode parent)
+ {
+ parentNode = parent;
+ }
+
+ [MonoTODO]
+ public virtual bool Supports (string feature, string version)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ public abstract void WriteContentTo (XmlWriter w);
+
+ [MonoTODO]
+ public abstract void WriteTo (XmlWriter w);
-
+ #endregion
+ }
+}
projects / mono.git / commitdiff