internal XmlNodeOrder ComparePosition( XPathNodePointer other ) {
//Debug.WriteLineIf( XmlTrace.traceXPathNodePointerFunctions.Enabled, "XPathNodePointer:ComparePosition(other)");
RealFoliate();
other.RealFoliate();
Debug.Assert( other != null );
if ( IsSamePosition( other ) )
return XmlNodeOrder.Same;
XmlNode curNode1 = null, curNode2 = null;
//deal with namespace node first
if ( this.NodeType == XPathNodeType.Namespace && other.NodeType == XPathNodeType.Namespace ) {
if ( this._parentOfNS == other._parentOfNS )
return this.CompareNamespacePosition( other );
//if not from the same parent
curNode1 = this._parentOfNS;
curNode2 = other._parentOfNS;
}
else if ( this.NodeType == XPathNodeType.Namespace ) {
Debug.Assert( other.NodeType != XPathNodeType.Namespace );
if ( this._parentOfNS == other._node ) {
//from the same region, NS nodes come before all other nodes
if ( other._column == null )
return XmlNodeOrder.After;
else
return XmlNodeOrder.Before;
}
//if not from the same region
curNode1 = this._parentOfNS;
curNode2 = other._node;
}
else if ( other.NodeType == XPathNodeType.Namespace ) {
Debug.Assert( this.NodeType != XPathNodeType.Namespace );
if ( this._node == other._parentOfNS ) {
//from the same region
if ( this._column == null )
return XmlNodeOrder.Before;
else
return XmlNodeOrder.After;
}
//if not from the same region
curNode1 = this._node;
curNode2 = other._parentOfNS;
}
else {
if ( this._node == other._node ) {
//compare within the same region
if ( this._column == other._column ) {
//one is the children of the other
Debug.Assert( this._fOnValue != other._fOnValue );
if ( this._fOnValue )
return XmlNodeOrder.After;
else
return XmlNodeOrder.Before;
}
else {
Debug.Assert( this.Row == other.Row ); //in the same row
if ( this._column == null )
return XmlNodeOrder.Before;
else if ( other._column == null )
return XmlNodeOrder.After;
else if ( this._column.Ordinal < other._column.Ordinal )
return XmlNodeOrder.Before;
else
return XmlNodeOrder.After;
}
}
curNode1 = this._node;
curNode2 = other._node;
}
Debug.Assert( curNode1 != null );
Debug.Assert( curNode2 != null );
if (curNode1 == null || curNode2 == null) {
return XmlNodeOrder.Unknown;
}
int depth1 = -1, depth2 = -1;
XmlNode root1 = XPathNodePointer.GetRoot( curNode1, ref depth1 );
XmlNode root2 = XPathNodePointer.GetRoot( curNode2, ref depth2 );
if ( root1 != root2 )
return XmlNodeOrder.Unknown;
if ( depth1 > depth2 ) {
while ( curNode1 != null && depth1 > depth2 ) {
curNode1 = ( ( curNode1.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode1).OwnerElement ) : ( curNode1.ParentNode ) );
depth1--;
}
if ( curNode1 == curNode2 )
return XmlNodeOrder.After;
}
else if ( depth2 > depth1 ) {
while ( curNode2 != null && depth2 > depth1 ) {
curNode2 = ( ( curNode2.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode2).OwnerElement ) : ( curNode2.ParentNode ) );
depth2--;
}
if ( curNode1 == curNode2 )
return XmlNodeOrder.Before;
}
XmlNode parent1 = GetParent(curNode1);
XmlNode parent2 = GetParent(curNode2);
XmlNode nextNode = null;
while ( parent1 != null && parent2 != null ) {
if ( parent1 == parent2 ) {
while (curNode1 != null ) {
nextNode = curNode1.NextSibling;
if ( nextNode == curNode2 )
return XmlNodeOrder.Before;
curNode1 = nextNode;
}
return XmlNodeOrder.After;
}
curNode1 = parent1;
curNode2 = parent2;
parent1 = curNode1.ParentNode;
parent2 = curNode2.ParentNode;
}
//logically, we shouldn't reach here
Debug.Assert( false );
return XmlNodeOrder.Unknown;
}
internal bool IsSamePosition( XPathNodePointer pointer ) {
//Debug.WriteLineIf( XmlTrace.traceXPathNodePointerFunctions.Enabled, "XPathNodePointer:IsSamePosition(pointer)");
RealFoliate();
pointer.RealFoliate();
AssertValid();
pointer.AssertValid();
if (_column == null && pointer._column == null)
return ( pointer._node == this._node && pointer._parentOfNS == this._parentOfNS );
return ( pointer._doc == this._doc
&& pointer._node == this._node
&& pointer._column == this._column
&& pointer._fOnValue == this._fOnValue
&& pointer._parentOfNS == this._parentOfNS );
}
internal bool IsSamePosition(XPathNodePointer pointer)
{
this.RealFoliate();
pointer.RealFoliate();
if ((this._column == null) && (pointer._column == null))
{
return ((pointer._node == this._node) && (pointer._parentOfNS == this._parentOfNS));
}
return ((((pointer._doc == this._doc) && (pointer._node == this._node)) && ((pointer._column == this._column) && (pointer._fOnValue == this._fOnValue))) && (pointer._parentOfNS == this._parentOfNS));
}
internal bool IsSamePosition(XPathNodePointer pointer)
{
RealFoliate();
pointer.RealFoliate();
AssertValid();
pointer.AssertValid();
if (_column == null && pointer._column == null)
return (pointer._node == _node && pointer._parentOfNS == _parentOfNS);
return (pointer._doc == _doc
&& pointer._node == _node
&& pointer._column == _column
&& pointer._fOnValue == _fOnValue
&& pointer._parentOfNS == _parentOfNS);
}
internal XmlNodeOrder ComparePosition(XPathNodePointer other)
{
this.RealFoliate();
other.RealFoliate();
if (this.IsSamePosition(other))
{
return XmlNodeOrder.Same;
}
XmlNode node = null;
XmlNode node2 = null;
if ((this.NodeType == XPathNodeType.Namespace) && (other.NodeType == XPathNodeType.Namespace))
{
if (this._parentOfNS == other._parentOfNS)
{
return this.CompareNamespacePosition(other);
}
node = this._parentOfNS;
node2 = other._parentOfNS;
}
else if (this.NodeType == XPathNodeType.Namespace)
{
if (this._parentOfNS == other._node)
{
if (other._column == null)
{
return XmlNodeOrder.After;
}
return XmlNodeOrder.Before;
}
node = this._parentOfNS;
node2 = other._node;
}
else if (other.NodeType == XPathNodeType.Namespace)
{
if (this._node == other._parentOfNS)
{
if (this._column == null)
{
return XmlNodeOrder.Before;
}
return XmlNodeOrder.After;
}
node = this._node;
node2 = other._parentOfNS;
}
else
{
if (this._node == other._node)
{
if (this._column == other._column)
{
if (this._fOnValue)
{
return XmlNodeOrder.After;
}
return XmlNodeOrder.Before;
}
if (this._column == null)
{
return XmlNodeOrder.Before;
}
if ((other._column != null) && (this._column.Ordinal < other._column.Ordinal))
{
return XmlNodeOrder.Before;
}
return XmlNodeOrder.After;
}
node = this._node;
node2 = other._node;
}
if ((node != null) && (node2 != null))
{
int depth = -1;
int num = -1;
XmlNode root = GetRoot(node, ref depth);
XmlNode node6 = GetRoot(node2, ref num);
if (root != node6)
{
return XmlNodeOrder.Unknown;
}
if (depth > num)
{
while ((node != null) && (depth > num))
{
node = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute) node).OwnerElement : node.ParentNode;
depth--;
}
if (node == node2)
{
return XmlNodeOrder.After;
}
}
else if (num > depth)
{
while ((node2 != null) && (num > depth))
{
node2 = (node2.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute) node2).OwnerElement : node2.ParentNode;
num--;
}
if (node == node2)
{
return XmlNodeOrder.Before;
}
}
XmlNode parent = this.GetParent(node);
XmlNode parentNode = this.GetParent(node2);
XmlNode nextSibling = null;
while ((parent != null) && (parentNode != null))
{
if (parent == parentNode)
{
while (node != null)
{
nextSibling = node.NextSibling;
if (nextSibling == node2)
{
return XmlNodeOrder.Before;
}
node = nextSibling;
}
return XmlNodeOrder.After;
}
node = parent;
node2 = parentNode;
parent = node.ParentNode;
parentNode = node2.ParentNode;
}
}
return XmlNodeOrder.Unknown;
}
