// compares the node to another one and returns the xmldiff operation for changing this node to the other
internal override XmlDiffOperation GetDiffOperation(XmlDiffNode changedNode, XmlDiff xmlDiff)
{
Debug.Assert(changedNode != null);
if (NodeType != changedNode.NodeType)
{
return(XmlDiffOperation.Undefined);
}
XmlDiffCharData changedCD = changedNode as XmlDiffCharData;
if (changedCD == null)
{
return(XmlDiffOperation.Undefined);
}
if (Value == changedCD.Value)
{
return(XmlDiffOperation.Match);
}
else
{
return(XmlDiffOperation.ChangeCharacterData);
}
}
// 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();
}
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);
}
}
static internal int OrderCharacterData(XmlDiffCharData t1, XmlDiffCharData t2)
{
Debug.Assert(t1 != null && t2 != null);
return(OrderStrings(t1.Value, t2.Value));
}
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, 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;
}
internal static int OrderCharacterData(XmlDiffCharData t1, XmlDiffCharData t2)
{
return XmlDiffDocument.OrderStrings(t1.Value, t2.Value);
}
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;
}
}
static internal int OrderCharacterData( XmlDiffCharData t1, XmlDiffCharData t2 )
{
Debug.Assert( t1 != null && t2 != null );
return OrderStrings( t1.Value, t2.Value );
}
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;
}