/// <summary> /// Returns: /// XmlNodeOrder.Unknown -- This navigator and the "other" navigator are not of the same type, or the /// navigator's are not positioned on nodes in the same document. /// XmlNodeOrder.Before -- This navigator's current node is before the "other" navigator's current node /// in document order. /// XmlNodeOrder.After -- This navigator's current node is after the "other" navigator's current node /// in document order. /// XmlNodeOrder.Same -- This navigator is positioned on the same node as the "other" navigator. /// </summary> public override XmlNodeOrder ComparePosition(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { XPathDocument thisDoc = _pageCurrent[_idxCurrent].Document; XPathDocument thatDoc = that._pageCurrent[that._idxCurrent].Document; if ((object)thisDoc == (object)thatDoc) { int locThis = GetPrimaryLocation(); int locThat = that.GetPrimaryLocation(); if (locThis == locThat) { locThis = GetSecondaryLocation(); locThat = that.GetSecondaryLocation(); if (locThis == locThat) { return(XmlNodeOrder.Same); } } return((locThis < locThat) ? XmlNodeOrder.Before : XmlNodeOrder.After); } } return(XmlNodeOrder.Unknown); }
public override bool IsDescendant(XPathNavigator other) { XPathDocumentNavigator navigator = other as XPathDocumentNavigator; if (navigator != null) { XPathNode[] pageParent; int idxParent; if (navigator.idxParent != 0) { pageParent = navigator.pageParent; idxParent = navigator.idxParent; } else { idxParent = navigator.pageCurrent[navigator.idxCurrent].GetParent(out pageParent); } while (idxParent != 0) { if ((idxParent == this.idxCurrent) && (pageParent == this.pageCurrent)) { return(true); } idxParent = pageParent[idxParent].GetParent(out pageParent); } } return(false); }
/// <summary> /// Return true if the "other" navigator's current node is a descendant of this navigator's current node. /// </summary> public override bool IsDescendant(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { XPathNode[] pageThat; int idxThat; // If that current node's parent is virtualized, then start with the virtual parent if (that._idxParent != 0) { pageThat = that._pageParent; idxThat = that._idxParent; } else { idxThat = that._pageCurrent[that._idxCurrent].GetParent(out pageThat); } while (idxThat != 0) { if (idxThat == _idxCurrent && pageThat == _pageCurrent) { return(true); } idxThat = pageThat[idxThat].GetParent(out pageThat); } } return(false); }
public override XmlNodeOrder ComparePosition(XPathNavigator other) { XPathDocumentNavigator navigator = other as XPathDocumentNavigator; if (navigator != null) { XPathDocument document = this.pageCurrent[this.idxCurrent].Document; XPathDocument document2 = navigator.pageCurrent[navigator.idxCurrent].Document; if (document == document2) { int primaryLocation = this.GetPrimaryLocation(); int secondaryLocation = navigator.GetPrimaryLocation(); if (primaryLocation == secondaryLocation) { primaryLocation = this.GetSecondaryLocation(); secondaryLocation = navigator.GetSecondaryLocation(); if (primaryLocation == secondaryLocation) { return(XmlNodeOrder.Same); } } if (primaryLocation >= secondaryLocation) { return(XmlNodeOrder.After); } return(XmlNodeOrder.Before); } } return(XmlNodeOrder.Unknown); }
/// <summary> /// Create a new iterator that is a copy of "iter". /// </summary> public XPathDocumentElementDescendantIterator(XPathDocumentElementDescendantIterator iter) : base(iter) { this.end = iter.end; this.localName = iter.localName; this.namespaceUri = iter.namespaceUri; this.matchSelf = iter.matchSelf; }
/// <summary> /// Create an iterator that ranges over all element children of "parent" having the specified QName. /// </summary> public XPathDocumentElementChildIterator(XPathDocumentNavigator parent, string name, string namespaceURI) : base(parent) { ArgumentNullException.ThrowIfNull(namespaceURI); _localName = parent.NameTable.Get(name); _namespaceUri = namespaceURI; }
/// <summary> /// Create a new iterator that is a copy of "iter". /// </summary> public XPathDocumentElementDescendantIterator(XPathDocumentElementDescendantIterator iter) : base(iter) { _end = iter._end; _localName = iter._localName; _namespaceUri = iter._namespaceUri; _matchSelf = iter._matchSelf; }
public XPathDocumentElementChildIterator(XPathDocumentNavigator parent, string name, string namespaceURI) : base(parent) { if (namespaceURI == null) { throw new ArgumentNullException("namespaceURI"); } this.localName = parent.NameTable.Get(name); this.namespaceUri = namespaceURI; }
public override bool IsSamePosition(XPathNavigator other) { XPathDocumentNavigator navigator = other as XPathDocumentNavigator; if (navigator == null) { return(false); } return((((this.idxCurrent == navigator.idxCurrent) && (this.pageCurrent == navigator.pageCurrent)) && (this.idxParent == navigator.idxParent)) && (this.pageParent == navigator.pageParent)); }
public XPathDocumentKindDescendantIterator(XPathDocumentNavigator root, XPathNodeType typ, bool matchSelf) : base(root) { this.typ = typ; this.matchSelf = matchSelf; if (root.NodeType != XPathNodeType.Root) { this.end = new XPathDocumentNavigator(root); this.end.MoveToNonDescendant(); } }
/// <summary> /// Returns true if this navigator is positioned to the same node as the "other" navigator. Returns false /// if not, or if the "other" navigator is not the same type as this navigator. /// </summary> public override bool IsSamePosition(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { return _idxCurrent == that._idxCurrent && _pageCurrent == that._pageCurrent && _idxParent == that._idxParent && _pageParent == that._pageParent; } return false; }
/// <summary> /// Returns true if this navigator is positioned to the same node as the "other" navigator. Returns false /// if not, or if the "other" navigator is not the same type as this navigator. /// </summary> public override bool IsSamePosition(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { return(this.idxCurrent == that.idxCurrent && this.pageCurrent == that.pageCurrent && this.idxParent == that.idxParent && this.pageParent == that.pageParent); } return(false); }
/// <summary> /// Create an iterator that ranges over all content descendants of "root" having the specified XPathNodeType. /// </summary> public XPathDocumentKindDescendantIterator(XPathDocumentNavigator root, XPathNodeType typ, bool matchSelf) : base(root) { this.typ = typ; this.matchSelf = matchSelf; // Find the next non-descendant node that follows "root" in document order if (root.NodeType != XPathNodeType.Root) { this.end = new XPathDocumentNavigator(root); this.end.MoveToNonDescendant(); } }
/// <summary> /// Position this navigator to the same position as the "other" navigator. If the "other" navigator /// is not of the same type as this navigator, then return false. /// </summary> public override bool MoveTo(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { _pageCurrent = that._pageCurrent; _idxCurrent = that._idxCurrent; _pageParent = that._pageParent; _idxParent = that._idxParent; return true; } return false; }
/// <summary> /// Position this navigator to the same position as the "other" navigator. If the "other" navigator /// is not of the same type as this navigator, then return false. /// </summary> public override bool MoveTo(XPathNavigator other) { XPathDocumentNavigator that = other as XPathDocumentNavigator; if (that != null) { this.pageCurrent = that.pageCurrent; this.idxCurrent = that.idxCurrent; this.pageParent = that.pageParent; this.idxParent = that.idxParent; return(true); } return(false); }
/// <summary> /// Create an iterator that ranges over all element descendants of "root" having the specified QName. /// </summary> public XPathDocumentElementDescendantIterator(XPathDocumentNavigator root, string name, string namespaceURI, bool matchSelf) : base(root) { ArgumentNullException.ThrowIfNull(namespaceURI); _localName = root.NameTable.Get(name); _namespaceUri = namespaceURI; _matchSelf = matchSelf; // Find the next non-descendant node that follows "root" in document order if (root.NodeType != XPathNodeType.Root) { _end = new XPathDocumentNavigator(root); _end.MoveToNonDescendant(); } }
public XPathDocumentElementDescendantIterator(XPathDocumentNavigator root, string name, string namespaceURI, bool matchSelf) : base(root) { if (namespaceURI == null) { throw new ArgumentNullException("namespaceURI"); } this.localName = root.NameTable.Get(name); this.namespaceUri = namespaceURI; this.matchSelf = matchSelf; if (root.NodeType != XPathNodeType.Root) { this.end = new XPathDocumentNavigator(root); this.end.MoveToNonDescendant(); } }
private int GetFollowingEnd(XPathDocumentNavigator end, bool useParentOfVirtual, out XPathNode[] pageEnd) { if ((end != null) && (this.pageCurrent[this.idxCurrent].Document == end.pageCurrent[end.idxCurrent].Document)) { if (end.idxParent == 0) { pageEnd = end.pageCurrent; return(end.idxCurrent); } pageEnd = end.pageParent; if (!useParentOfVirtual) { return(end.idxParent + 1); } return(end.idxParent); } pageEnd = null; return(0); }
/// <summary> /// "end" is positioned on a node which terminates a following scan. Return the page and index of "end" if it /// is positioned to a non-virtual node. If "end" is positioned to a virtual node: /// 1. If useParentOfVirtual is true, then return the page and index of the virtual node's parent /// 2. If useParentOfVirtual is false, then return the page and index of the virtual node's parent + 1. /// </summary> private int GetFollowingEnd(XPathDocumentNavigator end, bool useParentOfVirtual, out XPathNode[] pageEnd) { // If ending navigator is positioned to a node in another document, then return null if (end != null && _pageCurrent[_idxCurrent].Document == end._pageCurrent[end._idxCurrent].Document) { // If the ending navigator is not positioned on a virtual node, then return its current node if (end._idxParent == 0) { pageEnd = end._pageCurrent; return(end._idxCurrent); } // If the ending navigator is positioned on an attribute, namespace, or virtual text node, then use the // next physical node instead, as the results will be the same. pageEnd = end._pageParent; return((useParentOfVirtual) ? end._idxParent : end._idxParent + 1); } // No following, so set pageEnd to null and return an index of 0 pageEnd = null; return(0); }
/// <summary> /// Create an iterator that ranges over all element children of "parent" having the specified QName. /// </summary> public XPathDocumentElementChildIterator(XPathDocumentNavigator parent, string name, string namespaceURI !!) : base(parent)
/// <summary> /// Create a new iterator that is a copy of "iter". /// </summary> protected XPathDocumentBaseIterator(XPathDocumentBaseIterator iter) { this.ctxt = new XPathDocumentNavigator(iter.ctxt); this.pos = iter.pos; }
/// <summary> /// Create a new iterator that is initially positioned on the "ctxt" node. /// </summary> protected XPathDocumentBaseIterator(XPathDocumentNavigator ctxt) { this.ctxt = new XPathDocumentNavigator(ctxt); }
/// <summary> /// Create a new iterator that is a copy of "iter". /// </summary> public XPathDocumentKindDescendantIterator(XPathDocumentKindDescendantIterator iter) : base(iter) { this.end = iter.end; this.typ = iter.typ; this.matchSelf = iter.matchSelf; }
/// <summary> /// Create a new iterator that is a copy of "iter". /// </summary> public XPathDocumentKindDescendantIterator(XPathDocumentKindDescendantIterator iter) : base(iter) { _end = iter._end; _typ = iter._typ; _matchSelf = iter._matchSelf; }
public override bool MoveToFollowing(XPathNodeType type, XPathNavigator end) { XPathNode[] nodeArray2; int num2; XPathDocumentNavigator navigator = end as XPathDocumentNavigator; if ((type == XPathNodeType.Text) || (type == XPathNodeType.All)) { if (this.pageCurrent[this.idxCurrent].HasCollapsedText) { if (((navigator != null) && (this.idxCurrent == navigator.idxParent)) && (this.pageCurrent == navigator.pageParent)) { return(false); } this.pageParent = this.pageCurrent; this.idxParent = this.idxCurrent; this.idxCurrent = this.pageCurrent[this.idxCurrent].Document.GetCollapsedTextNode(out this.pageCurrent); return(true); } if (type == XPathNodeType.Text) { XPathNode[] pageParent; int idxParent; num2 = this.GetFollowingEnd(navigator, true, out nodeArray2); if (this.idxParent != 0) { pageParent = this.pageParent; idxParent = this.idxParent; } else { pageParent = this.pageCurrent; idxParent = this.idxCurrent; } if (((navigator != null) && (navigator.idxParent != 0)) && ((idxParent == num2) && (pageParent == nodeArray2))) { return(false); } if (!XPathNodeHelper.GetTextFollowing(ref pageParent, ref idxParent, nodeArray2, num2)) { return(false); } if (pageParent[idxParent].NodeType == XPathNodeType.Element) { this.idxCurrent = pageParent[idxParent].Document.GetCollapsedTextNode(out this.pageCurrent); this.pageParent = pageParent; this.idxParent = idxParent; } else { this.pageCurrent = pageParent; this.idxCurrent = idxParent; this.pageParent = null; this.idxParent = 0; } return(true); } } num2 = this.GetFollowingEnd(navigator, false, out nodeArray2); if (this.idxParent == 0) { return(XPathNodeHelper.GetContentFollowing(ref this.pageCurrent, ref this.idxCurrent, nodeArray2, num2, type)); } if (!XPathNodeHelper.GetContentFollowing(ref this.pageParent, ref this.idxParent, nodeArray2, num2, type)) { return(false); } this.pageCurrent = this.pageParent; this.idxCurrent = this.idxParent; this.pageParent = null; this.idxParent = 0; return(true); }
/// <summary> /// Create an iterator that ranges over all content children of "parent" having the specified XPathNodeType. /// </summary> public XPathDocumentKindChildIterator(XPathDocumentNavigator parent, XPathNodeType typ) : base(parent) { this.typ = typ; }
public XPathDocumentNavigator(XPathDocumentNavigator nav) : this(nav._pageCurrent, nav._idxCurrent, nav._pageParent, nav._idxParent) { _atomizedLocalName = nav._atomizedLocalName; }
/// <summary> /// Move to the next node that: /// 1. Follows the current node in document order (includes descendants, unlike XPath following axis) /// 2. Precedes "end" in document order (if end is null, then all following nodes in the document are considered) /// 3. Has the specified XPathNodeType /// Return false if the current node has no matching following nodes. /// </summary> public override bool MoveToFollowing(XPathNodeType type, XPathNavigator end) { XPathDocumentNavigator endTiny = end as XPathDocumentNavigator; XPathNode[] page, pageEnd; int idx, idxEnd; // If searching for text, make sure to handle collapsed text nodes correctly if (type == XPathNodeType.Text || type == XPathNodeType.All) { if (_pageCurrent[_idxCurrent].HasCollapsedText) { // Positioned on an element with collapsed text, so return the virtual text node, assuming it's before "end" if (endTiny != null && _idxCurrent == endTiny._idxParent && _pageCurrent == endTiny._pageParent) { // "end" is positioned to a virtual attribute, namespace, or text node return(false); } _pageParent = _pageCurrent; _idxParent = _idxCurrent; _idxCurrent = _pageCurrent[_idxCurrent].Document.GetCollapsedTextNode(out _pageCurrent); return(true); } if (type == XPathNodeType.Text) { // Get node on which scan ends (null if rest of document should be scanned, parent if positioned on virtual node) idxEnd = GetFollowingEnd(endTiny, true, out pageEnd); // If this navigator is positioned on a virtual node, then compute following of parent if (_idxParent != 0) { page = _pageParent; idx = _idxParent; } else { page = _pageCurrent; idx = _idxCurrent; } // If ending node is a virtual node, and current node is its parent, then we're done if (endTiny != null && endTiny._idxParent != 0 && idx == idxEnd && page == pageEnd) { return(false); } // Get all virtual (collapsed) and physical text nodes which follow the current node if (!XPathNodeHelper.GetTextFollowing(ref page, ref idx, pageEnd, idxEnd)) { return(false); } if (page[idx].NodeType == XPathNodeType.Element) { // Virtualize collapsed text nodes Debug.Assert(page[idx].HasCollapsedText); _idxCurrent = page[idx].Document.GetCollapsedTextNode(out _pageCurrent); _pageParent = page; _idxParent = idx; } else { // Physical text node Debug.Assert(page[idx].IsText); _pageCurrent = page; _idxCurrent = idx; _pageParent = null; _idxParent = 0; } return(true); } } // Get node on which scan ends (null if rest of document should be scanned, parent + 1 if positioned on virtual node) idxEnd = GetFollowingEnd(endTiny, false, out pageEnd); // If this navigator is positioned on a virtual node, then compute following of parent if (_idxParent != 0) { if (!XPathNodeHelper.GetContentFollowing(ref _pageParent, ref _idxParent, pageEnd, idxEnd, type)) { return(false); } _pageCurrent = _pageParent; _idxCurrent = _idxParent; _pageParent = null; _idxParent = 0; return(true); } return(XPathNodeHelper.GetContentFollowing(ref _pageCurrent, ref _idxCurrent, pageEnd, idxEnd, type)); }