开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
DiffgramOperation.cs
资源名称：xmlnotepad.rar　[点击查看]
上传用户：hbhltzc
上传日期：2022-06-04
资源大小：1925k
文件大小：33k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

DiffgramOperation.cs：源码内容
  1. //------------------------------------------------------------------------------
  2. // <copyright file="DiffgramOperation.cs" company="Microsoft">
  3. //     Copyright (c) Microsoft Corporation.  All rights reserved.
  4. // </copyright>                                                                
  5. //------------------------------------------------------------------------------
  7. using System;
  8. using System.Xml;
  9. using System.Text;
  10. using System.Diagnostics;
  11. using System.Collections;
  13. namespace Microsoft.XmlDiffPatch
  14. {
  15. //////////////////////////////////////////////////////////////////
  16. // DiffgramOperation
  17. //
  18. internal abstract class DiffgramOperation
  19. {
  20. // Fields
  21.     internal DiffgramOperation _nextSiblingOp;
  22.     protected ulong _operationID;
  23.     internal DiffgramOperation _parent;
  25. internal DiffgramOperation( ulong operationID )
  26. {
  27.         _nextSiblingOp = null;
  28.         _operationID = operationID;
  29. }
  31.     internal abstract XmlDiffOperation Operation { get; }
  33. // Methods
  34.     internal abstract void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff );
  36.     internal static string GetRelativeAddressOfNodeset( XmlDiffNode firstNode, XmlDiffNode lastNode )
  37.     {
  38. Debug.Assert( !( firstNode is XmlDiffAttributeOrNamespace ) &&
  39.           !( lastNode is XmlDiffAttributeOrNamespace ) );
  41.         int prevPosition = -1;
  42.         bool bInterval = false;
  43.         StringBuilder sb = new StringBuilder();
  44.         XmlDiffNode curNode = firstNode;
  45.         for (;;)
  46.         {
  47. Debug.Assert( curNode.Position > 0 );
  49.             if ( curNode.Position != prevPosition + 1 ) {
  50.                 if ( bInterval ) {
  51.                     sb.Append( prevPosition );
  52.                     bInterval = false;
  53.                     sb.Append( '|' );
  54.                 }
  55.                 sb.Append( curNode.Position );
  56.                 if ( curNode != lastNode ) {
  57.                     if ( curNode._nextSibling.Position == curNode.Position + 1 ) {
  58.                         sb.Append( "-" );
  59.                         bInterval = true;
  60.                     }
  61.                     else
  62.                         sb.Append( '|' );
  63.                 }
  64.             }
  66.             if ( curNode == lastNode )
  67.                 break;
  69.             prevPosition = curNode.Position;
  70.             curNode = curNode._nextSibling;
  71.         }
  72.         
  73.         if ( bInterval )
  74.             sb.Append( lastNode.Position );
  76.         return sb.ToString();
  77.     }
  79. internal static void GetAddressOfAttributeInterval( AttributeInterval interval, XmlWriter xmlWriter )
  80. {
  81. Debug.Assert( interval != null );
  82. if ( interval._next == null )
  83. {
  84. if ( interval._firstAttr == interval._lastAttr )
  85. {
  86. xmlWriter.WriteAttributeString( "match", interval._firstAttr.GetRelativeAddress() );
  87. return;
  88. }
  90.             if ( interval._firstAttr._parent._firstChildNode == interval._firstAttr && 
  91.  ( interval._lastAttr._nextSibling == null || 
  92.    interval._lastAttr._nextSibling.NodeType != XmlDiffNodeType.Attribute ) )
  93. {
  94. xmlWriter.WriteAttributeString( "match", "@*" );
  95. return;
  96. }
  97. }
  99. string match = string.Empty;
  101. for(;;)
  102. {
  103. XmlDiffAttribute attr = (XmlDiffAttribute) interval._firstAttr;
  104. for (;;)
  105. {
  106. match += attr.GetRelativeAddress();
  108. if ( attr == interval._lastAttr )
  109. break;
  110. match += "|";
  111. attr = (XmlDiffAttribute) attr._nextSibling;
  112. Debug.Assert( attr != null );
  113. }
  115. interval = interval._next;
  116. if ( interval == null )
  117. {
  118. xmlWriter.WriteAttributeString( "match", match );
  119. return;
  120. }
  122. match += "|";
  123. }
  124. }
  126. internal static void WriteAbsoluteMatchAttribute( XmlDiffNode node, XmlWriter xmlWriter )
  127.     {
  128.         XmlDiffAttribute attr = node as XmlDiffAttribute;
  129.         
  130.         if ( attr != null  && attr.NamespaceURI != string.Empty )
  131.             WriteNamespaceDefinition( attr, xmlWriter );
  133.         xmlWriter.WriteAttributeString( "match", node.GetAbsoluteAddress() );
  134.     }
  136.     private static void WriteNamespaceDefinition( XmlDiffAttribute attr, XmlWriter xmlWriter )
  137.     {
  138.         Debug.Assert( attr.NamespaceURI != string.Empty );
  140.         if ( attr.Prefix != string.Empty )
  141.             xmlWriter.WriteAttributeString( "xmlns", attr.Prefix, XmlDiff.XmlnsNamespaceUri, attr.NamespaceURI );
  142.         else
  143.             xmlWriter.WriteAttributeString( string.Empty, "xmlns", XmlDiff.XmlnsNamespaceUri, attr.NamespaceURI );
  144.     }
  145. }
  147. //////////////////////////////////////////////////////////////////
  148. // DiffgramParentOperation
  149. //
  150. internal abstract class DiffgramParentOperation : DiffgramOperation
  151. {
  152. // Fields
  153.     internal DiffgramOperation _firstChildOp;
  154.     internal DiffgramOperation _lastChildOp;
  156. // Constructor
  157. internal DiffgramParentOperation( ulong operationID ) : base ( operationID )
  158. {
  159.         _firstChildOp = null;
  160.         _lastChildOp = null;
  161. }
  163. // Methods
  164.     internal void InsertAtBeginning( DiffgramOperation newOp )
  165.     {
  166.         newOp._nextSiblingOp = _firstChildOp;
  167.         _firstChildOp = newOp;
  168.         newOp._parent = this;
  170.         if ( newOp._nextSiblingOp == null )
  171.             _lastChildOp = newOp;
  172.     }
  174.     internal void InsertAtEnd( DiffgramOperation newOp )
  175.     {
  176.         newOp._nextSiblingOp = null;
  177.         if ( _lastChildOp == null ) 
  178.         {
  179.             Debug.Assert( _firstChildOp == null );
  180.             _firstChildOp = _lastChildOp = newOp;
  181.         }
  182.         else
  183.         {
  184.             _lastChildOp._nextSiblingOp = newOp;
  185.             _lastChildOp = newOp;
  186.         }
  187.         newOp._parent = this;
  188.     }
  190.     internal void InsertAfter( DiffgramOperation newOp, DiffgramOperation refOp )
  191.     {
  192.         Debug.Assert( newOp._nextSiblingOp == null );
  193.         if ( refOp == null )
  194.         {
  195.         }
  196.         else
  197.         {
  198.             newOp._nextSiblingOp = refOp._nextSiblingOp;
  199.             refOp._nextSiblingOp = newOp;
  200.         }
  201.         newOp._parent = this;
  202.     }
  204.     internal void InsertOperationAtBeginning( DiffgramOperation op )
  205.     {
  206.         Debug.Assert( op._nextSiblingOp == null );
  207.         op._nextSiblingOp = _firstChildOp;
  208.         _firstChildOp = op;
  209.         op._parent = this;
  210.     }
  212.     internal void WriteChildrenTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  213.     {
  214.         DiffgramOperation curOp = _firstChildOp;
  215.         while ( curOp != null )
  216.         {
  217.             curOp.WriteTo( xmlWriter, xmlDiff );
  218.             curOp = curOp._nextSiblingOp;
  219.         }
  220.     }
  222. internal bool MergeRemoveSubtreeAtBeginning( XmlDiffNode subtreeRoot )
  223. {
  224. Debug.Assert( !( subtreeRoot is XmlDiffAttributeOrNamespace ) );
  226. DiffgramRemoveSubtrees remSubtrees = _firstChildOp as DiffgramRemoveSubtrees;
  228. return ( remSubtrees != null &&
  229.      remSubtrees.SetNewFirstNode( subtreeRoot ) );
  230. }
  232. internal bool MergeRemoveSubtreeAtEnd( XmlDiffNode subtreeRoot )
  233. {
  234. Debug.Assert( !( subtreeRoot is XmlDiffAttributeOrNamespace ) );
  236. DiffgramRemoveSubtrees remSubtrees = _lastChildOp as DiffgramRemoveSubtrees;
  238. return ( remSubtrees != null &&
  239.      remSubtrees.SetNewLastNode( subtreeRoot ) );
  240. }
  242. internal bool MergeRemoveAttributeAtBeginning( XmlDiffNode subtreeRoot )
  243. {
  244. if ( subtreeRoot.NodeType != XmlDiffNodeType.Attribute )
  245.             return false;
  247. DiffgramRemoveAttributes remAttrs = _firstChildOp as DiffgramRemoveAttributes;
  249. return ( remAttrs != null &&
  250.      remAttrs.AddAttribute( (XmlDiffAttribute)subtreeRoot ) );
  251. }
  253.     internal bool MergeAddSubtreeAtBeginning( XmlDiffNode subtreeRoot )
  254.     {
  255.         Debug.Assert( subtreeRoot.NodeType != XmlDiffNodeType.Attribute );
  257.         DiffgramAddSubtrees addSubtrees = _firstChildOp as DiffgramAddSubtrees;
  259.         return ( addSubtrees != null &&
  260.                  addSubtrees.SetNewFirstNode( subtreeRoot ) );
  261.     }
  263.     internal bool MergeAddSubtreeAtEnd( XmlDiffNode subtreeRoot )
  264.     {
  265.         Debug.Assert( subtreeRoot.NodeType != XmlDiffNodeType.Attribute );
  267.         DiffgramAddSubtrees addSubtrees = _lastChildOp as DiffgramAddSubtrees;
  269.         return ( addSubtrees != null &&
  270.                  addSubtrees.SetNewLastNode( subtreeRoot ) );
  271.     }
  272. }
  274. //////////////////////////////////////////////////////////////////
  275. // DiffgramAddNode
  276. //
  277. internal class DiffgramAddNode : DiffgramParentOperation
  278. {
  279. // Fields
  280.     XmlDiffNode _targetNode;
  282. // Constructor
  283.     internal DiffgramAddNode( XmlDiffNode targetNode, ulong operationID ) : base ( operationID )
  284.     {
  285.         Debug.Assert( targetNode != null );
  286.         Debug.Assert( targetNode.NodeType == XmlDiffNodeType.Element ||
  287.                       targetNode.NodeType == XmlDiffNodeType.Attribute ||
  288.                       targetNode.NodeType == XmlDiffNodeType.Namespace ||
  289.                       targetNode.NodeType == XmlDiffNodeType.XmlDeclaration || 
  290.                       targetNode.NodeType == XmlDiffNodeType.DocumentType || 
  291.                       targetNode.NodeType == XmlDiffNodeType.EntityReference );
  293.         _targetNode = targetNode;
  294.     }
  296. // Properties
  297.     internal override XmlDiffOperation Operation { 
  298.         get { 
  299.             return XmlDiffOperation.Add; 
  300.         }
  301.     }
  303. // Methods
  304.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  305.     {
  306.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "add", XmlDiff.NamespaceUri );
  308.         switch ( _targetNode.NodeType )
  309.         {
  310.             case XmlDiffNodeType.Element:
  311.             {
  312.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.Element).ToString() );
  314.                 XmlDiffElement el = _targetNode as XmlDiffElement;
  315.                 xmlWriter.WriteAttributeString( "name", el.LocalName );
  316.                 if ( el.NamespaceURI != string.Empty )
  317.                     xmlWriter.WriteAttributeString( "ns", el.NamespaceURI );
  318.                 if ( el.Prefix != string.Empty )
  319.                     xmlWriter.WriteAttributeString( "prefix", el.Prefix );
  320.                 if ( _operationID != 0 ) 
  321.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  323.                 WriteChildrenTo( xmlWriter, xmlDiff );
  324.                 break;
  325.             }
  326.             case XmlDiffNodeType.Attribute:
  327.             {
  328.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.Attribute).ToString() );
  330.                 XmlDiffAttribute at = _targetNode as XmlDiffAttribute;
  331.                 xmlWriter.WriteAttributeString( "name", at.LocalName );
  332.                 if ( at.NamespaceURI != string.Empty )
  333.                     xmlWriter.WriteAttributeString( "ns", at.NamespaceURI );
  334.                 if ( at.Prefix != string.Empty )
  335.                     xmlWriter.WriteAttributeString( "prefix", at.Prefix );
  336.                 if ( _operationID != 0 ) 
  337.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  338.                 xmlWriter.WriteString( at.Value );
  339.                 break;
  340.             }
  341.             case XmlDiffNodeType.Namespace:
  342.             {
  343.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.Attribute).ToString() );
  345.                 XmlDiffNamespace ns = _targetNode as XmlDiffNamespace;
  346.                 if ( ns.Prefix != string.Empty )
  347.                 {
  348.                     xmlWriter.WriteAttributeString( "prefix", "xmlns" );
  349.                     xmlWriter.WriteAttributeString( "name", ns.Prefix );
  350.                 }
  351.                 else
  352.                     xmlWriter.WriteAttributeString( "name", "xmlns" );
  353.                 if ( _operationID != 0 ) 
  354.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  356.                 xmlWriter.WriteString( ns.NamespaceURI );
  357.                 break;
  358.             }
  359.             case XmlDiffNodeType.CDATA:
  360.             {
  361.                 Debug.Assert( false, "CDATA nodes should be added with DiffgramAddSubtrees class." );
  363.                 xmlWriter.WriteAttributeString( "type", ((int)_targetNode.NodeType).ToString() );
  365.                 if ( _operationID != 0 ) 
  366.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  367.                 xmlWriter.WriteCData( (_targetNode as XmlDiffCharData).Value );
  368.                 break;
  369.             }
  370.             case XmlDiffNodeType.Comment:
  371.             {
  372.                 Debug.Assert( false, "Comment nodes should be added with DiffgramAddSubtrees class." );
  374.                 xmlWriter.WriteAttributeString( "type", ((int)_targetNode.NodeType).ToString() );
  376.                 if ( _operationID != 0 ) 
  377.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  378.                 xmlWriter.WriteComment( (_targetNode as XmlDiffCharData).Value );
  379.                 break;
  380.             }
  381.             case XmlDiffNodeType.Text:
  382.             {
  383.                 Debug.Assert( false, "Text nodes should be added with DiffgramAddSubtrees class." );
  385.                 xmlWriter.WriteAttributeString( "type", ((int)_targetNode.NodeType).ToString() );
  387.                 if ( _operationID != 0 ) 
  388.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  389.                 xmlWriter.WriteString( (_targetNode as XmlDiffCharData).Value );
  390.                 break;
  391.             }
  392.             case XmlDiffNodeType.ProcessingInstruction:
  393.             {
  394.                 Debug.Assert( false, "Processing instruction nodes should be added with DiffgramAddSubtrees class." );
  396.                 xmlWriter.WriteAttributeString( "type", ((int)_targetNode.NodeType).ToString() );
  398.                 if ( _operationID != 0 ) 
  399.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  400.                 XmlDiffPI pi = _targetNode as XmlDiffPI;
  401.                 xmlWriter.WriteProcessingInstruction( pi.Name, pi.Value );
  402.                 break;
  403.             }
  404.             case XmlDiffNodeType.EntityReference:
  405.             {
  406.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.EntityReference).ToString() );
  408.                 if ( _operationID != 0 ) 
  409.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  411.                 xmlWriter.WriteAttributeString( "name", ((XmlDiffER)_targetNode).Name );
  412.                 break;
  413.             }
  414.             case XmlDiffNodeType.SignificantWhitespace:
  415.             {
  416.                 Debug.Assert( false, "Significant whitespace nodes should be added with DiffgramAddSubtrees class." );
  418.                 xmlWriter.WriteAttributeString( "type", ((int)_targetNode.NodeType).ToString() );
  420.                 if ( _operationID != 0 ) 
  421.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  422.                 xmlWriter.WriteString( ((XmlDiffCharData)_targetNode).Value );
  423.                 break;
  424.             }
  425.             case XmlDiffNodeType.XmlDeclaration:
  426.             {
  427.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.XmlDeclaration).ToString() );
  429.                 if ( _operationID != 0 )
  430.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  431.                 xmlWriter.WriteString( ((XmlDiffXmlDeclaration)_targetNode).Value ); 
  432.                 break;
  433.             }
  434.             case XmlDiffNodeType.DocumentType:
  435.             {
  436.                 xmlWriter.WriteAttributeString( "type", ((int)XmlNodeType.DocumentType).ToString() );
  438.                 XmlDiffDocumentType docType = (XmlDiffDocumentType)_targetNode;
  440.                 if ( _operationID != 0 )
  441.                     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  442.                 xmlWriter.WriteAttributeString( "name", docType.Name );
  443.                 if ( docType.PublicId != string.Empty )
  444.                     xmlWriter.WriteAttributeString( "publicId", docType.PublicId );
  445.                 if ( docType.SystemId != string.Empty )
  446.                     xmlWriter.WriteAttributeString( "systemId", docType.SystemId );
  447.                 if ( docType.Subset != string.Empty )
  448.                     xmlWriter.WriteCData( docType.Subset );
  449.                 break;
  450.             }
  451.             default:
  452.                 Debug.Assert( false );
  453.                 break;
  454.         }
  456.         xmlWriter.WriteEndElement();
  457.     }
  458. }
  460. //////////////////////////////////////////////////////////////////
  461. // DiffgramAddSubtrees
  462. //
  463. internal class DiffgramAddSubtrees : DiffgramOperation
  464. {
  465. // Fields
  466.     internal XmlDiffNode _firstTargetNode;
  467.     internal XmlDiffNode _lastTargetNode;
  468.     private bool _bSorted;
  469.     private bool _bNeedNamespaces;
  471. // Constructor
  472.     internal DiffgramAddSubtrees( XmlDiffNode subtreeRoot, ulong operationID, bool bSorted ) : base ( operationID )
  473.     {
  474.         Debug.Assert( subtreeRoot != null );
  475.         _firstTargetNode = subtreeRoot;
  476.         _lastTargetNode = subtreeRoot;
  477.         _bSorted = bSorted;
  478.         _bNeedNamespaces = subtreeRoot.NodeType == XmlDiffNodeType.Element;
  479.     }
  481. // Properties
  482.     internal override XmlDiffOperation Operation {
  483.         get {
  484.             return XmlDiffOperation.Add;
  485.         }
  486.     }
  488. // Methods
  489.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  490.     {
  491.         if ( !_bSorted )
  492.             Sort();
  494.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "add", XmlDiff.NamespaceUri );
  495.         if ( _operationID != 0 ) 
  496.             xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  498.         // namespaces
  499.         if ( _bNeedNamespaces ) {
  500.             Hashtable definedPrefixes = new Hashtable(); 
  501.             XmlDiffParentNode parent = _firstTargetNode._parent;
  502.             while ( parent != null ) {
  503.                 if ( parent._bDefinesNamespaces ) {
  504.                     XmlDiffElement el = (XmlDiffElement)parent;
  505.                     XmlDiffAttributeOrNamespace curNs = el._attributes;
  506.                     while ( curNs != null && curNs.NodeType == XmlDiffNodeType.Namespace ) {
  507.                         if ( definedPrefixes[curNs.Prefix] == null ) {
  508.                             if ( curNs.Prefix == string.Empty )
  509.                                 xmlWriter.WriteAttributeString( "xmlns", XmlDiff.XmlnsNamespaceUri, curNs.NamespaceURI );
  510.                             else
  511.                                 xmlWriter.WriteAttributeString( "xmlns", curNs.Prefix, XmlDiff.XmlnsNamespaceUri, curNs.NamespaceURI );
  512.                             definedPrefixes[curNs.Prefix] = curNs.Prefix;
  513.                         }
  514.                         curNs = (XmlDiffAttributeOrNamespace)curNs._nextSibling;
  515.                     }
  516.                 }
  517.                 parent = parent._parent;
  518.             }
  519.         }
  520.         
  521.         // output nodes
  522.         XmlDiffNode node = _firstTargetNode;
  523.         for (;;)
  524.         {
  525.             node.WriteTo( xmlWriter );
  526.             if ( node == _lastTargetNode )
  527.                 break;
  528.             node = node._nextSibling;
  529.         }
  530.         xmlWriter.WriteEndElement();
  531.     }
  533.     private void Sort() {
  534.         XmlDiffNode prevSibling = null;
  535.         XmlDiff.SortNodesByPosition( ref _firstTargetNode, ref _lastTargetNode, ref prevSibling );
  536.         _bSorted = true;
  537.     }
  539. internal bool SetNewFirstNode( XmlDiffNode targetNode )
  540. {
  541. if ( _operationID != 0 ||
  542.  targetNode._nextSibling != _firstTargetNode ||
  543.              ( targetNode.NodeType == XmlDiffNodeType.Text && _firstTargetNode.NodeType == XmlDiffNodeType.Text ) ||
  544.      !targetNode.CanMerge ||
  545.      !_firstTargetNode.CanMerge )
  546. return false;
  548. _firstTargetNode = targetNode;
  550.         if ( targetNode.NodeType == XmlDiffNodeType.Element )
  551.             _bNeedNamespaces = true;
  552. return true;
  553. }
  555. internal bool SetNewLastNode( XmlDiffNode targetNode )
  556. {
  557. if ( _operationID != 0 ||
  558.  _lastTargetNode._nextSibling != targetNode ||
  559.              ( targetNode.NodeType == XmlDiffNodeType.Text && _lastTargetNode.NodeType == XmlDiffNodeType.Text ) ||
  560.      !targetNode.CanMerge ||
  561.      !_lastTargetNode.CanMerge )
  562. return false;
  564. _lastTargetNode = targetNode;
  566.         if ( targetNode.NodeType == XmlDiffNodeType.Element )
  567.             _bNeedNamespaces = true;
  568. return true;
  569. }
  570. }
  572. //////////////////////////////////////////////////////////////////
  573. // DiffgramCopy
  574. //
  575. internal class DiffgramCopy : DiffgramParentOperation
  576. {
  577. // Fields
  578.     XmlDiffNode _sourceNode;
  579.     bool _bSubtree;
  581. // Constructor
  582.     internal DiffgramCopy( XmlDiffNode sourceNode, bool bSubtree, ulong operationID ) : base ( operationID )
  583.     {
  584.         Debug.Assert( sourceNode != null );
  585.         _sourceNode = sourceNode;
  586.         _bSubtree = bSubtree;
  587.     }
  589. // Properties
  590.     internal override XmlDiffOperation Operation {
  591.         get {
  592.             return XmlDiffOperation.Add;
  593.         }
  594.     }
  596. // Methods
  597.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  598.     {
  599.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "add", XmlDiff.NamespaceUri );
  600.         WriteAbsoluteMatchAttribute( _sourceNode, xmlWriter );
  601.         if ( !_bSubtree )
  602.             xmlWriter.WriteAttributeString( "subtree", "no" );
  603.         if ( _operationID != 0 ) 
  604.             xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  606.         WriteChildrenTo( xmlWriter, xmlDiff );
  608.         xmlWriter.WriteEndElement();
  609.     }
  610. }
  612. //////////////////////////////////////////////////////////////////
  613. // DiffgramRemoveNode
  614. //
  615. internal class DiffgramRemoveNode : DiffgramParentOperation
  616. {
  617. // Fields
  618.     internal XmlDiffNode _sourceNode;
  619.     bool _bSubtree;
  621. // Costructor
  622.     internal DiffgramRemoveNode( XmlDiffNode sourceNode, bool bSubtree, ulong operationID ) : base ( operationID )
  623.     {
  624.         Debug.Assert( sourceNode != null );
  625.         _sourceNode = sourceNode;
  626.         _bSubtree = bSubtree;
  627.     }
  629. // Properties
  630.     internal override XmlDiffOperation Operation {
  631.         get {
  632.             return XmlDiffOperation.Remove;
  633.         }
  634.     }
  636. // Methods
  637.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  638.     {
  639.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "remove", XmlDiff.NamespaceUri );
  640.         xmlWriter.WriteAttributeString( "match", _sourceNode.GetRelativeAddress() );
  641.         if ( !_bSubtree )
  642.             xmlWriter.WriteAttributeString( "subtree", "no" );
  643.         if ( _operationID != 0 ) 
  644.             xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  646.         WriteChildrenTo( xmlWriter, xmlDiff );
  648.         xmlWriter.WriteEndElement();
  649.     }
  650. }
  652. //////////////////////////////////////////////////////////////////
  653. // DiffgramRemoveSubtrees
  654. //
  655. internal class DiffgramRemoveSubtrees : DiffgramOperation
  656. {
  657. // Fields
  658.     XmlDiffNode _firstSourceNode;
  659. XmlDiffNode _lastSourceNode;
  660.     bool _bSorted;
  662. // Constructor
  663.     internal DiffgramRemoveSubtrees( XmlDiffNode sourceNode, ulong operationID, bool bSorted ) : base ( operationID )
  664.     {
  665.         Debug.Assert( sourceNode != null );
  666.         _firstSourceNode = sourceNode;
  667. _lastSourceNode = sourceNode;
  668.         _bSorted = bSorted;
  669.     }
  671. // Properties
  672.     internal override XmlDiffOperation Operation {
  673.         get {
  674.             return XmlDiffOperation.Remove;
  675.         }
  676.     }
  678. // Methods
  679.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  680.     {
  681.         if ( !_bSorted ) 
  682.             Sort();
  684.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "remove", XmlDiff.NamespaceUri );
  685. if ( _firstSourceNode == _lastSourceNode ) 
  686. xmlWriter.WriteAttributeString( "match", _firstSourceNode.GetRelativeAddress() );
  687. else
  688. xmlWriter.WriteAttributeString( "match", GetRelativeAddressOfNodeset( _firstSourceNode, _lastSourceNode ) );
  689.         if ( _operationID != 0 ) 
  690.             xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  691.         xmlWriter.WriteEndElement();
  692.     }
  694.     private void Sort() {
  695.         XmlDiffNode prevSibling = null;
  696.         XmlDiff.SortNodesByPosition( ref _firstSourceNode, ref _lastSourceNode, ref prevSibling );
  697.         _bSorted = true;
  698.     }
  700. internal bool SetNewFirstNode( XmlDiffNode srcNode )
  701. {
  702. if ( _operationID != 0 ||
  703.  srcNode._nextSibling != _firstSourceNode ||
  704.  !srcNode.CanMerge ||
  705.  !_firstSourceNode.CanMerge )
  706. return false;
  708. _firstSourceNode = srcNode;
  709. return true;
  710. }
  712. internal bool SetNewLastNode( XmlDiffNode srcNode )
  713. {
  714. if ( _operationID != 0 ||
  715.  _lastSourceNode._nextSibling != srcNode ||
  716.  !srcNode.CanMerge ||
  717.              !_firstSourceNode.CanMerge )
  718. return false;
  720. _lastSourceNode = srcNode;
  721. return true;
  722. }
  723. }
  725. //////////////////////////////////////////////////////////////////
  726. // DiffgramRemoveAttributes
  727. //
  728. internal class DiffgramRemoveAttributes : DiffgramOperation
  729. {
  730. // Fields
  731.     AttributeInterval _attributes;
  733. // Constructor
  734.     internal DiffgramRemoveAttributes( XmlDiffAttribute sourceAttr ) : base ( 0 )
  735.     {
  736.         Debug.Assert( sourceAttr != null );
  737. _attributes = new AttributeInterval( sourceAttr, null );
  738.     }
  740. // Properties
  741.     internal override XmlDiffOperation Operation {
  742.         get {
  743.             return XmlDiffOperation.Remove;
  744.         }
  745.     }
  747. // Methods
  748.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  749.     {
  750.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "remove", XmlDiff.NamespaceUri );
  751.         GetAddressOfAttributeInterval( _attributes, xmlWriter );
  752.         Debug.Assert( _operationID == 0 );
  753.         xmlWriter.WriteEndElement();
  754.     }
  756. internal bool AddAttribute( XmlDiffAttribute srcAttr )
  757. {
  758. if ( _operationID != 0 ||
  759.  srcAttr._parent != _attributes._firstAttr._parent )
  760. return false;
  762. if ( srcAttr._nextSibling == _attributes._firstAttr )
  763. _attributes._firstAttr = srcAttr;
  764. else
  765. _attributes = new AttributeInterval( srcAttr, _attributes );
  767. return true;
  768. }
  769. }
  771. //////////////////////////////////////////////////////////////////
  772. // DiffgramChangeNode
  773. //
  774. internal class DiffgramChangeNode : DiffgramParentOperation
  775. {
  776. // Fields
  777.     internal XmlDiffNode _sourceNode;
  778.     internal XmlDiffNode _targetNode;
  779.     internal XmlDiffOperation _op;
  781. // Constructor
  782.     internal DiffgramChangeNode( XmlDiffNode sourceNode, XmlDiffNode targetNode, XmlDiffOperation op, ulong operationID ) 
  783.         : base ( operationID )
  784.     {
  785.         Debug.Assert( sourceNode != null );
  786.         Debug.Assert( targetNode != null );
  787.         Debug.Assert( XmlDiff.IsChangeOperation( op ) || op == XmlDiffOperation.ChangeAttr);
  789.         _sourceNode = sourceNode;
  790.         _targetNode = targetNode;
  791.         _op = op;
  792.     }
  794. // Properties
  795.     internal override XmlDiffOperation Operation {
  796.         get {
  797.             return _op;
  798.         }
  799.     }
  801. // Methods
  802.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  803.     {
  804.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "change", XmlDiff.NamespaceUri );
  805.         xmlWriter.WriteAttributeString( "match", _sourceNode.GetRelativeAddress() );
  806.         if ( _operationID != 0 ) 
  807.             xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
  809.         switch ( _op )
  810.         {
  811.             case XmlDiffOperation.ChangeAttr:
  812.             {
  813.                 XmlDiffAttribute sourceAttr = (XmlDiffAttribute) _sourceNode;
  814.                 XmlDiffAttribute targetAttr = (XmlDiffAttribute) _targetNode;
  816.                 if ( sourceAttr.Prefix != targetAttr.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces )
  817.                     xmlWriter.WriteAttributeString( "prefix", targetAttr.Prefix );
  818.                 if ( sourceAttr.NamespaceURI != targetAttr.NamespaceURI && !xmlDiff.IgnoreNamespaces )
  819.                     xmlWriter.WriteAttributeString( "ns", targetAttr.NamespaceURI );
  820.                 xmlWriter.WriteString( targetAttr.Value );
  821.                 break;
  822.             }
  823.         case XmlDiffOperation.ChangeElementName:
  824.             {
  825.                 XmlDiffElement sourceEl = (XmlDiffElement) _sourceNode;
  826.                 XmlDiffElement targetEl = (XmlDiffElement) _targetNode;
  828.                 if ( sourceEl.LocalName != targetEl.LocalName )
  829.                     xmlWriter.WriteAttributeString( "name", targetEl.LocalName );
  830.                 if ( sourceEl.Prefix != targetEl.Prefix && !xmlDiff.IgnorePrefixes && !xmlDiff.IgnoreNamespaces )
  831.                     xmlWriter.WriteAttributeString( "prefix", targetEl.Prefix );
  832.                 if ( sourceEl.NamespaceURI != targetEl.NamespaceURI && !xmlDiff.IgnoreNamespaces )
  833.                     xmlWriter.WriteAttributeString( "ns", targetEl.NamespaceURI );
  835.                 WriteChildrenTo( xmlWriter, xmlDiff );
  837.                 break;
  838.             }
  839.         case XmlDiffOperation.ChangePI:
  840.             {
  841. XmlDiffPI sourcePi = (XmlDiffPI)_sourceNode;
  842.                 XmlDiffPI targetPi = (XmlDiffPI)_targetNode;
  844.                 if ( sourcePi.Value == targetPi.Value ) {
  845.                     Debug.Assert( sourcePi.Name != targetPi.Name );
  846.          xmlWriter.WriteAttributeString( "name", targetPi.Name );
  847.                 }
  848.                 else {
  849. xmlWriter.WriteProcessingInstruction( targetPi.Name, targetPi.Value );
  850.                 }
  851.                 break;
  852.             }
  853.             case XmlDiffOperation.ChangeCharacterData:
  854.             {
  855.                 XmlDiffCharData chd = (XmlDiffCharData)_targetNode;
  856.                 switch ( _targetNode.NodeType ) {
  857.                     case XmlDiffNodeType.Text:
  858.                     case XmlDiffNodeType.SignificantWhitespace:
  859.                         xmlWriter.WriteString( chd.Value );
  860.                         break;
  861.                     case XmlDiffNodeType.Comment:
  862.                         xmlWriter.WriteComment( chd.Value );
  863.                         break;
  864.                     case XmlDiffNodeType.CDATA:
  865.                         xmlWriter.WriteCData( chd.Value );
  866.                         break;
  867.                     default:
  868.                         Debug.Assert( false );
  869.                         break;
  870.                 }
  871.                 break;
  872.             }
  873.             case XmlDiffOperation.ChangeER:
  874.             {
  875.                 xmlWriter.WriteAttributeString( "name", ((XmlDiffER)_targetNode).Name );
  876.                 break;
  877.             }
  878.             case XmlDiffOperation.ChangeXmlDeclaration:
  879.             {
  880.                 xmlWriter.WriteString( ((XmlDiffXmlDeclaration)_targetNode).Value );
  881.                 break;
  882.             }
  883.             case XmlDiffOperation.ChangeDTD:
  884.             {
  885. XmlDiffDocumentType sourceDtd = (XmlDiffDocumentType)_sourceNode;
  886.                 XmlDiffDocumentType targetDtd = (XmlDiffDocumentType)_targetNode;
  888. if ( sourceDtd.Name != targetDtd.Name )
  889. xmlWriter.WriteAttributeString( "name", targetDtd.Name );
  890. if ( sourceDtd.SystemId != targetDtd.SystemId )
  891. xmlWriter.WriteAttributeString( "systemId", targetDtd.SystemId );
  892. if ( sourceDtd.PublicId != targetDtd.PublicId )
  893. xmlWriter.WriteAttributeString( "publicId", targetDtd.PublicId );
  894. if ( sourceDtd.Subset != targetDtd.Subset )
  895. xmlWriter.WriteCData( targetDtd.Subset );
  896.                 break;
  897.             }
  898.             default:
  899.                 Debug.Assert( false );
  900.                 break;
  901.         }
  903.         xmlWriter.WriteEndElement();
  904.     }
  905. }
  907. //////////////////////////////////////////////////////////////////
  908. // DiffgramRemoveNode
  909. //
  910. internal class DiffgramPosition : DiffgramParentOperation
  911. {
  912. // Fields
  913.     internal XmlDiffNode _sourceNode;
  914.     internal XmlDiffNode _targetNode;
  916. // Costructor
  917.     internal DiffgramPosition( XmlDiffNode sourceNode, XmlDiffNode targetNode ) 
  918.         : this (  sourceNode ) {
  919.         _targetNode = targetNode;
  920.     }
  922.     internal DiffgramPosition( XmlDiffNode sourceNode ) : base( 0 )
  923.     {
  924.         Debug.Assert( !( sourceNode is XmlDiffAttributeOrNamespace ) );
  926.         if ( sourceNode is XmlDiffShrankNode ) 
  927.         {
  928.      Debug.Assert( sourceNode != null );
  929. sourceNode = ((XmlDiffShrankNode)sourceNode)._lastNode;
  930.         }
  932.         _sourceNode = sourceNode;
  933.     }
  935. // Properties
  936.     internal override XmlDiffOperation Operation {
  937.         get {
  938.             return XmlDiffOperation.Match;
  939.         }
  940.     }
  942. // Methods
  943.     internal override void WriteTo( XmlWriter xmlWriter, XmlDiff xmlDiff )
  944.     {
  945.         xmlWriter.WriteStartElement( XmlDiff.Prefix, "node", XmlDiff.NamespaceUri );
  946.         xmlWriter.WriteAttributeString( "match", _sourceNode.GetRelativeAddress() );
  948.         WriteChildrenTo( xmlWriter, xmlDiff );
  950.         xmlWriter.WriteEndElement();
  951.     }
  952. }
  954. //////////////////////////////////////////////////////////////////
  955. // AttributeInterval
  956. //
  957. internal class AttributeInterval
  958. {
  959. internal XmlDiffAttribute _firstAttr;
  960. internal XmlDiffAttribute _lastAttr;
  961. internal AttributeInterval _next;
  963. internal AttributeInterval( XmlDiffAttribute attr, AttributeInterval next )
  964. {
  965. _firstAttr = attr;
  966. _lastAttr = attr;
  967. _next = next;
  968. }
  969. }
  971. }