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