internal XmlDiffNode LoadNode(XmlNode node, ref int childPosition) { switch (node.NodeType) { case XmlNodeType.Element: XmlDiffElement elem = new XmlDiffElement(++childPosition, node.LocalName, node.Prefix, node.NamespaceURI); LoadChildNodes(elem, node); elem.ComputeHashValue(_xmlHash); return(elem); case XmlNodeType.Attribute: Debug.Assert(false, "Attributes cannot be loaded by this method."); return(null); case XmlNodeType.Text: string textValue = (_XmlDiff.IgnoreWhitespace) ? XmlDiff.NormalizeText(node.Value) : node.Value; XmlDiffCharData text = new XmlDiffCharData(++childPosition, textValue, XmlDiffNodeType.Text); text.ComputeHashValue(_xmlHash); return(text); case XmlNodeType.CDATA: XmlDiffCharData cdata = new XmlDiffCharData(++childPosition, node.Value, XmlDiffNodeType.CDATA); cdata.ComputeHashValue(_xmlHash); return(cdata); case XmlNodeType.EntityReference: XmlDiffER er = new XmlDiffER(++childPosition, node.Name); er.ComputeHashValue(_xmlHash); return(er); case XmlNodeType.Comment: ++childPosition; if (_XmlDiff.IgnoreComments) { return(null); } XmlDiffCharData comment = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.Comment); comment.ComputeHashValue(_xmlHash); return(comment); case XmlNodeType.ProcessingInstruction: ++childPosition; if (_XmlDiff.IgnorePI) { return(null); } XmlDiffPI pi = new XmlDiffPI(childPosition, node.Name, node.Value); pi.ComputeHashValue(_xmlHash); return(pi); case XmlNodeType.SignificantWhitespace: ++childPosition; if (_XmlDiff.IgnoreWhitespace) { return(null); } XmlDiffCharData ws = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.SignificantWhitespace); ws.ComputeHashValue(_xmlHash); return(ws); case XmlNodeType.XmlDeclaration: ++childPosition; if (_XmlDiff.IgnoreXmlDecl) { return(null); } XmlDiffXmlDeclaration xmlDecl = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(node.Value)); xmlDecl.ComputeHashValue(_xmlHash); return(xmlDecl); case XmlNodeType.EndElement: return(null); case XmlNodeType.DocumentType: childPosition++; if (_XmlDiff.IgnoreDtd) { return(null); } XmlDocumentType docType = (XmlDocumentType)node; XmlDiffDocumentType diffDocType = new XmlDiffDocumentType(childPosition, docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset); diffDocType.ComputeHashValue(_xmlHash); return(diffDocType); default: Debug.Assert(false); return(null); } }
// Loads child nodes of the 'parent' node internal void LoadChildNodes(XmlDiffParentNode parent, XmlReader reader, bool bEmptyElement) { XmlDiffNode savedLastChild = _curLastChild; _curLastChild = null; // load attributes & namespace nodes while (reader.MoveToNextAttribute()) { if (reader.Prefix == "xmlns") { if (!_XmlDiff.IgnoreNamespaces) { XmlDiffNamespace nsNode = new XmlDiffNamespace(reader.LocalName, reader.Value); nsNode.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode); } } else if (reader.Prefix == string.Empty && reader.LocalName == "xmlns") { if (!_XmlDiff.IgnoreNamespaces) { XmlDiffNamespace nsNode = new XmlDiffNamespace(string.Empty, reader.Value); nsNode.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode); } } else { string attrValue = _XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(reader.Value) : reader.Value; XmlDiffAttribute attr = new XmlDiffAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, attrValue); attr.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, attr); } } // empty element -> return, do not load chilren if (bEmptyElement) { goto End; } int childPosition = 0; // load children if (!reader.Read()) { goto End; } do { // ignore whitespaces between nodes if (reader.NodeType == XmlNodeType.Whitespace) { continue; } switch (reader.NodeType) { case XmlNodeType.Element: { bool bEmptyEl = reader.IsEmptyElement; XmlDiffElement elem = new XmlDiffElement(++childPosition, reader.LocalName, reader.Prefix, reader.NamespaceURI); LoadChildNodes(elem, reader, bEmptyEl); elem.ComputeHashValue(_xmlHash); InsertChild(parent, elem); break; } case XmlNodeType.Attribute: { Debug.Assert(false, "We should never get to this point, attributes should be read at the beginning of thid method."); break; } case XmlNodeType.Text: { string textValue = (_XmlDiff.IgnoreWhitespace) ? XmlDiff.NormalizeText(reader.Value) : reader.Value; XmlDiffCharData charDataNode = new XmlDiffCharData(++childPosition, textValue, XmlDiffNodeType.Text); charDataNode.ComputeHashValue(_xmlHash); InsertChild(parent, charDataNode); break; } case XmlNodeType.CDATA: { XmlDiffCharData charDataNode = new XmlDiffCharData(++childPosition, reader.Value, XmlDiffNodeType.CDATA); charDataNode.ComputeHashValue(_xmlHash); InsertChild(parent, charDataNode); break; } case XmlNodeType.EntityReference: { XmlDiffER er = new XmlDiffER(++childPosition, reader.Name); er.ComputeHashValue(_xmlHash); InsertChild(parent, er); break; } case XmlNodeType.Comment: { ++childPosition; if (!_XmlDiff.IgnoreComments) { XmlDiffCharData charDataNode = new XmlDiffCharData(childPosition, reader.Value, XmlDiffNodeType.Comment); charDataNode.ComputeHashValue(_xmlHash); InsertChild(parent, charDataNode); } break; } case XmlNodeType.ProcessingInstruction: { ++childPosition; if (!_XmlDiff.IgnorePI) { XmlDiffPI pi = new XmlDiffPI(childPosition, reader.Name, reader.Value); pi.ComputeHashValue(_xmlHash); InsertChild(parent, pi); } break; } case XmlNodeType.SignificantWhitespace: { if (reader.XmlSpace == XmlSpace.Preserve) { ++childPosition; if (!_XmlDiff.IgnoreWhitespace) { XmlDiffCharData charDataNode = new XmlDiffCharData(childPosition, reader.Value, XmlDiffNodeType.SignificantWhitespace); charDataNode.ComputeHashValue(_xmlHash); InsertChild(parent, charDataNode); } } break; } case XmlNodeType.XmlDeclaration: { ++childPosition; if (!_XmlDiff.IgnoreXmlDecl) { XmlDiffXmlDeclaration xmlDecl = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(reader.Value)); xmlDecl.ComputeHashValue(_xmlHash); InsertChild(parent, xmlDecl); } break; } case XmlNodeType.EndElement: goto End; case XmlNodeType.DocumentType: childPosition++; if (!_XmlDiff.IgnoreDtd) { XmlDiffDocumentType docType = new XmlDiffDocumentType(childPosition, reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); docType.ComputeHashValue(_xmlHash); InsertChild(parent, docType); } break; default: Debug.Assert(false); break; } } while (reader.Read()); End: _curLastChild = savedLastChild; }
private ulong ComputeHashXmlNode(XmlNode node) { switch (node.NodeType) { case XmlNodeType.Element: { XmlElement el = (XmlElement)node; HashAlgorithm ha = new HashAlgorithm(); HashElement(ha, el.LocalName, el.Prefix, el.NamespaceURI); ComputeHashXmlChildren(ha, el); return(ha.Hash); } case XmlNodeType.Attribute: // attributes are hashed in ComputeHashXmlChildren; Debug.Assert(false); return(0); case XmlNodeType.Whitespace: return(0); case XmlNodeType.SignificantWhitespace: if (!_bIgnoreWhitespace) { goto case XmlNodeType.Text; } return(0); case XmlNodeType.Comment: if (!_bIgnoreComments) { return(HashCharacterNode(XmlNodeType.Comment, ((XmlCharacterData)node).Value)); } return(0); case XmlNodeType.Text: { XmlCharacterData cd = (XmlCharacterData)node; if (_bIgnoreWhitespace) { return(HashCharacterNode(cd.NodeType, XmlDiff.NormalizeText(cd.Value))); } else { return(HashCharacterNode(cd.NodeType, cd.Value)); } } case XmlNodeType.CDATA: { XmlCharacterData cd = (XmlCharacterData)node; return(HashCharacterNode(cd.NodeType, cd.Value)); } case XmlNodeType.ProcessingInstruction: { if (_bIgnorePI) { return(0); } XmlProcessingInstruction pi = (XmlProcessingInstruction)node; return(HashPI(pi.Target, pi.Value)); } case XmlNodeType.EntityReference: { XmlEntityReference er = (XmlEntityReference)node; return(HashER(er.Name)); } case XmlNodeType.XmlDeclaration: { if (_bIgnoreXmlDecl) { return(0); } XmlDeclaration decl = (XmlDeclaration)node; return(HashXmlDeclaration(XmlDiff.NormalizeXmlDeclaration(decl.Value))); } case XmlNodeType.DocumentType: { if (_bIgnoreDtd) { return(0); } XmlDocumentType docType = (XmlDocumentType)node; return(HashDocumentType(docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset)); } case XmlNodeType.DocumentFragment: return(0); default: Debug.Assert(false); return(0); } }
private ulong ComputeHashXmlNode(XmlNode node) { switch (node.NodeType) { case XmlNodeType.Element: var xmlElement = (XmlElement)node; var ha = new HashAlgorithm(); this.HashElement(ha, xmlElement.LocalName, xmlElement.Prefix, xmlElement.NamespaceURI); this.ComputeHashXmlChildren(ha, (XmlNode)xmlElement); return(ha.Hash); case XmlNodeType.Attribute: return(0); case XmlNodeType.Text: var xmlCharacterData1 = (XmlCharacterData)node; return(this._bIgnoreWhitespace ? this.HashCharacterNode(xmlCharacterData1.NodeType, XmlDiff.NormalizeText(xmlCharacterData1.Value)) : this.HashCharacterNode(xmlCharacterData1.NodeType, xmlCharacterData1.Value)); case XmlNodeType.CDATA: var xmlCharacterData2 = (XmlCharacterData)node; return(this.HashCharacterNode(xmlCharacterData2.NodeType, xmlCharacterData2.Value)); case XmlNodeType.EntityReference: return(this.HashER(node.Name)); case XmlNodeType.ProcessingInstruction: if (this._bIgnorePI) { return(0); } var processingInstruction = (XmlProcessingInstruction)node; return(this.HashPI(processingInstruction.Target, processingInstruction.Value)); case XmlNodeType.Comment: return(!this._bIgnoreComments ? this.HashCharacterNode(XmlNodeType.Comment, node.Value) : 0UL); case XmlNodeType.DocumentType: if (this._bIgnoreDtd) { return(0); } var xmlDocumentType = (XmlDocumentType)node; return(this.HashDocumentType(xmlDocumentType.Name, xmlDocumentType.PublicId, xmlDocumentType.SystemId, xmlDocumentType.InternalSubset)); case XmlNodeType.DocumentFragment: return(0); case XmlNodeType.Whitespace: return(0); case XmlNodeType.SignificantWhitespace: if (this._bIgnoreWhitespace) { return(0); } goto case XmlNodeType.Text; case XmlNodeType.XmlDeclaration: return(this._bIgnoreXmlDecl ? 0UL : this.HashXmlDeclaration(XmlDiff.NormalizeXmlDeclaration(node.Value))); default: return(0); } }
internal void LoadChildNodes(XmlDiffParentNode parent, XmlReader reader, bool bEmptyElement) { var curLastChild = this._curLastChild; this._curLastChild = (XmlDiffNode) null; while (reader.MoveToNextAttribute()) { if (reader.Prefix == "xmlns") { if (!this._XmlDiff.IgnoreNamespaces) { var xmlDiffNamespace = new XmlDiffNamespace(reader.LocalName, reader.Value); xmlDiffNamespace.ComputeHashValue(this._xmlHash); this.InsertAttributeOrNamespace((XmlDiffElement) parent, (XmlDiffAttributeOrNamespace) xmlDiffNamespace); } } else if (reader.Prefix == string.Empty && reader.LocalName == "xmlns") { if (!this._XmlDiff.IgnoreNamespaces) { var xmlDiffNamespace = new XmlDiffNamespace(string.Empty, reader.Value); xmlDiffNamespace.ComputeHashValue(this._xmlHash); this.InsertAttributeOrNamespace((XmlDiffElement) parent, (XmlDiffAttributeOrNamespace) xmlDiffNamespace); } } else { var str = this._XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(reader.Value) : reader.Value; var xmlDiffAttribute = new XmlDiffAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, str); xmlDiffAttribute.ComputeHashValue(this._xmlHash); this.InsertAttributeOrNamespace((XmlDiffElement) parent, (XmlDiffAttributeOrNamespace) xmlDiffAttribute); } } if (!bEmptyElement) { var position = 0; if (reader.Read()) { do { if (reader.NodeType != XmlNodeType.Whitespace) { switch (reader.NodeType) { case XmlNodeType.Element: var isEmptyElement = reader.IsEmptyElement; var xmlDiffElement = new XmlDiffElement(++position, reader.LocalName, reader.Prefix, reader.NamespaceURI); this.LoadChildNodes((XmlDiffParentNode) xmlDiffElement, reader, isEmptyElement); xmlDiffElement.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffElement); break; case XmlNodeType.Text: var str = this._XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(reader.Value) : reader.Value; var xmlDiffCharData1 = new XmlDiffCharData(++position, str, XmlDiffNodeType.Text); xmlDiffCharData1.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffCharData1); break; case XmlNodeType.CDATA: var xmlDiffCharData2 = new XmlDiffCharData(++position, reader.Value, XmlDiffNodeType.CDATA); xmlDiffCharData2.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffCharData2); break; case XmlNodeType.EntityReference: var xmlDiffEr = new XmlDiffER(++position, reader.Name); xmlDiffEr.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffEr); break; case XmlNodeType.ProcessingInstruction: ++position; if (!this._XmlDiff.IgnorePI) { var xmlDiffPi = new XmlDiffPI(position, reader.Name, reader.Value); xmlDiffPi.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffPi); break; } break; case XmlNodeType.Comment: ++position; if (!this._XmlDiff.IgnoreComments) { var xmlDiffCharData3 = new XmlDiffCharData(position, reader.Value, XmlDiffNodeType.Comment); xmlDiffCharData3.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffCharData3); break; } break; case XmlNodeType.DocumentType: ++position; if (!this._XmlDiff.IgnoreDtd) { var diffDocumentType = new XmlDiffDocumentType(position, reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); diffDocumentType.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) diffDocumentType); break; } break; case XmlNodeType.SignificantWhitespace: if (reader.XmlSpace == XmlSpace.Preserve) { ++position; if (!this._XmlDiff.IgnoreWhitespace) { var xmlDiffCharData3 = new XmlDiffCharData(position, reader.Value, XmlDiffNodeType.SignificantWhitespace); xmlDiffCharData3.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) xmlDiffCharData3); break; } break; } break; case XmlNodeType.EndElement: goto label_29; case XmlNodeType.XmlDeclaration: ++position; if (!this._XmlDiff.IgnoreXmlDecl) { var diffXmlDeclaration = new XmlDiffXmlDeclaration(position, XmlDiff.NormalizeXmlDeclaration(reader.Value)); diffXmlDeclaration.ComputeHashValue(this._xmlHash); this.InsertChild(parent, (XmlDiffNode) diffXmlDeclaration); break; } break; } } } while (reader.Read()); } } label_29: this._curLastChild = curLastChild; }
internal XmlDiffNode LoadNode(XmlNode node, ref int childPosition) { switch (node.NodeType) { case XmlNodeType.Element: var xmlDiffElement = new XmlDiffElement(++childPosition, node.LocalName, node.Prefix, node.NamespaceURI); this.LoadChildNodes((XmlDiffParentNode) xmlDiffElement, node); xmlDiffElement.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffElement; case XmlNodeType.Attribute: return (XmlDiffNode) null; case XmlNodeType.Text: var str = this._XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(node.Value) : node.Value; var xmlDiffCharData1 = new XmlDiffCharData(++childPosition, str, XmlDiffNodeType.Text); xmlDiffCharData1.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffCharData1; case XmlNodeType.CDATA: var xmlDiffCharData2 = new XmlDiffCharData(++childPosition, node.Value, XmlDiffNodeType.CDATA); xmlDiffCharData2.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffCharData2; case XmlNodeType.EntityReference: var xmlDiffEr = new XmlDiffER(++childPosition, node.Name); xmlDiffEr.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffEr; case XmlNodeType.ProcessingInstruction: ++childPosition; if (this._XmlDiff.IgnorePI) return (XmlDiffNode) null; var xmlDiffPi = new XmlDiffPI(childPosition, node.Name, node.Value); xmlDiffPi.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffPi; case XmlNodeType.Comment: ++childPosition; if (this._XmlDiff.IgnoreComments) return (XmlDiffNode) null; var xmlDiffCharData3 = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.Comment); xmlDiffCharData3.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffCharData3; case XmlNodeType.DocumentType: ++childPosition; if (this._XmlDiff.IgnoreDtd) return (XmlDiffNode) null; var xmlDocumentType = (XmlDocumentType) node; var diffDocumentType = new XmlDiffDocumentType(childPosition, xmlDocumentType.Name, xmlDocumentType.PublicId, xmlDocumentType.SystemId, xmlDocumentType.InternalSubset); diffDocumentType.ComputeHashValue(this._xmlHash); return (XmlDiffNode) diffDocumentType; case XmlNodeType.SignificantWhitespace: ++childPosition; if (this._XmlDiff.IgnoreWhitespace) return (XmlDiffNode) null; var xmlDiffCharData4 = new XmlDiffCharData(childPosition, node.Value, XmlDiffNodeType.SignificantWhitespace); xmlDiffCharData4.ComputeHashValue(this._xmlHash); return (XmlDiffNode) xmlDiffCharData4; case XmlNodeType.EndElement: return (XmlDiffNode) null; case XmlNodeType.XmlDeclaration: ++childPosition; if (this._XmlDiff.IgnoreXmlDecl) return (XmlDiffNode) null; var diffXmlDeclaration = new XmlDiffXmlDeclaration(childPosition, XmlDiff.NormalizeXmlDeclaration(node.Value)); diffXmlDeclaration.ComputeHashValue(this._xmlHash); return (XmlDiffNode) diffXmlDeclaration; default: return (XmlDiffNode) null; } }