2169 lines
75 KiB
C#
2169 lines
75 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.XPath;
|
|
|
|
// Anything marked
|
|
|
|
|
|
|
|
|
|
class SeekableMessageNavigator : SeekableXPathNavigator, INodeCounter
|
|
{
|
|
// Use a single template for constructing the common elements.
|
|
static Node[] BlankDom;
|
|
|
|
// Constants
|
|
const string XmlP = "xml";
|
|
const string XmlnsP = "xmlns";
|
|
const string SoapP = "s";
|
|
const string EnvelopeTag = MessageStrings.Envelope;
|
|
const string HeaderTag = MessageStrings.Header;
|
|
const string BodyTag = MessageStrings.Body;
|
|
|
|
// These constants are constructed from each other so new ones can be added without too much hastle.
|
|
const int NullIndex = 0;
|
|
const int RootIndex = NullIndex + 1;
|
|
const int EnvelopeIndex = RootIndex + 1;
|
|
const int SoapNSIndex = EnvelopeIndex + 1;
|
|
const int XmlNSIndex = SoapNSIndex + 1;
|
|
const int HeaderIndex = XmlNSIndex + 1;
|
|
const int FirstHeaderIndex = HeaderIndex + 1;
|
|
|
|
const int StartSize = 50; // Blank nodes to start with
|
|
const int GrowFactor = 2; // Multiplier to grow the node array by
|
|
const int StretchMax = 1000; // Use the multiplier until the node array gets this big
|
|
const int GrowInc = 1000; // Grow by this many nodes when StretchMax is exceeded
|
|
|
|
// Shared as dom
|
|
Message message;
|
|
MessageHeaders headers;
|
|
XmlSpace space;
|
|
StringBuilder stringBuilder;
|
|
|
|
Node[] nodes;
|
|
int bodyIndex;
|
|
int nextFreeIndex;
|
|
|
|
NameTable nameTable;
|
|
bool includeBody;
|
|
bool atomize;
|
|
|
|
// Shared as counter
|
|
int nodeCount;
|
|
int nodeCountMax;
|
|
|
|
// Instance
|
|
SeekableMessageNavigator dom;
|
|
SeekableMessageNavigator counter;
|
|
Stack<string> nsStack;
|
|
int location;
|
|
int specialParent; // Always null if we're not at a namespace node
|
|
|
|
static SeekableMessageNavigator()
|
|
{
|
|
BlankDom = new Node[HeaderIndex + 1];
|
|
|
|
// Root
|
|
BlankDom[RootIndex].type = XPathNodeType.Root;
|
|
BlankDom[RootIndex].firstChild = EnvelopeIndex;
|
|
BlankDom[RootIndex].prefix = string.Empty;
|
|
BlankDom[RootIndex].name = string.Empty;
|
|
BlankDom[RootIndex].val = string.Empty;
|
|
|
|
// Envelope
|
|
BlankDom[EnvelopeIndex].type = XPathNodeType.Element;
|
|
BlankDom[EnvelopeIndex].prefix = SoapP;
|
|
//BlankDom[EnvelopeIndex].ns = soapNS;
|
|
BlankDom[EnvelopeIndex].name = EnvelopeTag;
|
|
BlankDom[EnvelopeIndex].parent = RootIndex;
|
|
BlankDom[EnvelopeIndex].firstChild = HeaderIndex;
|
|
BlankDom[EnvelopeIndex].firstNamespace = SoapNSIndex;
|
|
|
|
// SOAP Namespace
|
|
BlankDom[SoapNSIndex].type = XPathNodeType.Namespace;
|
|
BlankDom[SoapNSIndex].name = SoapP;
|
|
//BlankDom[SoapNSIndex].val = soapNS;
|
|
BlankDom[SoapNSIndex].nextSibling = XmlNSIndex;
|
|
BlankDom[SoapNSIndex].parent = EnvelopeIndex;
|
|
|
|
// xmlns:xml Namespace
|
|
BlankDom[XmlNSIndex].type = XPathNodeType.Namespace;
|
|
BlankDom[XmlNSIndex].name = "xml";
|
|
BlankDom[XmlNSIndex].val = XmlUtil.XmlNs;
|
|
BlankDom[XmlNSIndex].prevSibling = SoapNSIndex;
|
|
BlankDom[XmlNSIndex].parent = RootIndex; // This one needs to be connected a little different
|
|
|
|
// Header
|
|
BlankDom[HeaderIndex].type = XPathNodeType.Element;
|
|
BlankDom[HeaderIndex].prefix = SoapP;
|
|
//BlankDom[HeaderIndex].ns = soapNS;
|
|
BlankDom[HeaderIndex].name = HeaderTag;
|
|
BlankDom[HeaderIndex].parent = EnvelopeIndex;
|
|
//BlankDom[HeaderIndex].nextSibling = bodyIndex;
|
|
//BlankDom[HeaderIndex].firstChild = this.bodyIndex != FirstHeaderIndex ? FirstHeaderIndex : NullIndex;
|
|
BlankDom[HeaderIndex].firstNamespace = SoapNSIndex;
|
|
|
|
}
|
|
|
|
internal SeekableMessageNavigator(SeekableMessageNavigator nav)
|
|
{
|
|
Fx.Assert(nav != null, "Navigator may not be null");
|
|
|
|
this.counter = nav.counter;
|
|
this.dom = nav.dom;
|
|
this.location = nav.location;
|
|
this.specialParent = nav.specialParent;
|
|
if (this.specialParent != NullIndex)
|
|
{
|
|
this.nsStack = nav.CloneNSStack();
|
|
}
|
|
}
|
|
|
|
internal SeekableMessageNavigator(Message msg, int countMax, XmlSpace space, bool includeBody, bool atomize)
|
|
{
|
|
Init(msg, countMax, space, includeBody, atomize);
|
|
}
|
|
|
|
// The base uri of the element
|
|
// This is usually associated with the URI of the original data's location
|
|
// WS, Microsoft, look into what readers from messages surface. If it's always null, we can save
|
|
// some memory
|
|
public override string BaseURI
|
|
{
|
|
get
|
|
{
|
|
LoadOnDemand();
|
|
string s = this.dom.nodes[this.location].baseUri;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
}
|
|
|
|
// Get/Set an opaque position value.
|
|
// This property will save and restore a navigator's position without cloning
|
|
// The two integers needed to uniquely identify this navigators location within the DOM are encoded in
|
|
// a long. The high 32 bits is the parent index, and the low 32 bits is the current node index.
|
|
public override long CurrentPosition
|
|
{
|
|
get
|
|
{
|
|
long p = this.specialParent;
|
|
p <<= 32;
|
|
p += this.location;
|
|
return p;
|
|
}
|
|
set
|
|
{
|
|
Position p = this.dom.DecodePosition(value);
|
|
|
|
// If we are at a namespace, collect the namespaces that have already been seen
|
|
if (p.parent != NullIndex)
|
|
{
|
|
if (this.nsStack == null)
|
|
{
|
|
this.nsStack = new Stack<string>();
|
|
}
|
|
else
|
|
{
|
|
this.nsStack.Clear();
|
|
}
|
|
|
|
int n = this.dom.nodes[p.parent].firstNamespace;
|
|
|
|
while (n != p.elem)
|
|
{
|
|
// PERF, Microsoft, we might be able to get rid of this check by tweaking the position
|
|
// validator
|
|
if (n == NullIndex)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryProcessingException(QueryProcessingError.InvalidNavigatorPosition, SR.GetString(SR.SeekableMessageNavInvalidPosition)));
|
|
}
|
|
|
|
this.nsStack.Push(this.dom.nodes[n].name);
|
|
n = this.dom.nodes[n].nextSibling;
|
|
}
|
|
}
|
|
|
|
this.location = p.elem;
|
|
this.specialParent = p.parent;
|
|
}
|
|
}
|
|
|
|
// Returns whether the current node has any defined attributes.
|
|
public override bool HasAttributes
|
|
{
|
|
get
|
|
{
|
|
LoadOnDemand();
|
|
return this.dom.nodes[this.location].firstAttribute != NullIndex;
|
|
}
|
|
}
|
|
|
|
// Returns whether the current node has any children.
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
LoadOnDemand();
|
|
return this.dom.nodes[this.location].firstChild != NullIndex;
|
|
}
|
|
}
|
|
|
|
// Returns whether the current node was defined as an empty element.
|
|
// This is not relevant to xpath, so we're saving memory by not recording the true value.
|
|
// If a reader does ever get wrapped around it, we'll have to fix this.
|
|
public override bool IsEmptyElement
|
|
{
|
|
get
|
|
{
|
|
// <a/> is an empty element. <a></a> is not.
|
|
return this.dom.nodes[this.location].empty;
|
|
}
|
|
}
|
|
|
|
// Return the local name of the current node.
|
|
public override string LocalName
|
|
{
|
|
get
|
|
{
|
|
string s = this.dom.nodes[this.location].name;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
}
|
|
|
|
// Returns the message that was used to construct this navigator's DOM
|
|
internal Message Message
|
|
{
|
|
get
|
|
{
|
|
return this.dom.message;
|
|
}
|
|
}
|
|
|
|
// Returns the qualified name of the current node
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return GetName(this.location);
|
|
}
|
|
}
|
|
|
|
// Returns the namespace URI of the current node
|
|
public override string NamespaceURI
|
|
{
|
|
get
|
|
{
|
|
string s = this.dom.nodes[this.location].ns;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get
|
|
{
|
|
// Delay atomizing for the cases where we typically don't
|
|
// need to do it (e.g. creating a navigator over a Message).
|
|
if (!this.dom.atomize)
|
|
{
|
|
this.dom.Atomize();
|
|
}
|
|
return this.dom.nameTable;
|
|
}
|
|
}
|
|
|
|
// Returns the type of the current node
|
|
public override XPathNodeType NodeType
|
|
{
|
|
get
|
|
{
|
|
return this.dom.nodes[this.location].type;
|
|
}
|
|
}
|
|
|
|
// Returns the prefix of the current node
|
|
public override string Prefix
|
|
{
|
|
get
|
|
{
|
|
LoadOnDemand();
|
|
string s = this.dom.nodes[this.location].prefix;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
}
|
|
|
|
// Returns the text value of the current node
|
|
public override string Value
|
|
{
|
|
get
|
|
{
|
|
return this.dom.GetValue(this.location);
|
|
}
|
|
}
|
|
|
|
// Returns the value of xml:lang that is currently in scope.
|
|
public override string XmlLang
|
|
{
|
|
get
|
|
{
|
|
LoadOnDemand();
|
|
string s = this.dom.nodes[this.location].xmlLang;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
}
|
|
|
|
#if NO
|
|
// The default value of xml:space for the DOM
|
|
internal XmlSpace DefaultXmlSpace
|
|
{
|
|
get
|
|
{
|
|
return this.dom.space;
|
|
}
|
|
}
|
|
|
|
internal SeekableMessageNavigator DomNavigator
|
|
{
|
|
get
|
|
{
|
|
return this.dom;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Create a clone of the current navigator that shares its DOM and node counter
|
|
public override XPathNavigator Clone()
|
|
{
|
|
return new SeekableMessageNavigator(this);
|
|
}
|
|
|
|
// Compare the current position to that of another navigator.
|
|
public override XmlNodeOrder ComparePosition(XPathNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
// We can only compare the positions of navigators of the same type.
|
|
SeekableMessageNavigator smnav = nav as SeekableMessageNavigator;
|
|
if (smnav != null)
|
|
{
|
|
return ComparePosition(smnav);
|
|
}
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
// Compare the current position to that of another navigator.
|
|
internal XmlNodeOrder ComparePosition(SeekableMessageNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
if (this.dom != nav.dom)
|
|
{
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
return this.dom.ComparePosition(this.specialParent, this.location, nav.specialParent, nav.location);
|
|
}
|
|
|
|
// Compare two position values that are valid for this navigator's DOM
|
|
public override XmlNodeOrder ComparePosition(long pos1, long pos2)
|
|
{
|
|
Position p1 = this.dom.DecodePosition(pos1);
|
|
Position p2 = this.dom.DecodePosition(pos2);
|
|
return this.dom.ComparePosition(p1.parent, p1.elem, p2.parent, p2.elem);
|
|
}
|
|
|
|
// Compile: We don't need to override this. Seems like it could have even been static.
|
|
|
|
// Evaluate an xpath expression against the current navigator
|
|
public override object Evaluate(string xpath)
|
|
{
|
|
// We can only evaluate atomized navigators
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Evaluate")));
|
|
}
|
|
return base.Evaluate(xpath);
|
|
}
|
|
|
|
// Evaluate an xpath expression against the current navigator
|
|
public override object Evaluate(XPathExpression expr)
|
|
{
|
|
// We can only evaluate atomized navigators
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Evaluate")));
|
|
}
|
|
return base.Evaluate(expr);
|
|
}
|
|
|
|
// Evaluate an xpath expression against the current navigator
|
|
public override object Evaluate(XPathExpression expr, XPathNodeIterator context)
|
|
{
|
|
// We can only evaluate atomized navigators
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Evaluate")));
|
|
}
|
|
return base.Evaluate(expr, context);
|
|
}
|
|
|
|
// Get the value of an attribute with a particular name and namespace
|
|
public override string GetAttribute(string name, string ns)
|
|
{
|
|
if (name == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
|
|
}
|
|
|
|
if (ns == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns");
|
|
}
|
|
|
|
// We must be at an element node
|
|
if (this.NodeType != XPathNodeType.Element)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
int a;
|
|
string ret = string.Empty;
|
|
Increase();
|
|
LoadOnDemand();
|
|
|
|
// Walk through the attributes looking for the one we want.
|
|
a = this.dom.nodes[this.location].firstAttribute;
|
|
while (a != NullIndex)
|
|
{
|
|
if (String.CompareOrdinal(this.dom.nodes[a].name, name) == 0 && String.CompareOrdinal(this.dom.nodes[a].ns, ns) == 0)
|
|
{
|
|
ret = this.dom.nodes[a].val;
|
|
break;
|
|
}
|
|
|
|
Increase();
|
|
a = this.dom.nodes[a].nextSibling;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// Returns the local name of the node defined by the given navigator position
|
|
public override string GetLocalName(long pos)
|
|
{
|
|
string s = this.dom.nodes[this.dom.DecodePosition(pos).elem].name;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
|
|
// Returns the qualified name of the node defined by the given navigator position
|
|
public override string GetName(long pos)
|
|
{
|
|
return GetName(this.dom.DecodePosition(pos).elem);
|
|
}
|
|
|
|
// Returns the namespace uri of the node defined by the given navigator position
|
|
public override string GetNamespace(long pos)
|
|
{
|
|
string s = this.dom.nodes[this.dom.DecodePosition(pos).elem].ns;
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
|
|
// Returns the namespace uri that is bound to the given prefix in the current scope, or the empty
|
|
// string if the prefix is not defined
|
|
public override string GetNamespace(string name)
|
|
{
|
|
if (name == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
|
|
}
|
|
|
|
if (this.NodeType != XPathNodeType.Element)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
int ns;
|
|
Increase();
|
|
LoadOnDemand();
|
|
ns = this.dom.nodes[this.location].firstNamespace;
|
|
string ret = string.Empty;
|
|
|
|
while (ns != NullIndex)
|
|
{
|
|
Increase();
|
|
|
|
if (String.CompareOrdinal(this.dom.nodes[ns].name, name) == 0)
|
|
{
|
|
ret = this.dom.nodes[ns].val;
|
|
break;
|
|
}
|
|
|
|
ns = this.dom.nodes[ns].nextSibling;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// Returns the node type of the node defined by the given navigator position
|
|
public override XPathNodeType GetNodeType(long pos)
|
|
{
|
|
return this.dom.nodes[this.dom.DecodePosition(pos).elem].type;
|
|
}
|
|
|
|
// Returns the string value of the node defined by the given navigator position
|
|
public override string GetValue(long pos)
|
|
{
|
|
string s = this.dom.GetValue(this.dom.DecodePosition(pos).elem);
|
|
return s == null ? string.Empty : s;
|
|
}
|
|
|
|
// Test whether the given navigator is positioned on a descendant of this navigator
|
|
public override bool IsDescendant(XPathNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Navigator positions can only be compared if they are of the same type
|
|
SeekableMessageNavigator smnav = nav as SeekableMessageNavigator;
|
|
if (smnav != null)
|
|
{
|
|
return IsDescendant(smnav);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Test whether the given navigator is positioned on a descendant of this navigator
|
|
internal bool IsDescendant(SeekableMessageNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (this.dom != nav.dom)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Namespaces and attributes are not considered descendants
|
|
XPathNodeType type = this.dom.nodes[nav.location].type;
|
|
if (type == XPathNodeType.Namespace || type == XPathNodeType.Attribute)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Namespaces and attributes are not parents
|
|
type = this.dom.nodes[this.location].type;
|
|
if (type == XPathNodeType.Namespace || type == XPathNodeType.Attribute)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Climb up the tree looking for the current navigator's position
|
|
int n = nav.location;
|
|
while (n != NullIndex)
|
|
{
|
|
Increase();
|
|
n = this.dom.nodes[n].parent;
|
|
|
|
if (n == this.location)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Tests whether the given navigator is positioned on the same node as this navigator
|
|
public override bool IsSamePosition(XPathNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Navigator positions can only be compared if they are of the same type
|
|
SeekableMessageNavigator smnav = nav as SeekableMessageNavigator;
|
|
if (smnav != null)
|
|
{
|
|
return IsSamePosition(smnav);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Tests whether the given navigator is positioned on the same node as this navigator
|
|
internal bool IsSamePosition(SeekableMessageNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return this.dom == nav.dom && this.location == nav.location && this.specialParent == nav.specialParent;
|
|
}
|
|
|
|
// Test if the given xpath matches this navigator
|
|
public override bool Matches(string xpath)
|
|
{
|
|
// We can only match atomized navigators
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Matches")));
|
|
}
|
|
return base.Matches(xpath);
|
|
}
|
|
|
|
// Test if the given xpath matches this navigator
|
|
public override bool Matches(XPathExpression expr)
|
|
{
|
|
// We can only match atomized navigators
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Matches")));
|
|
}
|
|
return base.Matches(expr);
|
|
}
|
|
|
|
// Move this navigator to the same position as the given one
|
|
public override bool MoveTo(XPathNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Can only move to the position of a navigator of the same type
|
|
SeekableMessageNavigator smnav = nav as SeekableMessageNavigator;
|
|
if (smnav != null)
|
|
{
|
|
return MoveTo(smnav);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move this navigator to the same position as the given one
|
|
internal bool MoveTo(SeekableMessageNavigator nav)
|
|
{
|
|
if (nav == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
this.dom = nav.dom;
|
|
this.counter = nav.counter;
|
|
this.location = nav.location;
|
|
this.specialParent = nav.specialParent;
|
|
if (this.specialParent != NullIndex)
|
|
{
|
|
this.nsStack = nav.CloneNSStack();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Move this navigator to an attribute with the given name and namespace
|
|
public override bool MoveToAttribute(string localName, string namespaceURI)
|
|
{
|
|
if (localName == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("localName");
|
|
}
|
|
|
|
if (namespaceURI == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("namespaceURI");
|
|
}
|
|
|
|
LoadOnDemand();
|
|
|
|
// We must be positioned on an element
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Element)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Move through the attributes looking for one that matches
|
|
Increase();
|
|
int n = this.dom.nodes[this.location].firstAttribute;
|
|
while (n != NullIndex)
|
|
{
|
|
if (String.CompareOrdinal(this.dom.nodes[n].name, localName) == 0 &&
|
|
String.CompareOrdinal(this.dom.nodes[n].ns, namespaceURI) == 0)
|
|
{
|
|
// If we find it, we're done
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Try the next one
|
|
Increase();
|
|
n = this.dom.nodes[n].nextSibling;
|
|
}
|
|
}
|
|
|
|
// Didn't find it
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the first sibling of the current node
|
|
public override bool MoveToFirst()
|
|
{
|
|
// Not valid for attributes and namespaces
|
|
XPathNodeType t = this.dom.nodes[this.location].type;
|
|
if (t != XPathNodeType.Attribute && t != XPathNodeType.Namespace)
|
|
{
|
|
// Get the parent of the current node
|
|
Increase();
|
|
int p = this.dom.nodes[this.location].parent;
|
|
|
|
// If the parent was null, we're at the root (which has no siblings)
|
|
if (p != NullIndex)
|
|
{
|
|
// Move to the first child of our node's parent (ie, first sibling)
|
|
// Cool, huh? :-)
|
|
Increase();
|
|
this.location = this.dom.nodes[p].firstChild;
|
|
}
|
|
|
|
// The move is still considered successful if we were already there.
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the first attribute of it's current element
|
|
public override bool MoveToFirstAttribute()
|
|
{
|
|
// Only valid for element nodes
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Element)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the first attribute
|
|
LoadOnDemand();
|
|
int n = this.dom.nodes[this.location].firstAttribute;
|
|
|
|
// The move was only successful if there is at least one attribute
|
|
if (n != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the first child of the current node.
|
|
public override bool MoveToFirstChild()
|
|
{
|
|
// PERF, Microsoft, do we need this check? The null check may be enough
|
|
// Only valid for the root or an element node
|
|
if (this.location == RootIndex || this.dom.nodes[this.location].type == XPathNodeType.Element)
|
|
{
|
|
// Get the first child
|
|
LoadOnDemand();
|
|
int n = this.dom.nodes[this.location].firstChild;
|
|
|
|
// Only successful if there was at least one child
|
|
if (n != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the first namespace that fits the scope
|
|
public override bool MoveToFirstNamespace(XPathNamespaceScope scope)
|
|
{
|
|
// Only valid on element nodes
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Element)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Start with a clean namespace stack
|
|
if (this.nsStack == null)
|
|
{
|
|
this.nsStack = new Stack<string>();
|
|
}
|
|
else
|
|
{
|
|
this.nsStack.Clear();
|
|
}
|
|
|
|
// Find the namespace
|
|
LoadOnDemand();
|
|
int n = FindNamespace(this.location, this.dom.nodes[this.location].firstNamespace, scope);
|
|
|
|
// If one was found, move there
|
|
if (n != NullIndex)
|
|
{
|
|
// Record the parent
|
|
this.specialParent = this.location;
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the node with the given unique ID
|
|
public override bool MoveToId(string id)
|
|
{
|
|
// SOAP prohibits the inclusion of a DTD, so unique IDs cannot be defined.
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryProcessingException(QueryProcessingError.NotSupported, SR.GetString(SR.SeekableMessageNavIDNotSupported)));
|
|
}
|
|
|
|
// Move the navigator to the namespace manager the given prefix
|
|
public override bool MoveToNamespace(string name)
|
|
{
|
|
if (name == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
|
|
}
|
|
|
|
// Only valid from an element node
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Element)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Start with a clean namespace stack
|
|
if (this.nsStack == null)
|
|
{
|
|
this.nsStack = new Stack<string>();
|
|
}
|
|
else
|
|
{
|
|
this.nsStack.Clear();
|
|
}
|
|
|
|
Increase();
|
|
LoadOnDemand();
|
|
|
|
// Look through the namespaces for the specified prefix
|
|
int n = this.dom.nodes[this.location].firstNamespace;
|
|
string nodeName;
|
|
string nodeVal;
|
|
int nsCount = 0;
|
|
while (n != NullIndex)
|
|
{
|
|
// Skip any already defined prefixes
|
|
nodeName = this.dom.nodes[n].name;
|
|
if (!this.nsStack.Contains(nodeName))
|
|
{
|
|
this.nsStack.Push(nodeName);
|
|
++nsCount;
|
|
nodeVal = this.dom.nodes[n].val;
|
|
if ((nodeName.Length > 0 || nodeVal.Length > 0) && String.CompareOrdinal(nodeName, name) == 0)
|
|
{
|
|
this.specialParent = this.location;
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Try the next one
|
|
Increase();
|
|
n = this.dom.nodes[n].nextSibling;
|
|
}
|
|
|
|
// PERF, Microsoft, can we just clear?
|
|
// We didn't find it, so restore the namespace stack
|
|
for (int i = 0; i < nsCount; ++i)
|
|
{
|
|
this.nsStack.Pop();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the next sibling
|
|
public override bool MoveToNext()
|
|
{
|
|
// Not valid for attribute/namespace nodes. They have different 'next' functions.
|
|
XPathNodeType type = this.dom.nodes[this.location].type;
|
|
if (type == XPathNodeType.Attribute || type == XPathNodeType.Namespace)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Successful if there is a next sibling.
|
|
int n = this.dom.nodes[this.location].nextSibling;
|
|
if (n != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the next attribute node
|
|
public override bool MoveToNextAttribute()
|
|
{
|
|
// Only valid on an attribute node
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Attribute)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Successful if there is a next sibling
|
|
int n = this.dom.nodes[this.location].nextSibling;
|
|
if (n != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the next namespace node in the specified scope
|
|
public override bool MoveToNextNamespace(XPathNamespaceScope scope)
|
|
{
|
|
// Only valid from a namespace node
|
|
if (this.dom.nodes[this.location].type != XPathNodeType.Namespace)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Successful if the a namespace was found in the given scope
|
|
int n = FindNamespace(this.specialParent, this.dom.nodes[this.location].nextSibling, scope);
|
|
if (n != NullIndex)
|
|
{
|
|
// Move to the namespace
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the parent of the current node
|
|
public override bool MoveToParent()
|
|
{
|
|
// The root node doesn't have a parent
|
|
if (this.location == RootIndex)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Use the special parent if it's not null
|
|
Increase();
|
|
if (this.specialParent != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = this.specialParent;
|
|
this.specialParent = NullIndex;
|
|
}
|
|
else
|
|
{
|
|
this.location = this.dom.nodes[this.location].parent;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Move the navigator to the previous sibling of the current node
|
|
public override bool MoveToPrevious()
|
|
{
|
|
// Not valid for attribute/namespace nodes
|
|
int n = NullIndex;
|
|
XPathNodeType t = this.dom.nodes[this.location].type;
|
|
if (t != XPathNodeType.Attribute && t != XPathNodeType.Namespace)
|
|
{
|
|
n = this.dom.nodes[this.location].prevSibling;
|
|
}
|
|
|
|
// Successful if there was a previous sibling
|
|
if (n != NullIndex)
|
|
{
|
|
Increase();
|
|
this.location = n;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Move the navigator to the root node
|
|
public override void MoveToRoot()
|
|
{
|
|
Increase();
|
|
this.location = RootIndex;
|
|
this.specialParent = NullIndex;
|
|
}
|
|
|
|
// Select nodes from the navigator using the given xpath
|
|
public override XPathNodeIterator Select(string xpath)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Select")));
|
|
}
|
|
return base.Select(xpath);
|
|
}
|
|
|
|
// Select nodes from the navigator using the given xpath
|
|
public override XPathNodeIterator Select(XPathExpression xpath)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "Select")));
|
|
}
|
|
return base.Select(xpath);
|
|
}
|
|
|
|
// Select ancestor nodes from the navigator of a given type
|
|
public override XPathNodeIterator SelectAncestors(XPathNodeType type, bool matchSelf)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectAncestors")));
|
|
}
|
|
return base.SelectAncestors(type, matchSelf);
|
|
}
|
|
|
|
// Select ancestor nodes from the navigator with a particular name and namespace
|
|
public override XPathNodeIterator SelectAncestors(string name, string namespaceURI, bool matchSelf)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectAncestors")));
|
|
}
|
|
return base.SelectAncestors(name, namespaceURI, matchSelf);
|
|
}
|
|
|
|
// Select child nodes of a certain type from the navigator
|
|
public override XPathNodeIterator SelectChildren(XPathNodeType type)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectChildren")));
|
|
}
|
|
return base.SelectChildren(type);
|
|
}
|
|
|
|
// Select child nodes from the navigator with a certain name and namespace
|
|
public override XPathNodeIterator SelectChildren(string name, string namespaceURI)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectChildren")));
|
|
}
|
|
return base.SelectChildren(name, namespaceURI);
|
|
}
|
|
|
|
// Select descendant nodes of a certain type from the navigator
|
|
public override XPathNodeIterator SelectDescendants(XPathNodeType type, bool matchSelf)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectDescendants")));
|
|
}
|
|
return base.SelectDescendants(type, matchSelf);
|
|
}
|
|
|
|
// Selectg descendant nodes from the navigator with a certain name and namespace
|
|
public override XPathNodeIterator SelectDescendants(string name, string namespaceURI, bool matchSelf)
|
|
{
|
|
// Cannot select from an unatomized navigator
|
|
if (!this.dom.atomize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.NotAtomized, SR.GetString(SR.SeekableMessageNavNonAtomized, "SelectDescendants")));
|
|
}
|
|
return base.SelectDescendants(name, namespaceURI, matchSelf);
|
|
}
|
|
|
|
// ToString: Don't need to override this
|
|
|
|
// Atomize the required strings if atomization was not enabled for this DOM
|
|
// Calling this function permanently enables atomization for the DOM
|
|
internal void Atomize()
|
|
{
|
|
if (!this.dom.atomize)
|
|
{
|
|
this.dom.atomize = true;
|
|
this.dom.nameTable = new NameTable();
|
|
this.dom.nameTable.Add(string.Empty);
|
|
this.dom.Atomize(RootIndex, this.nextFreeIndex);
|
|
}
|
|
}
|
|
|
|
// Set a new count for this navigator
|
|
// Set it to use itself for the counter so all clones of it will share the new counter
|
|
internal void ForkNodeCount(int count)
|
|
{
|
|
Fx.Assert(count > 0, "Maximum node count must be greater than zero");
|
|
|
|
this.nodeCount = count;
|
|
this.nodeCountMax = count;
|
|
this.counter = this;
|
|
}
|
|
|
|
// THREAD: Synchronize this function if multiple threads can try to re-initialize an instance at the same time. Also, if you reinitialize the navigator that holds information referenced by clones, the clones will be affected as well.
|
|
internal void Init(Message msg, int countMax, XmlSpace space, bool includeBody, bool atomize)
|
|
{
|
|
Fx.Assert(countMax > 0, "Maximum node count must be greater than zero");
|
|
this.counter = this;
|
|
this.nodeCount = countMax;
|
|
this.nodeCountMax = countMax;
|
|
|
|
Fx.Assert(msg != null, "Message may not be null");
|
|
this.dom = this;
|
|
this.location = RootIndex;
|
|
this.specialParent = NullIndex;
|
|
this.includeBody = includeBody;
|
|
this.message = msg;
|
|
this.headers = msg.Headers;
|
|
this.space = space;
|
|
this.atomize = false; // Will get fixed at the end of this function
|
|
|
|
int minSize = msg.Headers.Count + FirstHeaderIndex + 1;
|
|
|
|
if (this.nodes == null || this.nodes.Length < minSize)
|
|
{
|
|
this.nodes = new Node[minSize + StartSize];
|
|
}
|
|
else
|
|
{
|
|
Array.Clear(this.nodes, 1, this.nextFreeIndex - 1);
|
|
}
|
|
|
|
this.bodyIndex = minSize - 1;
|
|
this.nextFreeIndex = minSize;
|
|
|
|
// Use the static blank DOM to create the first few nodes
|
|
Array.Copy(BlankDom, this.nodes, HeaderIndex + 1);
|
|
|
|
string soapNS = msg.Version.Envelope.Namespace;
|
|
this.nodes[EnvelopeIndex].ns = soapNS;
|
|
this.nodes[SoapNSIndex].val = soapNS;
|
|
this.nodes[HeaderIndex].ns = soapNS;
|
|
|
|
this.nodes[HeaderIndex].nextSibling = bodyIndex;
|
|
this.nodes[HeaderIndex].firstChild = this.bodyIndex != FirstHeaderIndex ? FirstHeaderIndex : NullIndex;
|
|
|
|
// Headers
|
|
if (msg.Headers.Count > 0)
|
|
{
|
|
for (int i = FirstHeaderIndex, h = 0; h < msg.Headers.Count; ++i, ++h)
|
|
{
|
|
this.nodes[i].type = XPathNodeType.Element;
|
|
this.nodes[i].parent = HeaderIndex;
|
|
this.nodes[i].nextSibling = i + 1;
|
|
this.nodes[i].prevSibling = i - 1;
|
|
|
|
// Extract the header block stub data
|
|
MessageHeaderInfo header = msg.Headers[h];
|
|
this.nodes[i].ns = header.Namespace;
|
|
this.nodes[i].name = header.Name;
|
|
this.nodes[i].firstChild = -1;
|
|
}
|
|
this.nodes[FirstHeaderIndex].prevSibling = NullIndex;
|
|
this.nodes[this.bodyIndex - 1].nextSibling = NullIndex;
|
|
}
|
|
|
|
// Body
|
|
this.nodes[bodyIndex].type = XPathNodeType.Element;
|
|
this.nodes[bodyIndex].prefix = SoapP;
|
|
this.nodes[bodyIndex].ns = soapNS;
|
|
this.nodes[bodyIndex].name = BodyTag;
|
|
this.nodes[bodyIndex].parent = EnvelopeIndex;
|
|
this.nodes[bodyIndex].prevSibling = HeaderIndex;
|
|
this.nodes[bodyIndex].firstNamespace = SoapNSIndex;
|
|
this.nodes[bodyIndex].firstChild = -1; // Need to load
|
|
|
|
// Atomize
|
|
if (atomize)
|
|
{
|
|
Atomize();
|
|
}
|
|
}
|
|
|
|
// Add an attribute node
|
|
// Must be called on the DOM object
|
|
void AddAttribute(int node, int attr)
|
|
{
|
|
// Since order just needs to be consistant, we can just push it on the front of the list
|
|
this.nodes[attr].parent = node;
|
|
this.nodes[attr].nextSibling = this.nodes[node].firstAttribute;
|
|
this.nodes[node].firstAttribute = attr;
|
|
}
|
|
|
|
// Append a node to another's set of children
|
|
// Must be called on the DOM object
|
|
void AddChild(int parent, int child)
|
|
{
|
|
// What we do depends on whether there are alredy children
|
|
if (this.nodes[parent].firstChild == NullIndex)
|
|
{
|
|
// Make the node the only child
|
|
this.nodes[parent].firstChild = child;
|
|
this.nodes[child].parent = parent;
|
|
}
|
|
else
|
|
{
|
|
// Make the new child the last sibling of the first child
|
|
AddSibling(this.nodes[parent].firstChild, child);
|
|
}
|
|
}
|
|
|
|
// Add a namespace node
|
|
// Must be called on the DOM object
|
|
void AddNamespace(int node, int ns)
|
|
{
|
|
// Since order just needs to be consistant, we can just push it on the front of the list
|
|
this.nodes[ns].parent = node;
|
|
this.nodes[ns].nextSibling = this.nodes[node].firstNamespace;
|
|
this.nodes[node].firstNamespace = ns;
|
|
}
|
|
|
|
// Make a node the last sibling of another node
|
|
// Must be called on the DOM object
|
|
void AddSibling(int node1, int node2)
|
|
{
|
|
// Get the current last sibling
|
|
int i = LastSibling(node1);
|
|
|
|
// Link the node in after the last sibling
|
|
this.nodes[i].nextSibling = node2;
|
|
this.nodes[node2].prevSibling = i;
|
|
this.nodes[node2].parent = this.nodes[i].parent;
|
|
}
|
|
|
|
// Atomize the necessary strings within a range of nodes.
|
|
// Must be called on the DOM object
|
|
void Atomize(int first, int bound)
|
|
{
|
|
string s;
|
|
for (; first < bound; ++first)
|
|
{
|
|
s = this.nodes[first].prefix;
|
|
if (s != null)
|
|
{
|
|
this.nodes[first].prefix = this.nameTable.Add(s);
|
|
}
|
|
|
|
s = this.nodes[first].name;
|
|
if (s != null)
|
|
{
|
|
this.nodes[first].name = this.nameTable.Add(s);
|
|
}
|
|
|
|
s = this.nodes[first].ns;
|
|
if (s != null)
|
|
{
|
|
this.nodes[first].ns = this.nameTable.Add(s);
|
|
}
|
|
}
|
|
}
|
|
#if NO
|
|
// Verify that a given position is valid for the document, and throw if it is not.
|
|
// The node referenced must already have been constructed
|
|
// Must be called on the DOM object
|
|
void CheckValidPosition(int elem, int parent)
|
|
{
|
|
if (!IsValidPosition(elem, parent))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryProcessingException(QueryProcessingError.InvalidNavigatorPosition, SR.GetString(SR.SeekableMessageNavInvalidPosition)));
|
|
}
|
|
}
|
|
#endif
|
|
// Create a copy of the current namespace stack
|
|
Stack<string> CloneNSStack()
|
|
{
|
|
Stack<string> newStack = new Stack<string>();
|
|
|
|
foreach (string s in this.nsStack)
|
|
{
|
|
newStack.Push(s);
|
|
}
|
|
|
|
return newStack;
|
|
}
|
|
|
|
// Compare the locations of two nodes in the DOM
|
|
// This function assumes the nodes are both in the body or in the same header block
|
|
XmlNodeOrder CompareLocation(int loc1, int loc2)
|
|
{
|
|
if (loc1 == loc2)
|
|
{
|
|
return XmlNodeOrder.Same;
|
|
}
|
|
else if (loc1 < loc2)
|
|
{
|
|
return XmlNodeOrder.Before;
|
|
}
|
|
else
|
|
{
|
|
return XmlNodeOrder.After;
|
|
}
|
|
}
|
|
|
|
// Performs the actual position comparison.
|
|
XmlNodeOrder ComparePosition(int p1, int loc1, int p2, int loc2)
|
|
{
|
|
// Both namespaces of the same node
|
|
if (p1 == p2 && p1 != NullIndex)
|
|
{
|
|
return CompareLocation(loc1, loc2);
|
|
}
|
|
|
|
// Get the element of navigator 1
|
|
int thisNode;
|
|
if (p1 == NullIndex)
|
|
{
|
|
if (this.nodes[loc1].type == XPathNodeType.Attribute)
|
|
{
|
|
thisNode = this.nodes[loc1].parent;
|
|
}
|
|
else
|
|
{
|
|
thisNode = loc1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
thisNode = p1;
|
|
}
|
|
|
|
// Get the element of navigator 2
|
|
int thatNode;
|
|
if (p2 == NullIndex)
|
|
{
|
|
if (this.nodes[loc2].type == XPathNodeType.Attribute)
|
|
{
|
|
thatNode = this.nodes[loc2].parent;
|
|
}
|
|
else
|
|
{
|
|
thatNode = loc2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
thatNode = p2;
|
|
}
|
|
|
|
// If the elements are the same
|
|
if (thisNode == thatNode)
|
|
{
|
|
XPathNodeType type1 = this.nodes[loc1].type;
|
|
XPathNodeType type2 = this.nodes[loc2].type;
|
|
|
|
// We already know they are not both namespaces.
|
|
|
|
if (type1 == XPathNodeType.Namespace)
|
|
{
|
|
if (type2 == XPathNodeType.Attribute)
|
|
{
|
|
// Namespaces come before attributes
|
|
return XmlNodeOrder.Before;
|
|
}
|
|
else
|
|
{
|
|
// loc2 is the element itself
|
|
return XmlNodeOrder.After;
|
|
}
|
|
}
|
|
|
|
if (type2 == XPathNodeType.Namespace)
|
|
{
|
|
if (type1 == XPathNodeType.Attribute)
|
|
{
|
|
// Namespaces come before attributes
|
|
return XmlNodeOrder.After;
|
|
}
|
|
else
|
|
{
|
|
// loc1 is the element itself
|
|
return XmlNodeOrder.Before;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Need to find out which upper level element is the parent of each node
|
|
// Upper level elements are in document order
|
|
|
|
int thisP = thisNode;
|
|
while (thisP > this.bodyIndex)
|
|
{
|
|
thisP = this.nodes[thisP].parent;
|
|
}
|
|
|
|
int thatP = thatNode;
|
|
while (thatP > this.bodyIndex)
|
|
{
|
|
thatP = this.nodes[thatP].parent;
|
|
}
|
|
|
|
if (thisP == thatP)
|
|
{
|
|
return CompareLocation(loc1, loc2);
|
|
}
|
|
else
|
|
{
|
|
return CompareLocation(thisP, thatP);
|
|
}
|
|
}
|
|
|
|
// Decompose the 'long' position into it's element and parent components
|
|
// Must be called on the DOM node
|
|
Position DecodePosition(long pos)
|
|
{
|
|
Position p = new Position((int)pos, (int)(pos >> 32));
|
|
|
|
// Make sure both nodes are valid
|
|
if (p.elem > NullIndex && p.elem < this.nextFreeIndex)
|
|
{
|
|
if (p.parent == NullIndex)
|
|
{
|
|
return p;
|
|
}
|
|
|
|
// If the parent is not null, make sure it is a valid parent and that the element is a namespace node
|
|
if (p.parent > NullIndex && p.parent < this.nextFreeIndex && this.nodes[p.parent].type == XPathNodeType.Element && this.nodes[p.elem].type == XPathNodeType.Namespace)
|
|
{
|
|
// Check that 'parent' is a descendant-or-self of elem->parent
|
|
int n = this.nodes[p.elem].parent;
|
|
int par = p.parent;
|
|
|
|
do
|
|
{
|
|
if (par == n)
|
|
{
|
|
return p;
|
|
}
|
|
|
|
par = this.nodes[par].parent;
|
|
|
|
} while (par != NullIndex);
|
|
}
|
|
}
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryProcessingException(QueryProcessingError.InvalidNavigatorPosition, SR.GetString(SR.SeekableMessageNavInvalidPosition)));
|
|
}
|
|
|
|
// Get the index of the next namespace that matches the scope
|
|
// This function populates the namespace stack too
|
|
// PERF, Microsoft, see if we can have this function set the current location too
|
|
int FindNamespace(int parent, int ns, XPathNamespaceScope scope)
|
|
{
|
|
bool done = false;
|
|
int nsCount = 0;
|
|
|
|
// ns is the first one we try
|
|
while (ns != NullIndex && !done)
|
|
{
|
|
Increase();
|
|
|
|
string nodeName, nodeVal;
|
|
|
|
// Skip any prefixes that are already defined
|
|
nodeName = this.dom.nodes[ns].name;
|
|
if (this.nsStack.Contains(nodeName))
|
|
{
|
|
ns = this.dom.nodes[ns].nextSibling;
|
|
continue;
|
|
}
|
|
this.nsStack.Push(nodeName);
|
|
++nsCount;
|
|
|
|
// Skip the node undefining the default namespace
|
|
nodeVal = this.dom.nodes[ns].val;
|
|
if (nodeName.Length == 0 && nodeVal.Length == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// See if the current namespace is in our scope
|
|
switch (scope)
|
|
{
|
|
case XPathNamespaceScope.All:
|
|
done = true;
|
|
break;
|
|
|
|
case XPathNamespaceScope.ExcludeXml:
|
|
// If it's 'xml', keep looking
|
|
if (String.CompareOrdinal(nodeName, XmlP) == 0)
|
|
{
|
|
Increase();
|
|
ns = this.dom.nodes[ns].nextSibling;
|
|
}
|
|
else
|
|
{
|
|
done = true;
|
|
}
|
|
break;
|
|
|
|
case XPathNamespaceScope.Local:
|
|
// If the node's parent is not the element we're searching from, we've exhausted
|
|
// the locally defined namespaces
|
|
if (this.dom.nodes[ns].parent != parent)
|
|
{
|
|
ns = NullIndex;
|
|
}
|
|
else
|
|
{
|
|
done = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we didn't find one, restore the namespace stack
|
|
if (ns == NullIndex)
|
|
{
|
|
for (int i = 0; i < nsCount; ++i)
|
|
{
|
|
this.nsStack.Pop();
|
|
}
|
|
}
|
|
|
|
return ns;
|
|
}
|
|
|
|
// Returns the qualified name of the given node
|
|
string GetName(int elem)
|
|
{
|
|
string p, n;
|
|
LoadOnDemand(elem);
|
|
p = this.dom.nodes[elem].prefix;
|
|
n = this.dom.nodes[elem].name;
|
|
|
|
if (p != null && p.Length > 0)
|
|
{
|
|
return p + ":" + n;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
// Returns the string value of given node
|
|
// If the value is null, it attempts to acquire it
|
|
// Must only be called on the DOM object
|
|
string GetValue(int elem)
|
|
{
|
|
string val = this.nodes[elem].val;
|
|
if (val == null)
|
|
{
|
|
if (this.stringBuilder == null)
|
|
{
|
|
this.stringBuilder = new StringBuilder();
|
|
}
|
|
else
|
|
{
|
|
this.stringBuilder.Length = 0;
|
|
}
|
|
|
|
GetValueDriver(elem);
|
|
|
|
string s = this.stringBuilder.ToString();
|
|
this.nodes[elem].val = s;
|
|
return s;
|
|
}
|
|
else
|
|
{
|
|
return val;
|
|
}
|
|
}
|
|
|
|
// Recursive function that collects up the string value of element nodes
|
|
// Must only be called on the DOM object
|
|
void GetValueDriver(int elem)
|
|
{
|
|
string val;
|
|
this.dom.LoadOnDemand(elem);
|
|
switch (this.nodes[elem].type)
|
|
{
|
|
// The string value of Element/Root nodes is the concatination of the values of their children
|
|
case XPathNodeType.Element:
|
|
case XPathNodeType.Root:
|
|
val = this.nodes[elem].val;
|
|
if (val == null)
|
|
{
|
|
int n = this.nodes[elem].firstChild;
|
|
while (n != NullIndex)
|
|
{
|
|
Increase();
|
|
GetValueDriver(n);
|
|
n = this.nodes[n].nextSibling;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.stringBuilder.Append(val);
|
|
}
|
|
break;
|
|
|
|
// String value cannot be 'computed' for other node types.
|
|
default:
|
|
this.stringBuilder.Append(this.nodes[elem].val);
|
|
break;
|
|
}
|
|
}
|
|
#if NO
|
|
// Checks if a node index is defined in the current DOM
|
|
// Must be called on the DOM object
|
|
bool IsValidNode(int n, bool allowNull)
|
|
{
|
|
if (allowNull)
|
|
{
|
|
return n >= NullIndex && n < this.dom.nextFreeIndex;
|
|
}
|
|
else
|
|
{
|
|
return n > NullIndex && n < this.dom.nextFreeIndex;
|
|
}
|
|
}
|
|
|
|
// Verify that a given position is valid for the document.
|
|
// The node referenced must already have been constructed
|
|
// Must be called on the DOM object
|
|
bool IsValidPosition(int elem, int parent)
|
|
{
|
|
// Make sure both nodes are valid
|
|
if ( elem > NullIndex && elem < this.nextFreeIndex)
|
|
{
|
|
if (parent == NullIndex)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// If the parent is not null, make sure it is a valid parent
|
|
if (parent > NullIndex && parent < this.nextFreeIndex)
|
|
{
|
|
// The parent must be an element node
|
|
if (this.nodes[parent].type != XPathNodeType.Element)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If the parent is not null, the element must be a namespace node
|
|
if (this.nodes[elem].type != XPathNodeType.Namespace)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check that 'parent' is a descendant-or-self of elem->parent
|
|
int n = this.nodes[elem].parent;
|
|
|
|
while (parent != n)
|
|
{
|
|
parent = this.nodes[parent].parent;
|
|
|
|
if (parent == NullIndex)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
// Find the last child of a node
|
|
// Must be called on the DOM object
|
|
int LastChild(int n)
|
|
{
|
|
// See if there are any children
|
|
n = this.nodes[n].firstChild;
|
|
if (n == NullIndex)
|
|
{
|
|
return NullIndex;
|
|
}
|
|
|
|
// Find the last sibling of the first child
|
|
return LastSibling(n);
|
|
}
|
|
|
|
// Find the last sibling of a node
|
|
// Must be called on the DOM object
|
|
int LastSibling(int n)
|
|
{
|
|
// Walk down the list unitl we get to the end.
|
|
while (this.nodes[n].nextSibling != NullIndex)
|
|
{
|
|
n = this.nodes[n].nextSibling;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
// Load the children of the body element
|
|
// Must be called on the DOM object
|
|
void LoadBody()
|
|
{
|
|
if (!this.message.IsEmpty)
|
|
{
|
|
// Get the body reader
|
|
XmlReader reader = this.message.GetReaderAtBodyContents();
|
|
if (reader.ReadState == ReadState.Initial)
|
|
{
|
|
reader.Read();
|
|
}
|
|
|
|
// Record where we start so we can atomize later
|
|
int lower = this.nextFreeIndex;
|
|
|
|
// Load the children of the body element
|
|
ReadChildNodes(reader, this.bodyIndex, SoapNSIndex);
|
|
|
|
// Record where we finished
|
|
int upper = this.nextFreeIndex;
|
|
|
|
// Atomize if necessary
|
|
if (this.atomize)
|
|
{
|
|
Atomize(lower, upper);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Load the given header node
|
|
// Must be called on the DOM object
|
|
void LoadHeader(int self)
|
|
{
|
|
// Get the header reader
|
|
XmlReader reader = this.headers.GetReaderAtHeader(self - FirstHeaderIndex);
|
|
if (reader.ReadState == ReadState.Initial)
|
|
{
|
|
reader.Read();
|
|
}
|
|
|
|
// Record where we started so we can atomize later
|
|
int lower = this.nextFreeIndex;
|
|
|
|
// Finish populating the header element
|
|
this.nodes[self].firstNamespace = SoapNSIndex;
|
|
this.nodes[self].prefix = this.atomize ? this.nameTable.Add(reader.Prefix) : reader.Prefix;
|
|
this.nodes[self].baseUri = reader.BaseURI;
|
|
this.nodes[self].xmlLang = reader.XmlLang;
|
|
|
|
// We are ignoring any siblings the reader may try to surface.
|
|
// NullIndex will be returned when then next element is the closing tag
|
|
if (!reader.IsEmptyElement)
|
|
{
|
|
ReadAttributes(self, reader);
|
|
reader.Read();
|
|
ReadChildNodes(reader, self, this.nodes[self].firstNamespace);
|
|
}
|
|
else
|
|
{
|
|
ReadAttributes(self, reader);
|
|
}
|
|
|
|
// Record where we finished
|
|
int upper = this.nextFreeIndex;
|
|
|
|
// Atomize if necessary
|
|
if (this.atomize)
|
|
{
|
|
Atomize(lower, upper);
|
|
}
|
|
}
|
|
|
|
// Make sure the current node is fully loaded into the DOM
|
|
// This function does not need to be called from the DOM object
|
|
void LoadOnDemand()
|
|
{
|
|
this.dom.LoadOnDemand(this.location);
|
|
}
|
|
|
|
// Make sure the given node is fully loaded into the DOM
|
|
// Must be called on the DOM object
|
|
// THREAD: Synchronize this function to prevent multiple concurrent loads of the same element.
|
|
// They will cause errors in the DOM structure.
|
|
void LoadOnDemand(int elem)
|
|
{
|
|
// Bail if we're not at a loadable item
|
|
if (elem > this.bodyIndex || elem < FirstHeaderIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Check for the 'unloaded' marker
|
|
if (this.nodes[elem].firstChild == -1)
|
|
{
|
|
// Clear the 'unloaded' marker
|
|
this.nodes[elem].firstChild = 0;
|
|
|
|
// Load as appropriate
|
|
if (elem == this.bodyIndex)
|
|
{
|
|
if (this.includeBody)
|
|
{
|
|
LoadBody();
|
|
}
|
|
else
|
|
{
|
|
// Throw an exception if we try to navigate into the body.
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NavigatorInvalidBodyAccessException(SR.GetString(SR.SeekableMessageNavBodyForbidden)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LoadHeader(elem);
|
|
}
|
|
}
|
|
else if (elem == this.bodyIndex && !this.includeBody)
|
|
{
|
|
// Throw an exception if we try to navigate into the body.
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NavigatorInvalidBodyAccessException(SR.GetString(SR.SeekableMessageNavBodyForbidden)));
|
|
}
|
|
}
|
|
|
|
// Get the index of a new unused node
|
|
// Perform an necessary resizing
|
|
// Must be called on the DOM object
|
|
// THREAD: Synchronize this function. If LoadOnDemand is synchronized, it may be possible to avoid synchronizing this one.
|
|
int NewNode()
|
|
{
|
|
// Resize if necessary
|
|
if (this.nextFreeIndex == this.nodes.Length)
|
|
{
|
|
// Compute the new size for the node array
|
|
int size;
|
|
if (this.nodes.Length <= StretchMax)
|
|
{
|
|
size = this.nodes.Length * GrowFactor;
|
|
}
|
|
else
|
|
{
|
|
size = this.nodes.Length + GrowInc;
|
|
}
|
|
|
|
// Resize the node array
|
|
Node[] tmp = new Node[size];
|
|
this.nodes.CopyTo(tmp, 0);
|
|
this.nodes = tmp;
|
|
}
|
|
|
|
// Return the index of the next free node
|
|
return this.nextFreeIndex++;
|
|
}
|
|
|
|
// Read in the attributes/namespaces and attach them to their element
|
|
// Must be called on the DOM object
|
|
void ReadAttributes(int elem, XmlReader reader)
|
|
{
|
|
int a, n;
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (QueryDataModel.IsAttribute(reader.NamespaceURI))
|
|
{
|
|
a = NewNode();
|
|
this.nodes[a].type = XPathNodeType.Attribute;
|
|
this.nodes[a].prefix = reader.Prefix;
|
|
this.nodes[a].name = reader.LocalName;
|
|
this.nodes[a].ns = reader.NamespaceURI;
|
|
this.nodes[a].val = reader.Value;
|
|
this.nodes[a].baseUri = reader.BaseURI;
|
|
this.nodes[a].xmlLang = reader.XmlLang;
|
|
AddAttribute(elem, a);
|
|
}
|
|
else
|
|
{
|
|
string name = reader.Prefix.Length == 0 ? string.Empty : reader.LocalName;
|
|
|
|
// It is illegal to override the 'xml' and 'xmlns' prefixes
|
|
if (String.CompareOrdinal(name, XmlP) == 0 || String.CompareOrdinal(name, XmlnsP) == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryProcessingException(QueryProcessingError.InvalidNamespacePrefix, SR.GetString(SR.SeekableMessageNavOverrideForbidden, reader.Name)));
|
|
}
|
|
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.Namespace;
|
|
this.nodes[n].name = name;
|
|
this.nodes[n].val = reader.Value;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddNamespace(elem, n);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Load elements from a reader
|
|
// Must be called on the DOM object
|
|
int ReadChildNodes(XmlReader reader, int parent, int parentNS)
|
|
{
|
|
Fx.Assert(reader != null, "Reader cannot be null");
|
|
|
|
// Loop over all nodes being surfaced
|
|
int n = NullIndex;
|
|
do
|
|
{
|
|
// PERF, Microsoft, reorder cases so more common ones are earlier
|
|
switch (reader.NodeType)
|
|
{
|
|
case XmlNodeType.Element:
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.Element;
|
|
this.nodes[n].prefix = reader.Prefix;
|
|
this.nodes[n].name = reader.LocalName;
|
|
this.nodes[n].ns = reader.NamespaceURI;
|
|
this.nodes[n].firstNamespace = parentNS;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
|
|
// Empty elements don't surface closing tags so they need to be handled differently
|
|
if (!reader.IsEmptyElement)
|
|
{
|
|
ReadAttributes(n, reader);
|
|
reader.Read();
|
|
ReadChildNodes(reader, n, this.nodes[n].firstNamespace);
|
|
}
|
|
else
|
|
{
|
|
ReadAttributes(n, reader);
|
|
this.nodes[n].empty = true;
|
|
}
|
|
|
|
AddChild(parent, n);
|
|
break;
|
|
|
|
case XmlNodeType.Comment:
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.Comment;
|
|
this.nodes[n].val = reader.Value;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddChild(parent, n);
|
|
break;
|
|
|
|
case XmlNodeType.ProcessingInstruction:
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.ProcessingInstruction;
|
|
this.nodes[n].name = reader.LocalName;
|
|
this.nodes[n].val = reader.Value;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddChild(parent, n);
|
|
break;
|
|
|
|
case XmlNodeType.SignificantWhitespace:
|
|
if (reader.XmlSpace == XmlSpace.Preserve)
|
|
{
|
|
// If we're preserving whitespace, try to append it to a text node instead
|
|
// of creating a new node
|
|
n = LastChild(parent);
|
|
if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text ||
|
|
this.nodes[n].type == XPathNodeType.Whitespace ||
|
|
this.nodes[n].type == XPathNodeType.SignificantWhitespace))
|
|
{
|
|
this.nodes[n].val = this.nodes[n].val + reader.Value;
|
|
}
|
|
else
|
|
{
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.SignificantWhitespace;
|
|
this.nodes[n].val = reader.Value;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddChild(parent, n);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto case XmlNodeType.Whitespace;
|
|
}
|
|
break;
|
|
|
|
case XmlNodeType.Whitespace:
|
|
if (this.space == XmlSpace.Preserve)
|
|
{
|
|
// If we're preserving whitespace, try to append it to a text node instead
|
|
// of creating a new node
|
|
n = LastChild(parent);
|
|
if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text ||
|
|
this.nodes[n].type == XPathNodeType.Whitespace ||
|
|
this.nodes[n].type == XPathNodeType.SignificantWhitespace))
|
|
{
|
|
this.nodes[n].val = this.nodes[n].val + reader.Value;
|
|
}
|
|
else
|
|
{
|
|
n = NewNode();
|
|
this.nodes[n].type = XPathNodeType.Whitespace;
|
|
this.nodes[n].val = reader.Value;
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddChild(parent, n);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case XmlNodeType.CDATA:
|
|
case XmlNodeType.Text:
|
|
// Try to append it to a text node instead of creating a new node
|
|
n = LastChild(parent);
|
|
if (n == NullIndex || (this.nodes[n].type != XPathNodeType.Text &&
|
|
this.nodes[n].type != XPathNodeType.Whitespace &&
|
|
this.nodes[n].type != XPathNodeType.SignificantWhitespace))
|
|
{
|
|
n = NewNode();
|
|
|
|
|
|
|
|
|
|
this.nodes[n].baseUri = reader.BaseURI;
|
|
this.nodes[n].xmlLang = reader.XmlLang;
|
|
AddChild(parent, n);
|
|
}
|
|
this.nodes[n].type = XPathNodeType.Text;
|
|
this.nodes[n].val = reader.Value;
|
|
break;
|
|
|
|
case XmlNodeType.EntityReference:
|
|
reader.ResolveEntity();
|
|
reader.Read();
|
|
ReadChildNodes(reader, parent, parentNS);
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
case XmlNodeType.EndEntity:
|
|
case XmlNodeType.EndElement:
|
|
case XmlNodeType.None:
|
|
return n;
|
|
|
|
case XmlNodeType.DocumentType:
|
|
break;
|
|
|
|
case XmlNodeType.XmlDeclaration:
|
|
default:
|
|
break;
|
|
}
|
|
} while (reader.Read());
|
|
|
|
return n;
|
|
}
|
|
|
|
int INodeCounter.CounterMarker
|
|
{
|
|
get
|
|
{
|
|
return this.counter.nodeCount;
|
|
}
|
|
set
|
|
{
|
|
this.counter.nodeCount = value;
|
|
}
|
|
}
|
|
|
|
int INodeCounter.MaxCounter
|
|
{
|
|
set
|
|
{
|
|
this.counter.nodeCountMax = value;
|
|
}
|
|
}
|
|
|
|
int INodeCounter.ElapsedCount(int marker)
|
|
{
|
|
return marker - this.counter.nodeCount;
|
|
}
|
|
|
|
void Increase()
|
|
{
|
|
Fx.Assert(this.counter != null, "Counter reference is null");
|
|
if (this.counter.nodeCount > 0)
|
|
{
|
|
--this.counter.nodeCount;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XPathNavigatorException(SR.GetString(SR.FilterNodeQuotaExceeded, this.counter.nodeCountMax)));
|
|
}
|
|
}
|
|
|
|
// PERF, Microsoft, find a better way to implement and have internal
|
|
void INodeCounter.Increase()
|
|
{
|
|
Increase();
|
|
}
|
|
|
|
void INodeCounter.IncreaseBy(int count)
|
|
{
|
|
this.counter.nodeCount -= (count - 1);
|
|
Increase();
|
|
}
|
|
|
|
struct Node
|
|
{
|
|
// Connectivity
|
|
internal int parent;
|
|
internal int firstAttribute;
|
|
internal int firstChild;
|
|
internal int firstNamespace;
|
|
internal int nextSibling;
|
|
internal int prevSibling;
|
|
|
|
// Data
|
|
internal string baseUri;
|
|
internal bool empty;
|
|
internal string name;
|
|
internal string ns;
|
|
internal string prefix;
|
|
internal string val;
|
|
internal string xmlLang;
|
|
|
|
// Type
|
|
internal XPathNodeType type;
|
|
}
|
|
|
|
struct Position
|
|
{
|
|
internal int elem;
|
|
internal int parent;
|
|
|
|
internal Position(int e, int p)
|
|
{
|
|
this.elem = e;
|
|
this.parent = p;
|
|
}
|
|
}
|
|
}
|
|
}
|