static internal int OrderAttributesOrNamespaces(XmlDiffAttributeOrNamespace node1,
XmlDiffAttributeOrNamespace node2)
{
Debug.Assert(node1 != null && node2 != null);
if (node1.NodeType != node2.NodeType)
{
if (node1.NodeType == XmlDiffNodeType.Namespace)
{
return(-1);
}
else
{
return(1);
}
}
int nCompare;
if ((nCompare = OrderStrings(node1.LocalName, node2.LocalName)) == 0 &&
(nCompare = OrderStrings(node1.Prefix, node2.Prefix)) == 0 &&
(nCompare = OrderStrings(node1.NamespaceURI, node2.NamespaceURI)) == 0 &&
(nCompare = OrderStrings(node1.Value, node2.Value)) == 0)
{
return(0);
}
return(nCompare);
}
internal static int OrderAttributesOrNamespaces(
XmlDiffAttributeOrNamespace node1,
XmlDiffAttributeOrNamespace node2)
{
int num;
return node1.NodeType != node2.NodeType ? (node1.NodeType == XmlDiffNodeType.Namespace ? -1 : 1) : ((num = XmlDiffDocument.OrderStrings(node1.LocalName, node2.LocalName)) == 0 && (num = XmlDiffDocument.OrderStrings(node1.Prefix, node2.Prefix)) == 0 && ((num = XmlDiffDocument.OrderStrings(node1.NamespaceURI, node2.NamespaceURI)) == 0 && (num = XmlDiffDocument.OrderStrings(node1.Value, node2.Value)) == 0) ? 0 : num);
}
// Methods
internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff)
{
if (!_bSorted)
{
Sort();
}
xmlWriter.WriteStartElement(XmlDiff.Prefix, "add", XmlDiff.NamespaceUri);
if (_operationID != 0)
{
xmlWriter.WriteAttributeString("opid", _operationID.ToString());
}
// namespaces
if (_bNeedNamespaces)
{
Hashtable definedPrefixes = new Hashtable();
XmlDiffParentNode parent = _firstTargetNode._parent;
while (parent != null)
{
if (parent._bDefinesNamespaces)
{
XmlDiffElement el = (XmlDiffElement)parent;
XmlDiffAttributeOrNamespace curNs = el._attributes;
while (curNs != null && curNs.NodeType == XmlDiffNodeType.Namespace)
{
if (definedPrefixes[curNs.Prefix] == null)
{
if (curNs.Prefix == string.Empty)
{
xmlWriter.WriteAttributeString("xmlns", XmlDiff.XmlnsNamespaceUri, curNs.NamespaceURI);
}
else
{
xmlWriter.WriteAttributeString("xmlns", curNs.Prefix, XmlDiff.XmlnsNamespaceUri, curNs.NamespaceURI);
}
definedPrefixes[curNs.Prefix] = curNs.Prefix;
}
curNs = (XmlDiffAttributeOrNamespace)curNs._nextSibling;
}
}
parent = parent._parent;
}
}
// output nodes
XmlDiffNode node = _firstTargetNode;
for (;;)
{
node.WriteTo(xmlWriter);
if (node == _lastTargetNode)
{
break;
}
node = node._nextSibling;
}
xmlWriter.WriteEndElement();
}
// compares the node to another one and returns true, if the nodes are identical;
// on elements this method ignores namespace declarations
internal override bool IsSameAs(XmlDiffNode node, XmlDiff xmlDiff)
{
// check node type
Debug.Assert(node != null);
if (node.NodeType != XmlDiffNodeType.Element)
{
return(false);
}
XmlDiffElement element = (XmlDiffElement)node;
// check element name
if (LocalName != element.LocalName)
{
return(false);
}
else if (!xmlDiff.IgnoreNamespaces)
{
if (NamespaceURI != element.NamespaceURI)
{
return(false);
}
else if (!xmlDiff.IgnorePrefixes)
{
if (Prefix != element.Prefix)
{
return(false);
}
}
}
// ignore namespace definitions - should be first in the list of attributes
XmlDiffAttributeOrNamespace attr1 = _attributes;
while (attr1 != null && attr1.NodeType == XmlDiffNodeType.Namespace)
{
attr1 = (XmlDiffAttributeOrNamespace)attr1._nextSibling;
}
XmlDiffAttributeOrNamespace attr2 = _attributes;
while (attr2 != null && attr2.NodeType == XmlDiffNodeType.Namespace)
{
attr2 = (XmlDiffAttributeOrNamespace)attr2._nextSibling;
}
// check attributes
while (attr1 != null && attr2 != null)
{
if (!attr1.IsSameAs(attr2, xmlDiff))
{
return(false);
}
attr1 = (XmlDiffAttributeOrNamespace)attr1._nextSibling;
attr2 = (XmlDiffAttributeOrNamespace)attr2._nextSibling;
}
return(attr1 == null && attr2 == null);
}
internal void InsertAttributeOrNamespace(XmlDiffAttributeOrNamespace newAttrOrNs)
{
newAttrOrNs._parent = (XmlDiffParentNode)this;
var node1 = this._attributes;
var attributeOrNamespace = (XmlDiffAttributeOrNamespace)null;
for (; node1 != null && XmlDiffDocument.OrderAttributesOrNamespaces(node1, newAttrOrNs) <= 0; node1 = (XmlDiffAttributeOrNamespace)node1._nextSibling)
{
attributeOrNamespace = node1;
}
if (attributeOrNamespace == null)
{
newAttrOrNs._nextSibling = (XmlDiffNode)this._attributes;
this._attributes = newAttrOrNs;
}
else
{
newAttrOrNs._nextSibling = attributeOrNamespace._nextSibling;
attributeOrNamespace._nextSibling = (XmlDiffNode)newAttrOrNs;
}
this._allAttributesHash += newAttrOrNs.HashValue;
char c;
if (newAttrOrNs.NodeType == XmlDiffNodeType.Attribute)
{
c = newAttrOrNs.LocalName[0];
}
else
{
var xmlDiffNamespace = (XmlDiffNamespace)newAttrOrNs;
c = xmlDiffNamespace.Prefix == string.Empty ? 'A' : xmlDiffNamespace.Prefix[0];
}
var upper = char.ToUpper(c);
if (upper >= 'R')
{
this._attributesHashRZ += newAttrOrNs.HashValue;
}
else if (upper >= 'I')
{
this._attributesHashIQ += newAttrOrNs.HashValue;
}
else
{
this._attributesHashAH += newAttrOrNs.HashValue;
}
if (newAttrOrNs.NodeType != XmlDiffNodeType.Namespace)
{
return;
}
this._bDefinesNamespaces = true;
}
internal override void Dump(string indent)
{
Trace.Write(indent + "(" + _index + ") <" + Name);
XmlDiffAttributeOrNamespace attr = _attributes;
while (attr != null)
{
attr.Dump(indent);
attr = (XmlDiffAttributeOrNamespace)attr._nextSibling;
}
Trace.WriteLine("> ");
DumpChildren(indent + " ");
}
// Overriden abstract methods for outputting
internal override void WriteTo(XmlWriter w)
{
w.WriteStartElement(Prefix, LocalName, NamespaceURI);
XmlDiffAttributeOrNamespace attr = _attributes;
while (attr != null)
{
attr.WriteTo(w);
attr = (XmlDiffAttributeOrNamespace)attr._nextSibling;
}
WriteContentTo(w);
w.WriteEndElement();
}
private void ComputeHashXmlDiffAttributes(HashAlgorithm ha, XmlDiffElement el)
{
int attrCount = 0;
ulong attrHashAll = 0;
XmlDiffAttributeOrNamespace curAttrOrNs = el._attributes;
while (curAttrOrNs != null)
{
attrHashAll += curAttrOrNs.HashValue;
attrCount++;
curAttrOrNs = (XmlDiffAttributeOrNamespace)curAttrOrNs._nextSibling;
}
if (attrCount > 0)
{
ha.AddULong(attrHashAll);
ha.AddInt(attrCount);
}
}
internal static int OrderAttributesOrNamespaces( XmlDiffAttributeOrNamespace node1,
XmlDiffAttributeOrNamespace node2 )
{
Debug.Assert( node1 != null && node2 != null );
if ( node1.NodeType != node2.NodeType )
{
if ( node1.NodeType == XmlDiffNodeType.Namespace )
return -1;
else
return 1;
}
int nCompare;
if ( ( nCompare = OrderStrings( node1.LocalName, node2.LocalName ) ) == 0 &&
( nCompare = OrderStrings( node1.Prefix, node2.Prefix ) ) == 0 &&
( nCompare = OrderStrings( node1.NamespaceURI, node2.NamespaceURI ) ) == 0 &&
( nCompare = OrderStrings( node1.Value, node2.Value ) ) == 0 )
{
return 0;
}
return nCompare;
}
internal void InsertAttributeOrNamespace(XmlDiffAttributeOrNamespace newAttrOrNs)
{
Debug.Assert(newAttrOrNs != null);
newAttrOrNs._parent = this;
XmlDiffAttributeOrNamespace curAttr = _attributes;
XmlDiffAttributeOrNamespace prevAttr = null;
while (curAttr != null &&
XmlDiffDocument.OrderAttributesOrNamespaces(curAttr, newAttrOrNs) <= 0)
{
prevAttr = curAttr;
curAttr = (XmlDiffAttributeOrNamespace)curAttr._nextSibling;
}
if (prevAttr == null)
{
newAttrOrNs._nextSibling = _attributes;
_attributes = newAttrOrNs;
}
else
{
newAttrOrNs._nextSibling = prevAttr._nextSibling;
prevAttr._nextSibling = newAttrOrNs;
}
// hash
Debug.Assert(newAttrOrNs.HashValue != 0);
_allAttributesHash += newAttrOrNs.HashValue;
char firstLetter;
if (newAttrOrNs.NodeType == XmlDiffNodeType.Attribute)
{
firstLetter = ((XmlDiffAttribute)newAttrOrNs).LocalName[0];
}
else
{
XmlDiffNamespace nsNode = (XmlDiffNamespace)newAttrOrNs;
firstLetter = (nsNode.Prefix == string.Empty) ? 'A' : nsNode.Prefix[0];
}
firstLetter = char.ToUpper(firstLetter);
if (firstLetter >= 'R')
{
_attributesHashRZ += newAttrOrNs.HashValue;
}
else if (firstLetter >= 'I')
{
_attributesHashIQ += newAttrOrNs.HashValue;
}
else
{
_attributesHashAH += newAttrOrNs.HashValue;
}
if (newAttrOrNs.NodeType == XmlDiffNodeType.Namespace)
{
_bDefinesNamespaces = true;
}
}
static internal int OrderSubTrees(XmlDiffElement elem1, XmlDiffElement elem2)
{
Debug.Assert(elem1 != null && elem2 != null);
int nCompare = 0;
// attributes - ignore namespace nodes
XmlDiffAttributeOrNamespace curAttr1 = elem1._attributes;
XmlDiffAttributeOrNamespace curAttr2 = elem2._attributes;
while (curAttr1 != null && curAttr1.NodeType == XmlDiffNodeType.Namespace)
{
curAttr1 = (XmlDiffAttributeOrNamespace)curAttr1._nextSibling;
}
while (curAttr2 != null && curAttr2.NodeType == XmlDiffNodeType.Namespace)
{
curAttr2 = (XmlDiffAttributeOrNamespace)curAttr2._nextSibling;
}
while (curAttr1 != null && curAttr2 != null)
{
if ((nCompare = OrderAttributesOrNamespaces(curAttr1, curAttr2)) != 0)
{
return(nCompare);
}
curAttr1 = (XmlDiffAttributeOrNamespace)curAttr1._nextSibling;
curAttr2 = (XmlDiffAttributeOrNamespace)curAttr2._nextSibling;
}
// children
if (curAttr1 == curAttr2)
{
XmlDiffNode curChild1 = elem1.FirstChildNode;
XmlDiffNode curChild2 = elem2.FirstChildNode;
while (curChild1 != null && curChild2 != null)
{
if ((nCompare = OrderChildren(curChild1, curChild2)) != 0)
{
return(nCompare);
}
curChild1 = curChild1._nextSibling;
curChild2 = curChild2._nextSibling;
}
if (curChild1 == curChild2)
{
return(0);
}
else if (curChild1 == null)
{
return(1); //elem2 > elem1;
}
else
{
return(-1); //elem1 > elem1;
}
}
else if (curAttr1 == null)
{
return(1); //elem2 > elem1;
}
else
{
return(-1); //elem1 > elem1;
}
}
// Inserts an attribute or namespace node. The new node is sorted into the other attributes/namespace nodes.
private void InsertAttributeOrNamespace(XmlDiffElement element, XmlDiffAttributeOrNamespace newAttrOrNs)
{
element.InsertAttributeOrNamespace(newAttrOrNs);
}
internal void InsertAttributeOrNamespace( XmlDiffAttributeOrNamespace newAttrOrNs )
{
Debug.Assert( newAttrOrNs != null );
newAttrOrNs._parent = this;
XmlDiffAttributeOrNamespace curAttr = _attributes;
XmlDiffAttributeOrNamespace prevAttr = null;
while ( curAttr != null &&
XmlDiffDocument.OrderAttributesOrNamespaces( curAttr, newAttrOrNs ) <= 0 )
{
prevAttr = curAttr;
curAttr = (XmlDiffAttributeOrNamespace)curAttr._nextSibling;
}
if ( prevAttr == null )
{
newAttrOrNs._nextSibling = _attributes;
_attributes = newAttrOrNs;
}
else
{
newAttrOrNs._nextSibling = prevAttr._nextSibling;
prevAttr._nextSibling = newAttrOrNs;
}
// hash
Debug.Assert( newAttrOrNs.HashValue != 0 );
_allAttributesHash += newAttrOrNs.HashValue;
char firstLetter;
if ( newAttrOrNs.NodeType == XmlDiffNodeType.Attribute )
firstLetter = ((XmlDiffAttribute)newAttrOrNs).LocalName[0];
else
{
XmlDiffNamespace nsNode = (XmlDiffNamespace)newAttrOrNs;
firstLetter = ( nsNode.Prefix == string.Empty ) ? 'A' : nsNode.Prefix[0];
}
firstLetter = char.ToUpper( firstLetter );
if ( firstLetter >= 'R' ) {
_attributesHashRZ += newAttrOrNs.HashValue;
}
else if ( firstLetter >= 'I' ) {
_attributesHashIQ += newAttrOrNs.HashValue;
}
else {
_attributesHashAH += newAttrOrNs.HashValue;
}
if ( newAttrOrNs.NodeType == XmlDiffNodeType.Namespace )
_bDefinesNamespaces = true;
}
// Inserts an attribute or namespace node. The new node is sorted into the other attributes/namespace nodes.
private void InsertAttributeOrNamespace( XmlDiffElement element, XmlDiffAttributeOrNamespace newAttrOrNs )
{
element.InsertAttributeOrNamespace( newAttrOrNs );
}
