public int Compare(QueryNode item1, QueryNode item2) { XmlNodeOrder order = item1.Node.ComparePosition(item1.Position, item2.Position); int ret; switch (order) { case XmlNodeOrder.Before: ret = -1; break; case XmlNodeOrder.Same: ret = 0; break; case XmlNodeOrder.After: ret = 1; break; case XmlNodeOrder.Unknown: default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new XPathException(SR.GetString(SR.QueryNotSortable))); } return(ret); }
int IComparer.Compare(object o1, object o2) { XPathSortElement xpathSortElement = (XPathSortElement)o1; XPathSortElement xpathSortElement2 = (XPathSortElement)o2; for (int i = 0; i < this._rgSorters.Count; i++) { XPathSorter xpathSorter = (XPathSorter)this._rgSorters[i]; int num = xpathSorter.Compare(xpathSortElement.Values[i], xpathSortElement2.Values[i]); if (num != 0) { return(num); } } XmlNodeOrder xmlNodeOrder = xpathSortElement.Navigator.ComparePosition(xpathSortElement2.Navigator); if (xmlNodeOrder == XmlNodeOrder.After) { return(1); } if (xmlNodeOrder != XmlNodeOrder.Same) { return(-1); } return(0); }
internal override void FillStk() { while ((m_eNext = m_qyInput.advance()) != null) { bool add = true; for (int i = 0; i < _Stk.Count; i++) { XPathNavigator nav = _Stk[i] as XPathNavigator; XmlNodeOrder compare = nav.ComparePosition(m_eNext); if (compare == XmlNodeOrder.Same) { add = false; break; } if (compare == XmlNodeOrder.Before) { _Stk.Insert(i, m_eNext.Clone()); add = false; break; } } if (add) { _Stk.Add(m_eNext.Clone()); } } _fillStk = false; _count = _Stk.Count; }
// Invariant: a[i] < a[i+1] for i > item // returns flase is head of the list was moved & as a result consistancy of list depends on head consistancy. bool SiftItem(int item) { Debug.Assert(firstNotEmpty <= item && item < arr.Length); ResetableIterator it = arr[item]; while (item + 1 < arr.Length) { XmlNodeOrder order = Query.CompareNodes(it.Current, arr[item + 1].Current); if (order == XmlNodeOrder.Before) { break; } if (order == XmlNodeOrder.After) { arr[item] = arr[item + 1]; //arr[item + 1] = it; item++; } else // Same { arr[item] = it; if (!Advance(item)) { return(false); } it = arr[item]; } } arr[item] = it; return(true); }
private bool SiftItem(int item) { ResetableIterator iterator = this.arr[item]; while ((item + 1) < this.arr.Length) { XmlNodeOrder order = Query.CompareNodes(iterator.Current, this.arr[item + 1].Current); if (order == XmlNodeOrder.Before) { break; } if (order == XmlNodeOrder.After) { this.arr[item] = this.arr[item + 1]; item++; } else { this.arr[item] = iterator; if (!this.Advance(item)) { return(false); } iterator = this.arr[item]; } } this.arr[item] = iterator; return(true); }
public int Compare(object obj1, object obj2) { NodeSequenceItem item1 = (NodeSequenceItem)obj1; NodeSequenceItem item2 = (NodeSequenceItem)obj2; XmlNodeOrder order = item1.Node.Node.ComparePosition(item1.Node.Position, item2.Node.Position); int ret; switch (order) { case XmlNodeOrder.Before: ret = -1; break; case XmlNodeOrder.Same: ret = 0; break; case XmlNodeOrder.After: ret = 1; break; case XmlNodeOrder.Unknown: default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XPathException(SR.GetString(SR.QueryNotSortable)), TraceEventType.Critical); } return(ret); }
private static int FindAtPathIndex(XPathNavigator nav) { int index = 0; XPathNavigator buf = nav.Clone(); if (buf.MoveToParent()) { if (buf.MoveToChild(nav.NodeType)) { do { if (buf.LocalName == nav.LocalName) { index++; } XmlNodeOrder cmp = buf.ComparePosition(nav); if (cmp == XmlNodeOrder.Same) { break; } }while (buf.MoveToNext(nav.NodeType)); } } return(index); }
public int Compare(object o1, object o2) { XPathNodeIterator xpathNodeIterator = o1 as XPathNodeIterator; XPathNodeIterator xpathNodeIterator2 = o2 as XPathNodeIterator; if (xpathNodeIterator == null) { return(-1); } if (xpathNodeIterator2 == null) { return(1); } XmlNodeOrder xmlNodeOrder = xpathNodeIterator.Current.ComparePosition(xpathNodeIterator2.Current); if (xmlNodeOrder == XmlNodeOrder.After) { return(-1); } if (xmlNodeOrder != XmlNodeOrder.Same) { return(1); } return(0); }
public override XPathNavigator Advance() { do { if (_needInput) { if (_elementStk.Count == 0) { currentNode = GetNextInput(); if (currentNode == null) { return(null); } if (!currentNode.MoveToFirstChild()) { continue; } position = 0; } else { currentNode = _elementStk.Pop(); position = _positionStk.Pop(); if (!DecideNextNode()) { continue; } } _needInput = false; } else { if (!currentNode.MoveToNext() || !DecideNextNode()) { _needInput = true; continue; } } // TODO: this code was previously removed #if DEBUG if (_lastNode != null) { if (currentNode.GetType().ToString() == "Microsoft.VisualStudio.Modeling.StoreNavigator") { XmlNodeOrder order = CompareNodes(_lastNode, currentNode); Debug.Assert(order == XmlNodeOrder.Before, "Algorith error. Nodes expected to be DocOrderDistinct"); } } lastNode = currentNode.Clone(); #endif if (matches(currentNode)) { position++; return(currentNode); } } while (true); } // Advance
public override XPathNavigator Advance() { XPathNavigator res1, res2; XmlNodeOrder order = 0; if (_advance1) { res1 = qy1.Advance(); } else { res1 = _nextNode; } if (_advance2) { res2 = qy2.Advance(); } else { res2 = _nextNode; } if (res1 != null && res2 != null) { order = CompareNodes(res1, res2); } else if (res2 == null) { _advance1 = true; _advance2 = false; _currentNode = res1; _nextNode = null; return(res1); } else { _advance1 = false; _advance2 = true; _currentNode = res2; _nextNode = null; return(res2); } if (order == XmlNodeOrder.Before) { return(ProcessBeforePosition(res1, res2)); } else if (order == XmlNodeOrder.After) { return(ProcessAfterPosition(res1, res2)); } else { // BugBug. In case of Unknown we sorting as the same. return(ProcessSamePosition(res1)); } }
FindNode(List <XPathNavigator> arNodes1, List <DocPair> arDocs, XPathNavigator currNode) { // 1. First, find the document of this node, return false if not found // 2. If the document for the node is found and the node is not an immediate // hit, then look for it using binsearch. int start = -1, end = -1, mid; foreach (DocPair p in arDocs) { XmlNodeOrder xOrder = arNodes1[p.First].ComparePosition(currNode); if (xOrder == XmlNodeOrder.Same) { return(true); } //else if (xOrder != XmlNodeOrder.Unknown) { start = p.First; end = p.Second; break; } } if (start == -1) { return(false); } //else perform a binary search in the range [start, end] while (end >= start) { mid = (start + end) / 2; XmlNodeOrder xOrder = arNodes1[mid].ComparePosition(currNode); if (xOrder == XmlNodeOrder.Before) { start = mid + 1; } else if (xOrder == XmlNodeOrder.After) { end = mid - 1; } else { return(true); } } return(false); }
public override XPathNavigator Advance() { XPathNavigator res1, res2; XmlNodeOrder order = 0; if (advance1) { res1 = qy1.Advance(); } else { res1 = nextNode; } if (advance2) { res2 = qy2.Advance(); } else { res2 = nextNode; } if (res1 != null && res2 != null) { order = CompareNodes(res1, res2); } else if (res2 == null) { advance1 = true; advance2 = false; currentNode = res1; nextNode = null; return(res1); } else { advance1 = false; advance2 = true; currentNode = res2; nextNode = null; return(res2); } if (order == XmlNodeOrder.Before) { return(ProcessBeforePosition(res1, res2)); } else if (order == XmlNodeOrder.After) { return(ProcessAfterPosition(res1, res2)); } else { return(ProcessSamePosition(res1)); } }
public override XPathNavigator Advance() { XPathNavigator nextNode; XPathNavigator navigator2; XmlNodeOrder before = XmlNodeOrder.Before; if (this.advance1) { nextNode = this.qy1.Advance(); } else { nextNode = this.nextNode; } if (this.advance2) { navigator2 = this.qy2.Advance(); } else { navigator2 = this.nextNode; } if ((nextNode != null) && (navigator2 != null)) { before = Query.CompareNodes(nextNode, navigator2); } else { if (navigator2 == null) { this.advance1 = true; this.advance2 = false; this.currentNode = nextNode; this.nextNode = null; return(nextNode); } this.advance1 = false; this.advance2 = true; this.currentNode = navigator2; this.nextNode = null; return(navigator2); } switch (before) { case XmlNodeOrder.Before: return(this.ProcessBeforePosition(nextNode, navigator2)); case XmlNodeOrder.After: return(this.ProcessAfterPosition(nextNode, navigator2)); } return(this.ProcessSamePosition(nextNode)); }
private void AddResult(XPathNavigator current) { for (int i = 0; i < _ResultStk.Count; i++) { XPathNavigator nav = _ResultStk[i] as XPathNavigator; XmlNodeOrder compare = nav.ComparePosition(current); if (compare == XmlNodeOrder.Same) { return; } if (compare == XmlNodeOrder.Before) { _ResultStk.Insert(i, current); return; } } _ResultStk.Add(current); }
/// <summary> /// See <see cref="System.Xml.XPath.XPathNavigator.ComparePosition" /> for details. /// </summary> public override XmlNodeOrder ComparePosition(XPathNavigator nav) { ObjectXPathNavigator other = nav as ObjectXPathNavigator; if (other == null) { return(XmlNodeOrder.Unknown); } if (_childNav == null && other._childNav == null) { if (_node == other._node) { return(XmlNodeOrder.Same); } Node parent = GetNonTransparentParent(_node); Node otherParent = GetNonTransparentParent(other._node); if (parent == otherParent) { if (_node.NodeType == XPathNodeType.Attribute) { if (other._node.NodeType == XPathNodeType.Attribute) { if (_node.Index < other._node.Index) { return(XmlNodeOrder.Before); } else { return(XmlNodeOrder.After); } } else { return(XmlNodeOrder.Before); } } } } XmlNodeOrder position = base.ComparePosition(nav); return(position); }
public static void AssertQuery(Query query) { Debug.Assert(query != null, "AssertQuery(): query == null"); if (query is FunctionQuery) { return; // Temp Fix. Functions (as document()) return now unordered sequences } query = Clone(query); XPathNavigator last = null; XPathNavigator curr; int querySize = query.Clone().Count; int actualSize = 0; while ((curr = query.Advance()) != null) { if (curr.GetType().ToString() == "Microsoft.VisualStudio.Modeling.StoreNavigator") { return; } if (curr.GetType().ToString() == "System.Xml.DataDocumentXPathNavigator") { return; } Debug.Assert(curr == query.Current, "AssertQuery(): query.Advance() != query.Current"); if (last != null) { if (last.NodeType == XPathNodeType.Namespace && curr.NodeType == XPathNodeType.Namespace) { // NamespaceQuery reports namsespaces in mixed order. // Ignore this for now. // It seams that this doesn't breake other queries becasue NS can't have children } else { XmlNodeOrder cmp = CompareNodes(last, curr); Debug.Assert(cmp == XmlNodeOrder.Before, "AssertQuery(): Wrong node order"); } } last = curr.Clone(); actualSize++; } Debug.Assert(actualSize == querySize, "AssertQuery(): actualSize != querySize"); }
private void AddResult(ArrayList ResultList, XPathNavigator nav) { int count = ResultList.Count; for (int i = 0; i < count; i++) { XmlNodeOrder docOrder = nav.ComparePosition(((XPathNavigator)ResultList[i])); if (docOrder == XmlNodeOrder.Same) { return; } if (docOrder == XmlNodeOrder.Before) { ResultList.Insert(i, nav.Clone()); return; } } ResultList.Add(nav.Clone()); }
public static XmlNodeOrder CompareNodes(XPathNavigator l, XPathNavigator r) { XmlNodeOrder order = l.ComparePosition(r); if (order != XmlNodeOrder.Unknown) { return(order); } XPathNavigator navigator = l.Clone(); navigator.MoveToRoot(); string baseURI = navigator.BaseURI; if (!navigator.MoveTo(r)) { navigator = r.Clone(); } navigator.MoveToRoot(); string strB = navigator.BaseURI; int num = string.CompareOrdinal(baseURI, strB); return((num < 0) ? XmlNodeOrder.Before : ((num > 0) ? XmlNodeOrder.After : XmlNodeOrder.Unknown)); }
public static XmlNodeOrder CompareNodes(XPathNavigator l, XPathNavigator r) { XmlNodeOrder cmp = l.ComparePosition(r); if (cmp == XmlNodeOrder.Unknown) { XPathNavigator copy = l.Clone(); copy.MoveToRoot(); string baseUriL = copy.BaseURI; if (!copy.MoveTo(r)) { copy = r.Clone(); } copy.MoveToRoot(); string baseUriR = copy.BaseURI; int cmpBase = string.CompareOrdinal(baseUriL, baseUriR); cmp = ( cmpBase < 0 ? XmlNodeOrder.Before : cmpBase > 0 ? XmlNodeOrder.After : /*default*/ XmlNodeOrder.Unknown ); } return(cmp); }
internal override XPathNavigator advance() { XPathNavigator res1, res2; XmlNodeOrder order = 0; if (advance1) { res1 = qy1.advance(); } else { res1 = _last; } if (advance2) { res2 = qy2.advance(); } else { res2 = _last; } if (res1 != null && res2 != null) { order = res1.ComparePosition(res2); } else if (res2 == null) { advance1 = true; advance2 = false; m_eNext = res1; _last = null; return(res1); } else { advance1 = false; advance2 = true; m_eNext = res2; _last = null; return(res2); } if (order == XmlNodeOrder.Same) { return(ProcessSamePosition(res1)); } if (order == XmlNodeOrder.Before) { return(ProcessBeforePosition(res1, res2)); } if (order == XmlNodeOrder.After) { return(ProcessAfterPosition(res1, res2)); } //Now order is XmlNodeOrder.Unknown XPathNavigator dummyres1 = res1.Clone(); dummyres1.MoveToRoot(); XPathNavigator dummyres2 = res2.Clone(); dummyres2.MoveToRoot(); int uriOrder = context.CompareDocument(dummyres1.BaseURI, dummyres2.BaseURI); if (uriOrder == 0) { return(ProcessSamePosition(res1)); } if (uriOrder < 0) { return(ProcessBeforePosition(res1, res2)); } if (uriOrder > 0) { return(ProcessAfterPosition(res1, res2)); } Debug.Assert(false, "should not be herein OrQuery.advance()"); return(null); }
public override bool MoveNextCore() { if (this._finished) { return(false); } if (this._iterRight == null) { if (!this._iterLeft.MoveNext()) { return(false); } this._iterRight = this._expr.EvaluateNodeSet(this._iterLeft); this._iterList = new SortedList(XPathIteratorComparer.Instance); } while (!this._iterRight.MoveNext()) { if (this._iterList.Count > 0) { int index = this._iterList.Count - 1; this._iterRight = (BaseIterator)this._iterList.GetByIndex(index); this._iterList.RemoveAt(index); break; } if (this._nextIterRight != null) { this._iterRight = this._nextIterRight; this._nextIterRight = null; break; } if (!this._iterLeft.MoveNext()) { this._finished = true; return(false); } this._iterRight = this._expr.EvaluateNodeSet(this._iterLeft); } bool flag = true; while (flag) { flag = false; if (this._nextIterRight == null) { bool flag2 = false; while (this._nextIterRight == null || !this._nextIterRight.MoveNext()) { if (!this._iterLeft.MoveNext()) { flag2 = true; break; } this._nextIterRight = this._expr.EvaluateNodeSet(this._iterLeft); } if (flag2) { this._nextIterRight = null; } } if (this._nextIterRight != null) { XmlNodeOrder xmlNodeOrder = this._iterRight.Current.ComparePosition(this._nextIterRight.Current); if (xmlNodeOrder != XmlNodeOrder.After) { if (xmlNodeOrder == XmlNodeOrder.Same) { if (!this._nextIterRight.MoveNext()) { this._nextIterRight = null; } else { int count = this._iterList.Count; this._iterList[this._nextIterRight] = this._nextIterRight; if (count != this._iterList.Count) { this._nextIterRight = (BaseIterator)this._iterList.GetByIndex(count); this._iterList.RemoveAt(count); } } flag = true; } } else { this._iterList[this._iterRight] = this._iterRight; this._iterRight = this._nextIterRight; this._nextIterRight = null; flag = true; } } } return(true); }
public override bool MoveNext() { // TODO: investigate removing these variables bool movedRight = false; bool movedLeft = false; if (!moveLeft && !moveRight) { return(false); } if (moveLeft) { movedLeft = left.MoveNext(); } if (moveRight) { movedRight = right.MoveNext(); } if (moveLeft && !movedLeft && moveRight && !movedRight) { return(false); } if (moveLeft && !movedLeft) { moveLeft = false; current = right.Current.Clone(); pos++; return(true); } if (moveRight && !movedRight) { /* from next time, don't move right */ moveRight = false; current = left.Current.Clone(); pos++; return(true); } // both moves were successful or we had leftover nodes from // one side now we need to chose which side to output first XmlNodeOrder order = left.Current.ComparePosition(right.Current); switch (order) { case XmlNodeOrder.Same: { moveRight = moveLeft = true; current = left.Current.Clone(); pos++; return(true); } break; case XmlNodeOrder.Before: case XmlNodeOrder.Unknown: { moveLeft = true; moveRight = false; current = left.Current.Clone(); pos++; return(true); } break; case XmlNodeOrder.After: { moveLeft = false; moveRight = true; current = right.Current.Clone(); pos++; return(true); } break; default: { throw new XPathException("Could understand node relationship : " + order.ToString(), null); } break; } return(false); }