internal bool AddAttribute(XmlDiffAttribute srcAttr) { if (_operationID != 0 || srcAttr._parent != _attributes._firstAttr._parent) { return(false); } if (srcAttr._nextSibling == _attributes._firstAttr) { _attributes._firstAttr = srcAttr; } else { _attributes = new AttributeInterval(srcAttr, _attributes); } return(true); }
// Methods internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff) { xmlWriter.WriteStartElement(XmlDiff.Prefix, "change", XmlDiff.NamespaceUri); xmlWriter.WriteAttributeString("match", _sourceNode.GetRelativeAddress()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } switch (_op) { case XmlDiffOperation.ChangeAttr: { XmlDiffAttribute sourceAttr = (XmlDiffAttribute)_sourceNode; XmlDiffAttribute targetAttr = (XmlDiffAttribute)_targetNode; if (sourceAttr.Prefix != targetAttr.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces) { xmlWriter.WriteAttributeString("prefix", targetAttr.Prefix); } if (sourceAttr.NamespaceURI != targetAttr.NamespaceURI && !xmlDiff.IgnoreNamespaces) { xmlWriter.WriteAttributeString("ns", targetAttr.NamespaceURI); } xmlWriter.WriteString(targetAttr.Value); break; } case XmlDiffOperation.ChangeElementName: { XmlDiffElement sourceEl = (XmlDiffElement)_sourceNode; XmlDiffElement targetEl = (XmlDiffElement)_targetNode; if (sourceEl.LocalName != targetEl.LocalName) { xmlWriter.WriteAttributeString("name", targetEl.LocalName); } if (sourceEl.Prefix != targetEl.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces) { xmlWriter.WriteAttributeString("prefix", targetEl.Prefix); } if (sourceEl.NamespaceURI != targetEl.NamespaceURI && !xmlDiff.IgnoreNamespaces) { xmlWriter.WriteAttributeString("ns", targetEl.NamespaceURI); } WriteChildrenTo(xmlWriter, xmlDiff); break; } case XmlDiffOperation.ChangePI: { XmlDiffPI sourcePi = (XmlDiffPI)_sourceNode; XmlDiffPI targetPi = (XmlDiffPI)_targetNode; if (sourcePi.Value == targetPi.Value) { Debug.Assert(sourcePi.Name != targetPi.Name); xmlWriter.WriteAttributeString("name", targetPi.Name); } else { xmlWriter.WriteProcessingInstruction(targetPi.Name, targetPi.Value); } break; } case XmlDiffOperation.ChangeCharacterData: { XmlDiffCharData chd = (XmlDiffCharData)_targetNode; switch (_targetNode.NodeType) { case XmlDiffNodeType.Text: case XmlDiffNodeType.SignificantWhitespace: xmlWriter.WriteString(chd.Value); break; case XmlDiffNodeType.Comment: xmlWriter.WriteComment(chd.Value); break; case XmlDiffNodeType.CDATA: xmlWriter.WriteCData(chd.Value); break; default: Debug.Assert(false); break; } break; } case XmlDiffOperation.ChangeER: { xmlWriter.WriteAttributeString("name", ((XmlDiffER)_targetNode).Name); break; } case XmlDiffOperation.ChangeXmlDeclaration: { xmlWriter.WriteString(((XmlDiffXmlDeclaration)_targetNode).Value); break; } case XmlDiffOperation.ChangeDTD: { XmlDiffDocumentType sourceDtd = (XmlDiffDocumentType)_sourceNode; XmlDiffDocumentType targetDtd = (XmlDiffDocumentType)_targetNode; if (sourceDtd.Name != targetDtd.Name) { xmlWriter.WriteAttributeString("name", targetDtd.Name); } if (sourceDtd.SystemId != targetDtd.SystemId) { xmlWriter.WriteAttributeString("systemId", targetDtd.SystemId); } if (sourceDtd.PublicId != targetDtd.PublicId) { xmlWriter.WriteAttributeString("publicId", targetDtd.PublicId); } if (sourceDtd.Subset != targetDtd.Subset) { xmlWriter.WriteCData(targetDtd.Subset); } break; } default: Debug.Assert(false); break; } xmlWriter.WriteEndElement(); }
// Methods internal override void WriteTo(XmlWriter xmlWriter, XmlDiff xmlDiff) { xmlWriter.WriteStartElement(XmlDiff.Prefix, "add", XmlDiff.NamespaceUri); switch (_targetNode.NodeType) { case XmlDiffNodeType.Element: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.Element).ToString()); XmlDiffElement el = _targetNode as XmlDiffElement; xmlWriter.WriteAttributeString("name", el.LocalName); if (el.NamespaceURI != string.Empty) { xmlWriter.WriteAttributeString("ns", el.NamespaceURI); } if (el.Prefix != string.Empty) { xmlWriter.WriteAttributeString("prefix", el.Prefix); } if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } WriteChildrenTo(xmlWriter, xmlDiff); break; } case XmlDiffNodeType.Attribute: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.Attribute).ToString()); XmlDiffAttribute at = _targetNode as XmlDiffAttribute; xmlWriter.WriteAttributeString("name", at.LocalName); if (at.NamespaceURI != string.Empty) { xmlWriter.WriteAttributeString("ns", at.NamespaceURI); } if (at.Prefix != string.Empty) { xmlWriter.WriteAttributeString("prefix", at.Prefix); } if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteString(at.Value); break; } case XmlDiffNodeType.Namespace: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.Attribute).ToString()); XmlDiffNamespace ns = _targetNode as XmlDiffNamespace; if (ns.Prefix != string.Empty) { xmlWriter.WriteAttributeString("prefix", "xmlns"); xmlWriter.WriteAttributeString("name", ns.Prefix); } else { xmlWriter.WriteAttributeString("name", "xmlns"); } if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteString(ns.NamespaceURI); break; } case XmlDiffNodeType.CDATA: { Debug.Assert(false, "CDATA nodes should be added with DiffgramAddSubtrees class."); xmlWriter.WriteAttributeString("type", ((int)_targetNode.NodeType).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteCData((_targetNode as XmlDiffCharData).Value); break; } case XmlDiffNodeType.Comment: { Debug.Assert(false, "Comment nodes should be added with DiffgramAddSubtrees class."); xmlWriter.WriteAttributeString("type", ((int)_targetNode.NodeType).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteComment((_targetNode as XmlDiffCharData).Value); break; } case XmlDiffNodeType.Text: { Debug.Assert(false, "Text nodes should be added with DiffgramAddSubtrees class."); xmlWriter.WriteAttributeString("type", ((int)_targetNode.NodeType).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteString((_targetNode as XmlDiffCharData).Value); break; } case XmlDiffNodeType.ProcessingInstruction: { Debug.Assert(false, "Processing instruction nodes should be added with DiffgramAddSubtrees class."); xmlWriter.WriteAttributeString("type", ((int)_targetNode.NodeType).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } XmlDiffPI pi = _targetNode as XmlDiffPI; xmlWriter.WriteProcessingInstruction(pi.Name, pi.Value); break; } case XmlDiffNodeType.EntityReference: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.EntityReference).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteAttributeString("name", ((XmlDiffER)_targetNode).Name); break; } case XmlDiffNodeType.SignificantWhitespace: { Debug.Assert(false, "Significant whitespace nodes should be added with DiffgramAddSubtrees class."); xmlWriter.WriteAttributeString("type", ((int)_targetNode.NodeType).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteString(((XmlDiffCharData)_targetNode).Value); break; } case XmlDiffNodeType.XmlDeclaration: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.XmlDeclaration).ToString()); if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteString(((XmlDiffXmlDeclaration)_targetNode).Value); break; } case XmlDiffNodeType.DocumentType: { xmlWriter.WriteAttributeString("type", ((int)XmlNodeType.DocumentType).ToString()); XmlDiffDocumentType docType = (XmlDiffDocumentType)_targetNode; if (_operationID != 0) { xmlWriter.WriteAttributeString("opid", _operationID.ToString()); } xmlWriter.WriteAttributeString("name", docType.Name); if (docType.PublicId != string.Empty) { xmlWriter.WriteAttributeString("publicId", docType.PublicId); } if (docType.SystemId != string.Empty) { xmlWriter.WriteAttributeString("systemId", docType.SystemId); } if (docType.Subset != string.Empty) { xmlWriter.WriteCData(docType.Subset); } break; } default: Debug.Assert(false); break; } xmlWriter.WriteEndElement(); }
// Constructor internal DiffgramRemoveAttributes(XmlDiffAttribute sourceAttr) : base(0) { Debug.Assert(sourceAttr != null); _attributes = new AttributeInterval(sourceAttr, null); }
// Loads child nodes of the 'parent' node internal void LoadChildNodes(XmlDiffParentNode parent, XmlNode parentDomNode) { XmlDiffNode savedLastChild = _curLastChild; _curLastChild = null; // load attributes & namespace nodes XmlNamedNodeMap attribs = parentDomNode.Attributes; if (attribs != null && attribs.Count > 0) { IEnumerator attrEnum = attribs.GetEnumerator(); while (attrEnum.MoveNext()) { XmlAttribute attr = (XmlAttribute)attrEnum.Current; if (attr.Prefix == "xmlns") { if (!_XmlDiff.IgnoreNamespaces) { XmlDiffNamespace nsNode = new XmlDiffNamespace(attr.LocalName, attr.Value); nsNode.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode); } } else if (attr.Prefix == string.Empty && attr.LocalName == "xmlns") { if (!_XmlDiff.IgnoreNamespaces) { XmlDiffNamespace nsNode = new XmlDiffNamespace(string.Empty, attr.Value); nsNode.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, nsNode); } } else { string attrValue = _XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText(attr.Value) : attr.Value; XmlDiffAttribute newAttr = new XmlDiffAttribute(attr.LocalName, attr.Prefix, attr.NamespaceURI, attrValue); newAttr.ComputeHashValue(_xmlHash); InsertAttributeOrNamespace((XmlDiffElement)parent, newAttr); } } } // load children XmlNodeList children = parentDomNode.ChildNodes; if (children.Count == 0) { goto End; } int childPosition = 0; IEnumerator childEnum = children.GetEnumerator(); while (childEnum.MoveNext()) { XmlNode node = (XmlNode)childEnum.Current; // ignore whitespaces between nodes if (node.NodeType == XmlNodeType.Whitespace) { continue; } XmlDiffNode newDiffNode = LoadNode((XmlNode)childEnum.Current, ref childPosition); if (newDiffNode != null) { InsertChild(parent, newDiffNode); } } End: _curLastChild = savedLastChild; }
internal AttributeInterval(XmlDiffAttribute attr, AttributeInterval next) { _firstAttr = attr; _lastAttr = attr; _next = next; }
internal DiffgramRemoveAttributes(XmlDiffAttribute sourceAttr) : base(0UL) { this._attributes = new AttributeInterval(sourceAttr, (AttributeInterval)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; }
// Constructor internal DiffgramRemoveAttributes( XmlDiffAttribute sourceAttr ) : base(0) { Debug.Assert( sourceAttr != null ); _attributes = new AttributeInterval( sourceAttr, null ); }
internal bool AddAttribute( XmlDiffAttribute srcAttr ) { if ( _operationID != 0 || srcAttr._parent != _attributes._firstAttr._parent ) return false; if ( srcAttr._nextSibling == _attributes._firstAttr ) _attributes._firstAttr = srcAttr; else _attributes = new AttributeInterval( srcAttr, _attributes ); return true; }
private static void WriteNamespaceDefinition( XmlDiffAttribute attr, XmlWriter xmlWriter ) { Debug.Assert( attr.NamespaceURI != string.Empty ); if ( attr.Prefix != string.Empty ) xmlWriter.WriteAttributeString( "xmlns", attr.Prefix, XmlDiff.XmlnsNamespaceUri, attr.NamespaceURI ); else xmlWriter.WriteAttributeString( string.Empty, "xmlns", XmlDiff.XmlnsNamespaceUri, attr.NamespaceURI ); }
internal AttributeInterval( XmlDiffAttribute attr, AttributeInterval next ) { _firstAttr = attr; _lastAttr = attr; _next = next; }
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; }
// Loads child nodes of the 'parent' node internal void LoadChildNodes( XmlDiffParentNode parent, XmlNode parentDomNode ) { XmlDiffNode savedLastChild = _curLastChild; _curLastChild = null; // load attributes & namespace nodes XmlNamedNodeMap attribs = parentDomNode.Attributes; if ( attribs != null && attribs.Count > 0 ) { IEnumerator attrEnum = attribs.GetEnumerator(); while ( attrEnum.MoveNext() ) { XmlAttribute attr = (XmlAttribute)attrEnum.Current; if ( attr.Prefix == "xmlns" ) { if ( !_XmlDiff.IgnoreNamespaces ) { XmlDiffNamespace nsNode = new XmlDiffNamespace( attr.LocalName, attr.Value ); nsNode.ComputeHashValue( _xmlHash ); InsertAttributeOrNamespace( (XmlDiffElement)parent, nsNode ); } } else if ( attr.Prefix == string.Empty && attr.LocalName == "xmlns" ) { if ( !_XmlDiff.IgnoreNamespaces ) { XmlDiffNamespace nsNode = new XmlDiffNamespace( string.Empty, attr.Value ); nsNode.ComputeHashValue( _xmlHash ); InsertAttributeOrNamespace( (XmlDiffElement)parent, nsNode ); } } else { string attrValue = _XmlDiff.IgnoreWhitespace ? XmlDiff.NormalizeText( attr.Value ) : attr.Value; XmlDiffAttribute newAttr = new XmlDiffAttribute( attr.LocalName, attr.Prefix, attr.NamespaceURI, attrValue ); newAttr.ComputeHashValue( _xmlHash ); InsertAttributeOrNamespace( (XmlDiffElement)parent, newAttr ); } } } // load children XmlNodeList children = parentDomNode.ChildNodes; if ( children.Count == 0 ) goto End; int childPosition = 0; IEnumerator childEnum = children.GetEnumerator(); while ( childEnum.MoveNext() ) { XmlNode node = (XmlNode)childEnum.Current; // ignore whitespaces between nodes if ( node.NodeType == XmlNodeType.Whitespace ) continue; XmlDiffNode newDiffNode = LoadNode( (XmlNode)childEnum.Current, ref childPosition ); if ( newDiffNode != null ) InsertChild( parent, newDiffNode ); } End: _curLastChild = savedLastChild; }
// 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; }