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);
}
