//
using System;
-#if NET_2_0
using System.Collections;
+#if NET_2_0
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
public abstract class XPathNavigator : ICloneable
#endif
{
+ class EnumerableIterator : XPathNodeIterator
+ {
+ IEnumerable source;
+ IEnumerator e;
+ int pos;
+
+ public EnumerableIterator (IEnumerable source, int pos)
+ {
+ this.source = source;
+ for (int i = 0; i < pos; i++)
+ MoveNext ();
+ }
+
+ public override XPathNodeIterator Clone ()
+ {
+ return new EnumerableIterator (source, pos);
+ }
+
+ public override bool MoveNext ()
+ {
+ if (e == null)
+ e = source.GetEnumerator ();
+ if (!e.MoveNext ())
+ return false;
+ pos++;
+ return true;
+ }
+
+ public override int CurrentPosition {
+ get { return pos; }
+ }
+
+ public override XPathNavigator Current {
+ get { return pos == 0 ? null : (XPathNavigator) e.Current; }
+ }
+ }
+
#region Static members
#if NET_2_0
public static IEqualityComparer NavigatorComparer {
{
return Evaluate (expr, context, null);
}
-
- internal virtual object Evaluate (XPathExpression expr, XPathNodeIterator context, NSResolver ctx)
+
+ BaseIterator ToBaseIterator (XPathNodeIterator iter, NSResolver ctx)
+ {
+ BaseIterator i = iter as BaseIterator;
+ if (i == null)
+ i = new WrapperIterator (iter, ctx);
+ return i;
+ }
+
+ object Evaluate (XPathExpression expr, XPathNodeIterator context, NSResolver ctx)
{
CompiledExpression cexpr = (CompiledExpression) expr;
if (ctx == null)
if (context == null)
context = new NullIterator (this, ctx);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.Evaluate (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateNodeSet (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
- iterContext.NamespaceManager = ctx;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
return cexpr.EvaluateString (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateNumber (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateBoolean (iterContext);
}
return Select (expr, null);
}
- internal virtual XPathNodeIterator Select (XPathExpression expr, NSResolver ctx)
+ internal XPathNodeIterator Select (XPathExpression expr, NSResolver ctx)
{
CompiledExpression cexpr = (CompiledExpression) expr;
if (ctx == null)
return SelectTest (new NodeNameTest (axis, qname, true));
}
+ static IEnumerable EnumerateChildren (XPathNavigator n, XPathNodeType type)
+ {
+ if (!n.MoveToFirstChild ())
+ yield break;
+ n.MoveToParent ();
+ XPathNavigator nav = n.Clone ();
+ nav.MoveToFirstChild ();
+ XPathNavigator nav2 = null;
+ do {
+ if (type == XPathNodeType.All || nav.NodeType == type) {
+ if (nav2 == null)
+ nav2 = nav.Clone ();
+ else
+ nav2.MoveTo (nav);
+ yield return nav2;
+ }
+ } while (nav.MoveToNext ());
+ }
+
public virtual XPathNodeIterator SelectChildren (XPathNodeType type)
{
+#if false
return SelectTest (new NodeTypeTest (Axes.Child, type));
+#else
+ return new WrapperIterator (new EnumerableIterator (EnumerateChildren (this, type), 0), null);
+ // FIXME: make it work i.e. remove dependency on BaseIterator
+// return new EnumerableIterator (EnumerateChildren (this, type), 0);
+#endif
+ }
+
+ static IEnumerable EnumerateChildren (XPathNavigator n, string name, string ns)
+ {
+ if (!n.MoveToFirstChild ())
+ yield break;
+ n.MoveToParent ();
+ XPathNavigator nav = n.Clone ();
+ nav.MoveToFirstChild ();
+ XPathNavigator nav2 = nav.Clone ();
+ do {
+ if ((name == String.Empty || nav.LocalName == name) && (ns == String.Empty || nav.NamespaceURI == ns)) {
+ nav2.MoveTo (nav);
+ yield return nav2;
+ }
+ } while (nav.MoveToNext ());
}
public virtual XPathNodeIterator SelectChildren (string name, string namespaceURI)
if (namespaceURI == null)
throw new ArgumentNullException ("namespaceURI");
+#if false
Axes axis = Axes.Child;
XmlQualifiedName qname = new XmlQualifiedName (name, namespaceURI);
return SelectTest (new NodeNameTest (axis, qname, true));
+#else
+ return new WrapperIterator (new EnumerableIterator (EnumerateChildren (this, name, namespaceURI), 0), null);
+#endif
}
public virtual XPathNodeIterator SelectDescendants (XPathNodeType type, bool matchSelf)
#if NET_2_0
- public virtual bool CheckValidity (XmlSchemaSet schemas, ValidationEventHandler handler)
+ public virtual bool CheckValidity (XmlSchemaSet schemas, ValidationEventHandler validationEventHandler)
{
XmlReaderSettings settings = new XmlReaderSettings ();
settings.NameTable = NameTable;
settings.SetSchemas (schemas);
- settings.ValidationEventHandler += handler;
+ settings.ValidationEventHandler += validationEventHandler;
settings.ValidationType = ValidationType.Schema;
try {
XmlReader r = XmlReader.Create (
return Clone ();
}
- [MonoTODO]
- public virtual object Evaluate (string xpath, IXmlNamespaceResolver nsResolver)
+ public virtual object Evaluate (string xpath, IXmlNamespaceResolver resolver)
{
- return Evaluate (Compile (xpath), null, nsResolver);
+ return Evaluate (Compile (xpath), null, resolver);
}
- [MonoTODO]
public virtual IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope)
{
IDictionary<string, string> table = new Dictionary<string, string> ();
} while (nav.MoveToNextNamespace (xpscope));
return table;
}
+#endif
- public virtual string LookupNamespace (string prefix)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual string LookupNamespace (string prefix)
{
XPathNavigator nav = Clone ();
if (nav.NodeType != XPathNodeType.Element)
return null;
}
- public virtual string LookupPrefix (string namespaceUri)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual string LookupPrefix (string namespaceURI)
{
XPathNavigator nav = Clone ();
if (nav.NodeType != XPathNodeType.Element)
if (!nav.MoveToFirstNamespace ())
return null;
do {
- if (nav.Value == namespaceUri)
+ if (nav.Value == namespaceURI)
return nav.Name;
} while (nav.MoveToNextNamespace ());
return null;
return false;
}
- public virtual bool MoveToChild (XPathNodeType type)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToChild (XPathNodeType type)
{
return MoveTo (SelectChildren (type));
}
- public virtual bool MoveToChild (string localName, string namespaceURI)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToChild (string localName, string namespaceURI)
{
return MoveTo (SelectChildren (localName, namespaceURI));
}
- public virtual bool MoveToNext (string localName, string namespaceURI)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToNext (string localName, string namespaceURI)
{
XPathNavigator nav = Clone ();
while (nav.MoveToNext ()) {
return false;
}
- public virtual bool MoveToNext (XPathNodeType type)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToNext (XPathNodeType type)
{
XPathNavigator nav = Clone ();
while (nav.MoveToNext ()) {
- if (nav.NodeType == type) {
+ if (type == XPathNodeType.All || nav.NodeType == type) {
MoveTo (nav);
return true;
}
return false;
}
- public virtual bool MoveToFollowing (string localName,
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToFollowing (string localName,
string namespaceURI)
{
return MoveToFollowing (localName, namespaceURI, null);
}
- public virtual bool MoveToFollowing (string localName,
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToFollowing (string localName,
string namespaceURI, XPathNavigator end)
{
if (localName == null)
} while (true);
}
- public virtual bool MoveToFollowing (XPathNodeType type)
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToFollowing (XPathNodeType type)
{
return MoveToFollowing (type, null);
}
- public virtual bool MoveToFollowing (XPathNodeType type,
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ virtual bool MoveToFollowing (XPathNodeType type,
XPathNavigator end)
{
if (type == XPathNodeType.Root)
}
if (end != null && end.IsSamePosition (nav))
return false;
- if (nav.NodeType == type) {
+ if (type == XPathNodeType.All || nav.NodeType == type) {
MoveTo (nav);
return true;
}
} while (true);
}
+#if NET_2_0
public virtual XmlReader ReadSubtree ()
{
- return new XPathNavigatorReader (this);
+ switch (NodeType) {
+ case XPathNodeType.Element:
+ case XPathNodeType.Root:
+ return new XPathNavigatorReader (this);
+ default:
+ throw new InvalidOperationException (String.Format ("NodeType {0} is not supported to read as a subtree of an XPathNavigator.", NodeType));
+ }
}
- public virtual XPathNodeIterator Select (string xpath, IXmlNamespaceResolver nsResolver)
+ public virtual XPathNodeIterator Select (string xpath, IXmlNamespaceResolver resolver)
{
- return Select (Compile (xpath), nsResolver);
+ return Select (Compile (xpath), resolver);
}
public virtual XPathNavigator SelectSingleNode (string xpath)
return SelectSingleNode (xpath, null);
}
- public virtual XPathNavigator SelectSingleNode (string xpath, IXmlNamespaceResolver nsResolver)
+ public virtual XPathNavigator SelectSingleNode (string xpath, IXmlNamespaceResolver resolver)
{
XPathExpression expr = Compile (xpath);
- expr.SetContext (nsResolver);
+ expr.SetContext (resolver);
return SelectSingleNode (expr);
}
return null;
}
- [MonoTODO]
- public override object ValueAs (Type type, IXmlNamespaceResolver nsResolver)
+ // it is not very effective code but should just work
+ public override object ValueAs (Type returnType, IXmlNamespaceResolver nsResolver)
{
- throw new NotImplementedException ();
+ return new XmlAtomicValue (Value, XmlSchemaSimpleType.XsString).ValueAs (returnType, nsResolver);
}
public virtual void WriteSubtree (XmlWriter writer)
writer.WriteNode (this, false);
}
- [MonoTODO]
+ static readonly char [] escape_text_chars =
+ new char [] {'&', '<', '>'};
+ static readonly char [] escape_attr_chars =
+ new char [] {'"', '&', '<', '>', '\r', '\n'};
+
+ static string EscapeString (string value, bool attr)
+ {
+ StringBuilder sb = null;
+ char [] escape = attr ? escape_attr_chars : escape_text_chars;
+ if (value.IndexOfAny (escape) < 0)
+ return value;
+ sb = new StringBuilder (value, value.Length + 10);
+ if (attr)
+ sb.Replace ("\"", """);
+ sb.Replace ("<", "<");
+ sb.Replace (">", ">");
+ if (attr) {
+ sb.Replace ("\r\n", " ");
+ sb.Replace ("\r", " ");
+ sb.Replace ("\n", " ");
+ }
+ return sb.ToString ();
+ }
+
public virtual string InnerXml {
get {
+ switch (NodeType) {
+ case XPathNodeType.Element:
+ case XPathNodeType.Root:
+ break;
+ case XPathNodeType.Attribute:
+ case XPathNodeType.Namespace:
+ return EscapeString (Value, true);
+ case XPathNodeType.Text:
+ case XPathNodeType.Whitespace:
+ case XPathNodeType.SignificantWhitespace:
+ return String.Empty;
+ case XPathNodeType.ProcessingInstruction:
+ case XPathNodeType.Comment:
+ return Value;
+ }
+
XmlReader r = ReadSubtree ();
r.Read (); // start
// skip the element itself (or will reach to
int depth = r.Depth;
if (NodeType != XPathNodeType.Root)
r.Read ();
+ else
+ depth = -1; // for Root, it should consume the entire tree, so no depth check is done.
StringWriter sw = new StringWriter ();
- XmlWriter xtw = XmlWriter.Create (sw);
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.Indent = true;
+ s.ConformanceLevel = ConformanceLevel.Fragment;
+ s.OmitXmlDeclaration = true;
+ XmlWriter xtw = XmlWriter.Create (sw, s);
while (!r.EOF && r.Depth > depth)
xtw.WriteNode (r, false);
return sw.ToString ();
public virtual string OuterXml {
get {
+ switch (NodeType) {
+ case XPathNodeType.Attribute:
+ return String.Concat (
+ Prefix,
+ Prefix.Length > 0 ? ":" : String.Empty,
+ LocalName,
+ "=\"",
+ EscapeString (Value, true),
+ "\"");
+ case XPathNodeType.Namespace:
+ return String.Concat (
+ "xmlns",
+ LocalName.Length > 0 ? ":" : String.Empty,
+ LocalName,
+ "=\"",
+ EscapeString (Value, true),
+ "\"");
+ case XPathNodeType.Text:
+ return EscapeString (Value, false);
+ case XPathNodeType.Whitespace:
+ case XPathNodeType.SignificantWhitespace:
+ return Value;
+ }
+
XmlWriterSettings s = new XmlWriterSettings ();
s.Indent = true;
s.OmitXmlDeclaration = true;
+ s.ConformanceLevel = ConformanceLevel.Fragment;
StringBuilder sb = new StringBuilder ();
using (XmlWriter w = XmlWriter.Create (sb, s)) {
WriteSubtree (w);
}
return sb.ToString ();
}
- [MonoTODO]
set {
switch (NodeType) {
case XPathNodeType.Root:
}
}
- [MonoTODO]
public virtual IXmlSchemaInfo SchemaInfo {
get {
return null;
}
}
- [MonoTODO]
public override object TypedValue {
get {
switch (NodeType) {
}
}
- [MonoTODO]
public override XmlSchemaType XmlType {
get {
if (SchemaInfo != null)
}
public virtual void AppendChild (
- string xmlFragments)
+ string newChild)
{
- AppendChild (CreateFragmentReader (xmlFragments));
+ AppendChild (CreateFragmentReader (newChild));
}
public virtual void AppendChild (
- XmlReader reader)
+ XmlReader newChild)
{
XmlWriter w = AppendChild ();
- while (!reader.EOF)
- w.WriteNode (reader, false);
+ while (!newChild.EOF)
+ w.WriteNode (newChild, false);
w.Close ();
}
- [MonoTODO]
public virtual void AppendChild (
- XPathNavigator nav)
+ XPathNavigator newChild)
{
- AppendChild (new XPathNavigatorReader (nav));
+ AppendChild (new XPathNavigatorReader (newChild));
}
- public virtual void AppendChildElement (string prefix, string name, string ns, string value)
+ public virtual void AppendChildElement (string prefix, string localName, string namespaceURI, string value)
{
XmlWriter xw = AppendChild ();
- xw.WriteStartElement (prefix, name, ns);
+ xw.WriteStartElement (prefix, localName, namespaceURI);
xw.WriteString (value);
xw.WriteEndElement ();
xw.Close ();
}
// must override it.
- [MonoTODO ("needs tests")]
public virtual XmlWriter CreateAttributes ()
{
throw new NotSupportedException ();
}
// must override it.
- public virtual void DeleteRange (XPathNavigator nav)
+ public virtual void DeleteRange (XPathNavigator lastSiblingToDelete)
{
throw new NotSupportedException ();
}
- public virtual XmlWriter ReplaceRange (XPathNavigator nav)
+ public virtual XmlWriter ReplaceRange (XPathNavigator lastSiblingToReplace)
{
throw new NotSupportedException ();
}
throw new InvalidOperationException ("Could not move to parent to insert sibling node");
}
- public virtual void InsertAfter (string xmlFragments)
+ public virtual void InsertAfter (string newSibling)
{
- InsertAfter (CreateFragmentReader (xmlFragments));
+ InsertAfter (CreateFragmentReader (newSibling));
}
- public virtual void InsertAfter (XmlReader reader)
+ public virtual void InsertAfter (XmlReader newSibling)
{
using (XmlWriter w = InsertAfter ()) {
- w.WriteNode (reader, false);
+ w.WriteNode (newSibling, false);
}
}
- [MonoTODO]
- public virtual void InsertAfter (XPathNavigator nav)
+ public virtual void InsertAfter (XPathNavigator newSibling)
{
- InsertAfter (new XPathNavigatorReader (nav));
+ InsertAfter (new XPathNavigatorReader (newSibling));
}
public virtual XmlWriter InsertBefore ()
throw new NotSupportedException ();
}
- public virtual void InsertBefore (string xmlFragments)
+ public virtual void InsertBefore (string newSibling)
{
- InsertBefore (CreateFragmentReader (xmlFragments));
+ InsertBefore (CreateFragmentReader (newSibling));
}
- public virtual void InsertBefore (XmlReader reader)
+ public virtual void InsertBefore (XmlReader newSibling)
{
using (XmlWriter w = InsertBefore ()) {
- w.WriteNode (reader, false);
+ w.WriteNode (newSibling, false);
}
}
- [MonoTODO]
- public virtual void InsertBefore (XPathNavigator nav)
+ public virtual void InsertBefore (XPathNavigator newSibling)
{
- InsertBefore (new XPathNavigatorReader (nav));
+ InsertBefore (new XPathNavigatorReader (newSibling));
}
public virtual void InsertElementAfter (string prefix,
return AppendChild ();
}
- public virtual void PrependChild (string xmlFragments)
+ public virtual void PrependChild (string newChild)
{
- PrependChild (CreateFragmentReader (xmlFragments));
+ PrependChild (CreateFragmentReader (newChild));
}
- public virtual void PrependChild (XmlReader reader)
+ public virtual void PrependChild (XmlReader newChild)
{
using (XmlWriter w = PrependChild ()) {
- w.WriteNode (reader, false);
+ w.WriteNode (newChild, false);
}
}
- [MonoTODO]
- public virtual void PrependChild (XPathNavigator nav)
+ public virtual void PrependChild (XPathNavigator newChild)
{
- PrependChild (new XPathNavigatorReader (nav));
+ PrependChild (new XPathNavigatorReader (newChild));
}
public virtual void PrependChildElement (string prefix,
}
}
- public virtual void ReplaceSelf (string xmlFragment)
+ public virtual void ReplaceSelf (string newNode)
{
- ReplaceSelf (CreateFragmentReader (xmlFragment));
+ ReplaceSelf (CreateFragmentReader (newNode));
}
// must override it.
- public virtual void ReplaceSelf (XmlReader reader)
+ public virtual void ReplaceSelf (XmlReader newNode)
{
throw new NotSupportedException ();
}
- [MonoTODO]
- public virtual void ReplaceSelf (XPathNavigator navigator)
+ public virtual void ReplaceSelf (XPathNavigator newNode)
{
- ReplaceSelf (new XPathNavigatorReader (navigator));
+ ReplaceSelf (new XPathNavigatorReader (newNode));
}
// Dunno the exact purpose, but maybe internal editor use
[MonoTODO]
- public virtual void SetTypedValue (object value)
+ public virtual void SetTypedValue (object typedValue)
{
throw new NotSupportedException ();
}
throw new NotSupportedException ();
}
- [MonoTODO]
private void DeleteChildren ()
{
switch (NodeType) {
projects / mono.git / blobdiff