|
public ComparePosition ( |
||
| nav | ||
| return | XmlNodeOrder | |
public int Compare(object o1, object o2)
{
XPathNavigator nav1 = o1 as XPathNavigator;
XPathNavigator nav2 = o2 as XPathNavigator;
if (nav1 == null)
{
return(-1);
}
if (nav2 == null)
{
return(1);
}
switch (nav1.ComparePosition(nav2))
{
case XmlNodeOrder.Same:
return(0);
case XmlNodeOrder.After:
return(1);
default:
return(-1);
}
}
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;
}
public int Compare(object o1, object o2)
{
XPathNavigator xpathNavigator = o1 as XPathNavigator;
XPathNavigator xpathNavigator2 = o2 as XPathNavigator;
if (xpathNavigator == null)
{
return(-1);
}
if (xpathNavigator2 == null)
{
return(1);
}
XmlNodeOrder xmlNodeOrder = xpathNavigator.ComparePosition(xpathNavigator2);
if (xmlNodeOrder == XmlNodeOrder.After)
{
return(1);
}
if (xmlNodeOrder != XmlNodeOrder.Same)
{
return(-1);
}
return(0);
}
/// <summary>
/// Add a node indexed by the specified key value.
/// </summary>
public void Add(string key, XPathNavigator navigator) {
XmlQueryNodeSequence seq;
if (!this.table.TryGetValue(key, out seq)) {
// Create a new sequence and add it to the index
seq = new XmlQueryNodeSequence();
seq.AddClone(navigator);
this.table.Add(key, seq);
}
else {
// The nodes are guaranteed to be added in document order with possible duplicates.
// Add node to the existing sequence if it differs from the last one.
Debug.Assert(navigator.ComparePosition(seq[seq.Count - 1]) >= 0, "Index nodes must be added in document order");
if (!navigator.IsSamePosition(seq[seq.Count - 1])) {
seq.AddClone(navigator);
}
}
}
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);
}
void NotVisited(XPathNavigator current)
{
XmlNodeOrder compare;
for (int i = 0; i < _stack.Count; i++)
{
XPathNavigator nav = _stack[i] as XPathNavigator;
compare = nav.ComparePosition(current);
if (compare == XmlNodeOrder.Same)
{
return;
}
if (compare == XmlNodeOrder.Before)
{
_stack.Insert(i, current.Clone());
return;
}
}
_stack.Add(current.Clone());
}
void AddToStack(XPathNavigator current)
{
XmlNodeOrder compare;
for (int i = 0; i < ElementList.Count; i++)
{
XPathNavigator nav = ElementList[i] as XPathNavigator;
compare = nav.ComparePosition(current);
if (compare == XmlNodeOrder.Same)
{
return;
}
if (compare == XmlNodeOrder.Before)
{
ElementList.Insert(i, current.Clone());
return;
}
}
ElementList.Add(current.Clone());
}
/// <summary>
/// Position this iterator to the next preceding node in document order. Discard all input nodes
/// that are followed by another input node in the same document. This leaves one node per document from
/// which the complete set of preceding nodes can be derived without possibility of duplicates.
/// Return IteratorResult.NeedInputNode if the next input node needs to be fetched first. Return
/// IteratorResult.HaveCurrent if the Current property is set to the next node in the iteration.
/// </summary>
public IteratorResult MoveNext(XPathNavigator input)
{
switch (_state)
{
case IteratorState.NeedCandidateCurrent:
// If there are no more input nodes, then iteration is complete
if (input == null)
return IteratorResult.NoMoreNodes;
// Save input node as current node
_navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, input);
// Scan for additional input nodes within the same document (since they are after navCurrent in docorder)
_state = IteratorState.HaveCandidateCurrent;
return IteratorResult.NeedInputNode;
case IteratorState.HaveCandidateCurrent:
// If there are no more input nodes,
if (input == null)
{
// Then candidate node has been selected, and there are no further input nodes
_state = IteratorState.HaveCurrentNoNext;
}
else
{
// If the input node is in the same document as the current node,
if (_navCurrent.ComparePosition(input) != XmlNodeOrder.Unknown)
{
// Then update the current node and get the next input node
_navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, input);
return IteratorResult.NeedInputNode;
}
// Save the input node as navNext
_navNext = XmlQueryRuntime.SyncToNavigator(_navNext, input);
_state = IteratorState.HaveCurrentHaveNext;
}
PushAncestors();
break;
}
if (!_navStack.IsEmpty)
{
while (true)
{
// Move to the next matching node that is before the top node on the stack in document order
if (_filter.MoveToFollowing(_navCurrent, _navStack.Peek()))
// Found match
return IteratorResult.HaveCurrentNode;
// Do not include ancestor nodes as part of the preceding axis
_navCurrent.MoveTo(_navStack.Pop());
// No more preceding matches possible
if (_navStack.IsEmpty)
break;
}
}
if (_state == IteratorState.HaveCurrentNoNext)
{
// No more nodes, so iteration is complete
_state = IteratorState.NeedCandidateCurrent;
return IteratorResult.NoMoreNodes;
}
// Make next node the current node and start trying to find input node greatest in docorder
_navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, _navNext);
_state = IteratorState.HaveCandidateCurrent;
return IteratorResult.HaveCurrentNode;
}
/// <summary>
/// Position this iterator to the next following node. Prune by finding the first input node in
/// document order that has no other input nodes in its subtree. All other input nodes should be
/// discarded. Return IteratorResult.NeedInputNode if the next input node needs to be fetched
/// first. Return IteratorResult.HaveCurrent if the Current property is set to the next node in the
/// iteration.
/// </summary>
public IteratorResult MoveNext(XPathNavigator input)
{
switch (_state)
{
case IteratorState.NeedCandidateCurrent:
// If there are no more input nodes, then iteration is complete
if (input == null)
return IteratorResult.NoMoreNodes;
// Save input node as current node
_navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, input);
// Still must check next input node to see if is a descendant of this one
_state = IteratorState.HaveCandidateCurrent;
return IteratorResult.NeedInputNode;
case IteratorState.HaveCandidateCurrent:
// If there are no more input nodes,
if (input == null)
{
// Then candidate node has been selected, and there are no further input nodes
_state = IteratorState.HaveCurrentNoNext;
return MoveFirst();
}
// If input node is in the subtree of the candidate node, then use the input node instead
if (_navCurrent.IsDescendant(input))
goto case IteratorState.NeedCandidateCurrent;
// Found node on which to perform following scan. Now skip past all input nodes in the same document.
_state = IteratorState.HaveCurrentNeedNext;
goto case IteratorState.HaveCurrentNeedNext;
case IteratorState.HaveCurrentNeedNext:
// If there are no more input nodes,
if (input == null)
{
// Then candidate node has been selected, and there are no further input nodes
_state = IteratorState.HaveCurrentNoNext;
return MoveFirst();
}
// Skip input node unless it's in a different document than the node on which the following scan was performed
if (_navCurrent.ComparePosition(input) != XmlNodeOrder.Unknown)
return IteratorResult.NeedInputNode;
// Next node is in a different document, so save it
_navNext = XmlQueryRuntime.SyncToNavigator(_navNext, input);
_state = IteratorState.HaveCurrentHaveNext;
return MoveFirst();
}
if (!_filter.MoveToFollowing(_navCurrent, null))
return MoveFailed();
return IteratorResult.HaveCurrentNode;
}
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;
}
private static void AddKeyValue(Hashtable keyTable, String key, XPathNavigator value, bool checkDuplicates) {
ArrayList list = (ArrayList)keyTable[key];
if (list == null) {
list = new ArrayList();
keyTable.Add(key, list);
} else {
Debug.Assert(
value.ComparePosition((XPathNavigator) list[list.Count - 1]) != XmlNodeOrder.Before,
"The way we traversing nodes should garantees node-order"
);
if (checkDuplicates) {
// it's posible that this value already was ----osiated with current node
// but if this happened the node is last in the list of values.
if (value.ComparePosition((XPathNavigator) list[list.Count - 1]) == XmlNodeOrder.Same) {
return;
}
} else {
Debug.Assert(
value.ComparePosition((XPathNavigator) list[list.Count - 1]) != XmlNodeOrder.Same,
"checkDuplicates == false : We can't have duplicates"
);
}
}
list.Add(value.Clone());
}
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));
}
/// <summary>
/// Checks an XPathNavigator object to see if it's already in the dependency
/// map. Contains won't work with XPathNavigator objects that point
/// to the same node, you see.
/// </summary>
/// <param name="node">The node to test.</param>
/// <returns>true if it's on the list.</returns>
private bool IsInDependenciesMap(XPathNavigator node)
{
foreach (DependencyList next in this.dependencyMap)
{
if (node.ComparePosition(next.Node) == XmlNodeOrder.Same)
{
return true;
}
}
return false;
}
private bool IsContextUsed(XPathNavigator contextNode)
{
foreach (XPathNavigator nav in this.usedContext)
{
if (contextNode.ComparePosition(nav) == System.Xml.XmlNodeOrder.Same)
{
return true;
}
}
return false;
}
