683 lines
29 KiB
C#
683 lines
29 KiB
C#
|
//------------------------------------------------------------------------------
|
||
|
|
// <copyright file="XPathNodeHelper.cs" company="Microsoft">
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
// </copyright>
|
||
|
|
// <owner current="true" primary="true">[....]</owner>
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
using System;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Text;
|
||
|
|
using System.Xml;
|
||
|
|
using System.Xml.XPath;
|
||
|
|
using System.Xml.Schema;
|
||
|
|
|
||
|
|
namespace MS.Internal.Xml.Cache {
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Library of XPathNode helper routines.
|
||
|
|
/// </summary>
|
||
|
|
internal abstract class XPathNodeHelper {
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return chain of namespace nodes. If specified node has no local namespaces, then 0 will be
|
||
|
|
/// returned. Otherwise, the first node in the chain is guaranteed to be a local namespace (its
|
||
|
|
/// parent is this node). Subsequent nodes may not have the same node as parent, so the caller will
|
||
|
|
/// need to test the parent in order to terminate a search that processes only local namespaces.
|
||
|
|
/// </summary>
|
||
|
|
public static int GetLocalNamespaces(XPathNode[] pageElem, int idxElem, out XPathNode[] pageNmsp) {
|
||
|
|
if (pageElem[idxElem].HasNamespaceDecls) {
|
||
|
|
// Only elements have namespace nodes
|
||
|
|
Debug.Assert(pageElem[idxElem].NodeType == XPathNodeType.Element);
|
||
|
|
return pageElem[idxElem].Document.LookupNamespaces(pageElem, idxElem, out pageNmsp);
|
||
|
|
}
|
||
|
|
pageNmsp = null;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return chain of in-scope namespace nodes for nodes of type Element. Nodes in the chain might not
|
||
|
|
/// have this element as their parent. Since the xmlns:xml namespace node is always in scope, this
|
||
|
|
/// method will never return 0 if the specified node is an element.
|
||
|
|
/// </summary>
|
||
|
|
public static int GetInScopeNamespaces(XPathNode[] pageElem, int idxElem, out XPathNode[] pageNmsp) {
|
||
|
|
XPathDocument doc;
|
||
|
|
|
||
|
|
// Only elements have namespace nodes
|
||
|
|
if (pageElem[idxElem].NodeType == XPathNodeType.Element) {
|
||
|
|
doc = pageElem[idxElem].Document;
|
||
|
|
|
||
|
|
// Walk ancestors, looking for an ancestor that has at least one namespace declaration
|
||
|
|
while (!pageElem[idxElem].HasNamespaceDecls) {
|
||
|
|
idxElem = pageElem[idxElem].GetParent(out pageElem);
|
||
|
|
if (idxElem == 0) {
|
||
|
|
// There are no namespace nodes declared on ancestors, so return xmlns:xml node
|
||
|
|
return doc.GetXmlNamespaceNode(out pageNmsp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Return chain of in-scope namespace nodes
|
||
|
|
return doc.LookupNamespaces(pageElem, idxElem, out pageNmsp);
|
||
|
|
}
|
||
|
|
pageNmsp = null;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the first attribute of the specified node. If no attribute exist, do not
|
||
|
|
/// set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetFirstAttribute(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
if (pageNode[idxNode].HasAttribute) {
|
||
|
|
GetChild(ref pageNode, ref idxNode);
|
||
|
|
Debug.Assert(pageNode[idxNode].NodeType == XPathNodeType.Attribute);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the next attribute sibling of the specified node. If the node is not itself an
|
||
|
|
/// attribute, or if there are no siblings, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetNextAttribute(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page;
|
||
|
|
int idx;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
idx = pageNode[idxNode].GetSibling(out page);
|
||
|
|
if (idx != 0 && page[idx].NodeType == XPathNodeType.Attribute) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the first content-typed child of the specified node. If the node has no children, or
|
||
|
|
/// if the node is not content-typed, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetContentChild(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
if (page[idx].HasContentChild) {
|
||
|
|
GetChild(ref page, ref idx);
|
||
|
|
|
||
|
|
// Skip past attribute children
|
||
|
|
while (page[idx].NodeType == XPathNodeType.Attribute) {
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
Debug.Assert(idx != 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the next content-typed sibling of the specified node. If the node has no siblings, or
|
||
|
|
/// if the node is not content-typed, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetContentSibling(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
if (!page[idx].IsAttrNmsp) {
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
if (idx != 0) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the parent of the specified node. If the node has no parent, do not set pageNode
|
||
|
|
/// or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetParent(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
idx = page[idx].GetParent(out page);
|
||
|
|
if (idx != 0) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a location integer that can be easily compared with other locations from the same document
|
||
|
|
/// in order to determine the relative document order of two nodes.
|
||
|
|
/// </summary>
|
||
|
|
public static int GetLocation(XPathNode[] pageNode, int idxNode) {
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
Debug.Assert(idxNode <= UInt16.MaxValue);
|
||
|
|
Debug.Assert(pageNode[0].PageInfo.PageNumber <= Int16.MaxValue);
|
||
|
|
return (pageNode[0].PageInfo.PageNumber << 16) | idxNode;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the first element child of the specified node that has the specified name. If no such child exists,
|
||
|
|
/// then do not set pageNode or idxNode and return false. Assume that the localName has been atomized with respect
|
||
|
|
/// to this document's name table, but not the namespaceName.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetElementChild(ref XPathNode[] pageNode, ref int idxNode, string localName, string namespaceName) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
// Only check children if at least one element child exists
|
||
|
|
if (page[idx].HasElementChild) {
|
||
|
|
GetChild(ref page, ref idx);
|
||
|
|
Debug.Assert(idx != 0);
|
||
|
|
|
||
|
|
// Find element with specified localName and namespaceName
|
||
|
|
do {
|
||
|
|
if (page[idx].ElementMatch(localName, namespaceName)) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
}
|
||
|
|
while (idx != 0);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a following sibling element of the specified node that has the specified name. If no such
|
||
|
|
/// sibling exists, or if the node is not content-typed, then do not set pageNode or idxNode and
|
||
|
|
/// return false. Assume that the localName has been atomized with respect to this document's name table,
|
||
|
|
/// but not the namespaceName.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetElementSibling(ref XPathNode[] pageNode, ref int idxNode, string localName, string namespaceName) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
// Elements should not be returned as "siblings" of attributes (namespaces don't link to elements, so don't need to check them)
|
||
|
|
if (page[idx].NodeType != XPathNodeType.Attribute) {
|
||
|
|
while (true) {
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
|
||
|
|
if (idx == 0)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (page[idx].ElementMatch(localName, namespaceName)) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the first child of the specified node that has the specified type (must be a content type). If no such
|
||
|
|
/// child exists, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetContentChild(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
int mask;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
// Only check children if at least one content-typed child exists
|
||
|
|
if (page[idx].HasContentChild) {
|
||
|
|
mask = XPathNavigator.GetContentKindMask(typ);
|
||
|
|
|
||
|
|
GetChild(ref page, ref idx);
|
||
|
|
do {
|
||
|
|
if (((1 << (int) page[idx].NodeType) & mask) != 0) {
|
||
|
|
// Never return attributes, as Attribute is not a content type
|
||
|
|
if (typ == XPathNodeType.Attribute)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
}
|
||
|
|
while (idx != 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a following sibling of the specified node that has the specified type. If no such
|
||
|
|
/// sibling exists, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetContentSibling(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
int mask = XPathNavigator.GetContentKindMask(typ);
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
if (page[idx].NodeType != XPathNodeType.Attribute) {
|
||
|
|
while (true) {
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
|
||
|
|
if (idx == 0)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (((1 << (int) page[idx].NodeType) & mask) != 0) {
|
||
|
|
Debug.Assert(typ != XPathNodeType.Attribute && typ != XPathNodeType.Namespace);
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the first preceding sibling of the specified node. If no such sibling exists, then do not set
|
||
|
|
/// pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetPreviousContentSibling(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] pageParent = pageNode, pagePrec, pageAnc;
|
||
|
|
int idxParent = idxNode, idxPrec, idxAnc;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
Debug.Assert(pageNode[idxNode].NodeType != XPathNodeType.Attribute);
|
||
|
|
|
||
|
|
// Since nodes are laid out in document order on pages, the algorithm is:
|
||
|
|
// 1. Get parent of current node
|
||
|
|
// 2. If no parent, then there is no previous sibling, so return false
|
||
|
|
// 3. Get node that immediately precedes the current node in document order
|
||
|
|
// 4. If preceding node is parent, then there is no previous sibling, so return false
|
||
|
|
// 5. Walk ancestors of preceding node, until parent of current node is found
|
||
|
|
idxParent = pageParent[idxParent].GetParent(out pageParent);
|
||
|
|
if (idxParent != 0) {
|
||
|
|
idxPrec = idxNode - 1;
|
||
|
|
if (idxPrec == 0) {
|
||
|
|
// Need to get previous page
|
||
|
|
pagePrec = pageNode[0].PageInfo.PreviousPage;
|
||
|
|
idxPrec = pagePrec.Length - 1;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Previous node is on the same page
|
||
|
|
pagePrec = pageNode;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If parent node is previous node, then no previous sibling
|
||
|
|
if (idxParent == idxPrec && pageParent == pagePrec)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// Find child of parent node by walking ancestor chain
|
||
|
|
pageAnc = pagePrec;
|
||
|
|
idxAnc = idxPrec;
|
||
|
|
do {
|
||
|
|
pagePrec = pageAnc;
|
||
|
|
idxPrec = idxAnc;
|
||
|
|
idxAnc = pageAnc[idxAnc].GetParent(out pageAnc);
|
||
|
|
Debug.Assert(idxAnc != 0 && pageAnc != null);
|
||
|
|
}
|
||
|
|
while (idxAnc != idxParent || pageAnc != pageParent);
|
||
|
|
|
||
|
|
// We found the previous sibling, but if it's an attribute node, then return false
|
||
|
|
if (pagePrec[idxPrec].NodeType != XPathNodeType.Attribute) {
|
||
|
|
pageNode = pagePrec;
|
||
|
|
idxNode = idxPrec;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a previous sibling element of the specified node that has the specified name. If no such
|
||
|
|
/// sibling exists, or if the node is not content-typed, then do not set pageNode or idxNode and
|
||
|
|
/// return false. Assume that the localName has been atomized with respect to this document's name table,
|
||
|
|
/// but not the namespaceName.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetPreviousElementSibling(ref XPathNode[] pageNode, ref int idxNode, string localName, string namespaceName) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
if (page[idx].NodeType != XPathNodeType.Attribute) {
|
||
|
|
while (true) {
|
||
|
|
if (!GetPreviousContentSibling(ref page, ref idx))
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (page[idx].ElementMatch(localName, namespaceName)) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a previous sibling of the specified node that has the specified type. If no such
|
||
|
|
/// sibling exists, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetPreviousContentSibling(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
int mask = XPathNavigator.GetContentKindMask(typ);
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
while (true) {
|
||
|
|
if (!GetPreviousContentSibling(ref page, ref idx))
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (((1 << (int) page[idx].NodeType) & mask) != 0) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the attribute of the specified node that has the specified name. If no such attribute exists,
|
||
|
|
/// then do not set pageNode or idxNode and return false. Assume that the localName has been atomized with respect
|
||
|
|
/// to this document's name table, but not the namespaceName.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetAttribute(ref XPathNode[] pageNode, ref int idxNode, string localName, string namespaceName) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
// Find attribute with specified localName and namespaceName
|
||
|
|
if (page[idx].HasAttribute) {
|
||
|
|
GetChild(ref page, ref idx);
|
||
|
|
do {
|
||
|
|
if (page[idx].NameMatch(localName, namespaceName)) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
idx = page[idx].GetSibling(out page);
|
||
|
|
}
|
||
|
|
while (idx != 0 && page[idx].NodeType == XPathNodeType.Attribute);
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Get the next non-virtual (not collapsed text, not namespaces) node that follows the specified node in document order.
|
||
|
|
/// If no such node exists, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetFollowing(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
|
||
|
|
do {
|
||
|
|
// Next non-virtual node is in next slot within the page
|
||
|
|
if (++idx < page[0].PageInfo.NodeCount) {
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, start at the beginning of the next page
|
||
|
|
page = page[0].PageInfo.NextPage;
|
||
|
|
idx = 0;
|
||
|
|
}
|
||
|
|
while (page != null);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Get the next element node that:
|
||
|
|
/// 1. Follows the current node in document order (includes descendants, unlike XPath following axis)
|
||
|
|
/// 2. Precedes the ending node in document order (if pageEnd is null, then all following nodes in the document are considered)
|
||
|
|
/// 3. Has the specified QName
|
||
|
|
/// If no such element exists, then do not set pageCurrent or idxCurrent and return false.
|
||
|
|
/// Assume that the localName has been atomized with respect to this document's name table, but not the namespaceName.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetElementFollowing(ref XPathNode[] pageCurrent, ref int idxCurrent, XPathNode[] pageEnd, int idxEnd, string localName, string namespaceName) {
|
||
|
|
XPathNode[] page = pageCurrent;
|
||
|
|
int idx = idxCurrent;
|
||
|
|
Debug.Assert(pageCurrent != null && idxCurrent != 0, "Cannot pass null argument(s)");
|
||
|
|
|
||
|
|
// If current node is an element having a matching name,
|
||
|
|
if (page[idx].NodeType == XPathNodeType.Element && (object) page[idx].LocalName == (object) localName) {
|
||
|
|
// Then follow similar element name pointers
|
||
|
|
int idxPageEnd = 0;
|
||
|
|
int idxPageCurrent;
|
||
|
|
|
||
|
|
if (pageEnd != null) {
|
||
|
|
idxPageEnd = pageEnd[0].PageInfo.PageNumber;
|
||
|
|
idxPageCurrent = page[0].PageInfo.PageNumber;
|
||
|
|
|
||
|
|
// If ending node is <= starting node in document order, then scan to end of document
|
||
|
|
if (idxPageCurrent > idxPageEnd || (idxPageCurrent == idxPageEnd && idx >= idxEnd))
|
||
|
|
pageEnd = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (true) {
|
||
|
|
idx = page[idx].GetSimilarElement(out page);
|
||
|
|
|
||
|
|
if (idx == 0)
|
||
|
|
break;
|
||
|
|
|
||
|
|
// Only scan to ending node
|
||
|
|
if (pageEnd != null) {
|
||
|
|
idxPageCurrent = page[0].PageInfo.PageNumber;
|
||
|
|
if (idxPageCurrent > idxPageEnd)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (idxPageCurrent == idxPageEnd && idx >= idxEnd)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((object) page[idx].LocalName == (object) localName && page[idx].NamespaceUri == namespaceName)
|
||
|
|
goto FoundNode;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Since nodes are laid out in document order on pages, scan them sequentially
|
||
|
|
// rather than following links.
|
||
|
|
idx++;
|
||
|
|
do {
|
||
|
|
if ((object) page == (object) pageEnd && idx <= idxEnd) {
|
||
|
|
// Only scan to termination point
|
||
|
|
while (idx != idxEnd) {
|
||
|
|
if (page[idx].ElementMatch(localName, namespaceName))
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Scan all nodes in the page
|
||
|
|
while (idx < page[0].PageInfo.NodeCount) {
|
||
|
|
if (page[idx].ElementMatch(localName, namespaceName))
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
page = page[0].PageInfo.NextPage;
|
||
|
|
idx = 1;
|
||
|
|
}
|
||
|
|
while (page != null);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
|
||
|
|
FoundNode:
|
||
|
|
// Found match
|
||
|
|
pageCurrent = page;
|
||
|
|
idxCurrent = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Get the next node that:
|
||
|
|
/// 1. Follows the current node in document order (includes descendants, unlike XPath following axis)
|
||
|
|
/// 2. Precedes the ending node in document order (if pageEnd is null, then all following nodes in the document are considered)
|
||
|
|
/// 3. Has the specified XPathNodeType (but Attributes and Namespaces never match)
|
||
|
|
/// If no such node exists, then do not set pageCurrent or idxCurrent and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetContentFollowing(ref XPathNode[] pageCurrent, ref int idxCurrent, XPathNode[] pageEnd, int idxEnd, XPathNodeType typ) {
|
||
|
|
XPathNode[] page = pageCurrent;
|
||
|
|
int idx = idxCurrent;
|
||
|
|
int mask = XPathNavigator.GetContentKindMask(typ);
|
||
|
|
Debug.Assert(pageCurrent != null && idxCurrent != 0, "Cannot pass null argument(s)");
|
||
|
|
Debug.Assert(typ != XPathNodeType.Text, "Text should be handled by GetTextFollowing in order to take into account collapsed text.");
|
||
|
|
Debug.Assert(page[idx].NodeType != XPathNodeType.Attribute, "Current node should never be an attribute or namespace--caller should handle this case.");
|
||
|
|
|
||
|
|
// Since nodes are laid out in document order on pages, scan them sequentially
|
||
|
|
// rather than following sibling/child/parent links.
|
||
|
|
idx++;
|
||
|
|
do {
|
||
|
|
if ((object) page == (object) pageEnd && idx <= idxEnd) {
|
||
|
|
// Only scan to termination point
|
||
|
|
while (idx != idxEnd) {
|
||
|
|
if (((1 << (int) page[idx].NodeType) & mask) != 0)
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Scan all nodes in the page
|
||
|
|
while (idx < page[0].PageInfo.NodeCount) {
|
||
|
|
if (((1 << (int) page[idx].NodeType) & mask) != 0)
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
page = page[0].PageInfo.NextPage;
|
||
|
|
idx = 1;
|
||
|
|
}
|
||
|
|
while (page != null);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
|
||
|
|
FoundNode:
|
||
|
|
Debug.Assert(!page[idx].IsAttrNmsp, "GetContentFollowing should never return attributes or namespaces.");
|
||
|
|
|
||
|
|
// Found match
|
||
|
|
pageCurrent = page;
|
||
|
|
idxCurrent = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Scan all nodes that follow the current node in document order, but precede the ending node in document order.
|
||
|
|
/// Return two types of nodes with non-null text:
|
||
|
|
/// 1. Element parents of collapsed text nodes (since it is the element parent that has the collapsed text)
|
||
|
|
/// 2. Non-collapsed text nodes
|
||
|
|
/// If no such node exists, then do not set pageCurrent or idxCurrent and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetTextFollowing(ref XPathNode[] pageCurrent, ref int idxCurrent, XPathNode[] pageEnd, int idxEnd) {
|
||
|
|
XPathNode[] page = pageCurrent;
|
||
|
|
int idx = idxCurrent;
|
||
|
|
Debug.Assert(pageCurrent != null && idxCurrent != 0, "Cannot pass null argument(s)");
|
||
|
|
Debug.Assert(!page[idx].IsAttrNmsp, "Current node should never be an attribute or namespace--caller should handle this case.");
|
||
|
|
|
||
|
|
// Since nodes are laid out in document order on pages, scan them sequentially
|
||
|
|
// rather than following sibling/child/parent links.
|
||
|
|
idx++;
|
||
|
|
do {
|
||
|
|
if ((object) page == (object) pageEnd && idx <= idxEnd) {
|
||
|
|
// Only scan to termination point
|
||
|
|
while (idx != idxEnd) {
|
||
|
|
if (page[idx].IsText || (page[idx].NodeType == XPathNodeType.Element && page[idx].HasCollapsedText))
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Scan all nodes in the page
|
||
|
|
while (idx < page[0].PageInfo.NodeCount) {
|
||
|
|
if (page[idx].IsText || (page[idx].NodeType == XPathNodeType.Element && page[idx].HasCollapsedText))
|
||
|
|
goto FoundNode;
|
||
|
|
idx++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
page = page[0].PageInfo.NextPage;
|
||
|
|
idx = 1;
|
||
|
|
}
|
||
|
|
while (page != null);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
|
||
|
|
FoundNode:
|
||
|
|
// Found match
|
||
|
|
pageCurrent = page;
|
||
|
|
idxCurrent = idx;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Get the next non-virtual (not collapsed text, not namespaces) node that follows the specified node in document order,
|
||
|
|
/// but is not a descendant. If no such node exists, then do not set pageNode or idxNode and return false.
|
||
|
|
/// </summary>
|
||
|
|
public static bool GetNonDescendant(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
XPathNode[] page = pageNode;
|
||
|
|
int idx = idxNode;
|
||
|
|
|
||
|
|
// Get page, idx at which to end sequential scan of nodes
|
||
|
|
do {
|
||
|
|
// If the current node has a sibling,
|
||
|
|
if (page[idx].HasSibling) {
|
||
|
|
// Then that is the first non-descendant
|
||
|
|
pageNode = page;
|
||
|
|
idxNode = page[idx].GetSibling(out pageNode);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, try finding a sibling at the parent level
|
||
|
|
idx = page[idx].GetParent(out page);
|
||
|
|
}
|
||
|
|
while (idx != 0);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return the page and index of the first child (attribute or content) of the specified node.
|
||
|
|
/// </summary>
|
||
|
|
private static void GetChild(ref XPathNode[] pageNode, ref int idxNode) {
|
||
|
|
Debug.Assert(pageNode[idxNode].HasAttribute || pageNode[idxNode].HasContentChild, "Caller must check HasAttribute/HasContentChild on parent before calling GetChild.");
|
||
|
|
Debug.Assert(pageNode[idxNode].HasAttribute || !pageNode[idxNode].HasCollapsedText, "Text child is virtualized and therefore is not present in the physical node page.");
|
||
|
|
|
||
|
|
if (++idxNode >= pageNode.Length) {
|
||
|
|
// Child is first node on next page
|
||
|
|
pageNode = pageNode[0].PageInfo.NextPage;
|
||
|
|
idxNode = 1;
|
||
|
|
}
|
||
|
|
// Else child is next node on this page
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|