Example #1
0
        // 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);
            }
        }
Example #2
0
// 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();
        }
Example #3
0
        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);
            }
        }
Example #4
0
 static internal int OrderCharacterData(XmlDiffCharData t1, XmlDiffCharData t2)
 {
     Debug.Assert(t1 != null && t2 != null);
     return(OrderStrings(t1.Value, t2.Value));
 }
Example #5
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;
    }
Example #6
0
        // 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;
        }
Example #7
0
 internal static int OrderCharacterData(XmlDiffCharData t1, XmlDiffCharData t2)
 {
   return XmlDiffDocument.OrderStrings(t1.Value, t2.Value);
 }
Example #8
0
 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;
    }