Exemplo n.º 1
0
// Constructor
    internal EditScript( EditScript next)
    {
        _nextEditScript = next;
    }
Exemplo n.º 2
0
// Constructor
    internal EditScriptMatch( int startSourceIndex, int startTargetIndex, 
                              int length, EditScript next )
        : base ( next )
    {
        Debug.Assert( length > 0 );
        Debug.Assert( startSourceIndex > 0 );
        Debug.Assert( startTargetIndex > 0 );

        _firstSourceIndex = startSourceIndex;
        _firstTargetIndex = startTargetIndex;
        _length = length;
    }
Exemplo n.º 3
0
// Constructor
        internal EditScriptOpened(EditScript next) : base(next)
        {
        }
Exemplo n.º 4
0
// Constructor
    internal EditScriptReference( EditScript editScriptReference, EditScript next ) : base( next )
    {
        Debug.Assert( editScriptReference != null );
        Debug.Assert( next != null );

        _editScriptReference = editScriptReference;
    }
Exemplo n.º 5
0
        private void OnMatch( DiffgramParentOperation parent, bool bNeedPosition )
        {
            EditScriptMatch matchOp = _editScript as EditScriptMatch;

            Debug.Assert( _curSourceIndex == matchOp._firstSourceIndex + matchOp._length - 1 );
            Debug.Assert( _curTargetIndex == matchOp._firstTargetIndex + matchOp._length - 1 );

            // cache
            int endTargetIndex = matchOp._firstTargetIndex + matchOp._length - 1;
            int endSourceIndex = matchOp._firstSourceIndex + matchOp._length - 1;
            XmlDiffNode targetRoot = _targetNodes[ endTargetIndex ];
            XmlDiffNode sourceRoot = _sourceNodes[ endSourceIndex ];

            // a subtree or leaf node matches
            if ( matchOp._firstTargetIndex <= targetRoot.Left  &&
             matchOp._firstSourceIndex <= sourceRoot.Left )
            {
            if ( _bBuildingAddTree )
            {
                Debug.Assert( !bNeedPosition );

                ulong opid = GenerateOperationID( XmlDiffDescriptorType.Move );

                // output <add match=" "> to diffgram and "remove" to substitute script
                parent.InsertAtBeginning( new DiffgramCopy( sourceRoot, true, opid ) );

                // add 'remove' operation to postponed operations
                PostponedRemoveSubtrees( sourceRoot, opid,
                //AddToPosponedOperations( new DiffgramRemoveSubtrees( sourceRoot, opid ),
                                        sourceRoot.Left,
                                        endSourceIndex );
            }
            else
            {
                // matched element -> check attributes if they really match (hash values of attributes matches)
                if ( sourceRoot.NodeType == XmlDiffNodeType.Element )
                {
                    DiffgramPosition diffPos = _cachedDiffgramPosition;
                    diffPos._sourceNode = sourceRoot;

                    GenerateChangeDiffgramForAttributes( diffPos, (XmlDiffElement)sourceRoot, (XmlDiffElement)targetRoot );

                    if ( diffPos._firstChildOp != null || bNeedPosition )
                    {
                        parent.InsertAtBeginning( diffPos );
                        _cachedDiffgramPosition = new DiffgramPosition( null );
                        bNeedPosition = false;
                    }
                }
                // otherwise output <node> - only if we need the position (<=> preceding operation was 'add')
                else
                {
                    if ( bNeedPosition )
                    {
                        parent.InsertAtBeginning( new DiffgramPosition( sourceRoot ) );
                        bNeedPosition = false;
                    }
                    // xml declaration, DTD
                    else if ( !_bChildOrderSignificant && (int)sourceRoot.NodeType < 0 ) {
                        DiffgramOperation op = parent._firstChildOp;
                        if ( op is DiffgramAddNode || op is DiffgramAddSubtrees || op is DiffgramCopy ) {
                            parent.InsertAtBeginning( new DiffgramPosition( sourceRoot ) );
                        }
                    }
                }
            }

            // adjust current position
            _curSourceIndex = sourceRoot.Left - 1;
            _curTargetIndex = targetRoot.Left - 1;

            // adjust boundaries in the edit script or move to next edit script operation
            matchOp._length -= endTargetIndex - targetRoot.Left + 1;
            if ( matchOp._length <= 0 )
                _editScript = _editScript._nextEditScript;
            }
            // single but non-leaf node matches (-> recursively generate the diffgram subtree)
            else
            {
            // adjust current position
            _curSourceIndex--;
            _curTargetIndex--;

            // adjust boundaries in the edit script or move to next edit script operation
            matchOp._length--;
            if ( matchOp._length <= 0 )
                _editScript = _editScript._nextEditScript;

            DiffgramParentOperation diffgramNode;
            if ( _bBuildingAddTree )
            {
                Debug.Assert( !bNeedPosition );

                ulong opid = GenerateOperationID( XmlDiffDescriptorType.Move );
                bool bCopySubtree = sourceRoot.NodeType != XmlDiffNodeType.Element;

                // output <add match=".." subtree="no">
                diffgramNode = new DiffgramCopy( sourceRoot, bCopySubtree, opid );
                // add 'remove' operation to postponed operations
                PostponedRemoveNode( sourceRoot, bCopySubtree, opid,
                                     endSourceIndex,
                                     endSourceIndex );

                // recursively generate the diffgram subtree
                GenerateDiffgramAdd( diffgramNode, sourceRoot.Left, targetRoot.Left );

                // insert to diffgram tree
                parent.InsertAtBeginning( diffgramNode );
            }
            else
            {
                // output <node>
                diffgramNode = new DiffgramPosition( sourceRoot );

                // recursively generate the diffgram subtree
                GenerateDiffgramMatch( diffgramNode, sourceRoot.Left, targetRoot.Left );

                // insert to diffgram tree
                if ( diffgramNode._firstChildOp != null )
                    parent.InsertAtBeginning( diffgramNode );
            }
            }
        }
Exemplo n.º 6
0
        private void OnRemove( DiffgramParentOperation parent )
        {
            EditScriptRemove remOp = _editScript as EditScriptRemove;

            Debug.Assert( remOp._endSourceIndex == _curSourceIndex );
            XmlDiffNode sourceRoot = _sourceNodes[ remOp._endSourceIndex ];

            // remove subtree or leaf node and no descendant node matches (=has been moved somewhere else)
            if ( remOp._startSourceIndex <= sourceRoot.Left )
            {
            bool bShrankNode = sourceRoot is XmlDiffShrankNode;

            if ( sourceRoot._bSomeDescendantMatches && !bShrankNode )
            {
                DiffgramOperation newDiffOp = GenerateDiffgramRemoveWhenDescendantMatches( (XmlDiffParentNode)sourceRoot );
                if ( _bBuildingAddTree )
                {
                    PostponedOperation( newDiffOp, sourceRoot.Left, remOp._endSourceIndex );
                }
                else
                {
                    parent.InsertAtBeginning( newDiffOp );
                }
            }
            else
            {
                ulong opid = 0;
                // shrank node -> output as 'move' operation
                if ( bShrankNode )
                {
                    XmlDiffShrankNode shrankNode = (XmlDiffShrankNode) sourceRoot;
                    if ( shrankNode.MoveOperationId == 0 )
                        shrankNode.MoveOperationId = GenerateOperationID( XmlDiffDescriptorType.Move );
                    opid = shrankNode.MoveOperationId;

                    Debug.Assert( sourceRoot == _sourceNodes[ sourceRoot.Left ] );
                }

                // insert 'remove' operation
                if ( _bBuildingAddTree )
                {
                    PostponedRemoveSubtrees( sourceRoot, opid,
                    //AddToPosponedOperations( new DiffgramRemoveSubtrees( sourceRoot, opid ),
                        sourceRoot.Left, remOp._endSourceIndex );
                }
                else
                {
                    if ( opid != 0 ||
                        !parent.MergeRemoveSubtreeAtBeginning( sourceRoot ) )
                    {
                        parent.InsertAtBeginning( new DiffgramRemoveSubtrees( sourceRoot, opid, !_xmlDiff.IgnoreChildOrder ) );
                    }
                }
            }

            // adjust current position
            _curSourceIndex = sourceRoot.Left - 1;

            // adjust boundaries in the edit script or move to next edit script operation
            remOp._endSourceIndex = sourceRoot.Left - 1;
            if ( remOp._startSourceIndex > remOp._endSourceIndex )
                _editScript = _editScript._nextEditScript;
            }
            // remove single but non-leaf node or some descendant matches (=has been moved somewhere else)
            // -> recursively process diffgram subtree
            else
            {
            Debug.Assert( !( sourceRoot is XmlDiffShrankNode) );

            // adjust current position
            _curSourceIndex--;

            // adjust boundaries in the edit script or move to next edit script operation
            remOp._endSourceIndex--;
            if ( remOp._startSourceIndex > remOp._endSourceIndex )
                _editScript = _editScript._nextEditScript;

            bool bRemoveSubtree = sourceRoot.NodeType != XmlDiffNodeType.Element;

            if ( _bBuildingAddTree )
            {
                // add 'remove' to postponed operations
                PostponedRemoveNode( sourceRoot, bRemoveSubtree, 0,
                //AddToPosponedOperations( new DiffgramRemoveNode( sourceRoot, bRemoveSubtree, 0 ),
                    remOp._endSourceIndex + 1, remOp._endSourceIndex + 1 );

                // recursively parse subtree
                GenerateDiffgramAdd( parent, sourceRoot.Left, _targetNodes[ _curTargetIndex ].Left );
            }
            else
            {
                // 'remove' operation
                DiffgramRemoveNode remNode = new DiffgramRemoveNode( sourceRoot, bRemoveSubtree, 0 );

                // parse subtree
                GenerateDiffgramMatch( remNode, sourceRoot.Left, _targetNodes[ _curTargetIndex ].Left );

                parent.InsertAtBeginning( remNode );
            }
            }
        }
Exemplo n.º 7
0
// Constructor
    internal EditScriptChange( int sourceIndex, int targetIndex, XmlDiffOperation changeOp, EditScript next )
        : base( next )
    {
        Debug.Assert( sourceIndex > 0 );
        Debug.Assert( targetIndex > 0 );
        Debug.Assert( XmlDiff.IsChangeOperation( changeOp) );

        _sourceIndex = sourceIndex;
        _targetIndex = targetIndex;
        _changeOp = changeOp;
    }
Exemplo n.º 8
0
        // produces <change> element in diffgram
        private void OnChange( DiffgramParentOperation parent )
        {
            EditScriptChange chOp = _editScript as EditScriptChange;

            Debug.Assert( chOp._targetIndex == _curTargetIndex );
            Debug.Assert( chOp._sourceIndex == _curSourceIndex );

            XmlDiffNode sourceRoot = _sourceNodes[ chOp._sourceIndex ];
            XmlDiffNode targetRoot = _targetNodes[ chOp._targetIndex ];

            Debug.Assert( !( sourceRoot is XmlDiffShrankNode) );
            Debug.Assert( !( targetRoot is XmlDiffShrankNode) );

            // adjust current position
            _curSourceIndex--;
            _curTargetIndex--;

            // move to next edit script operation
            _editScript = _editScript._nextEditScript;

            DiffgramOperation diffgramNode = null;

            if ( _bBuildingAddTree )
            {
            // <add> changed node to the new location
            if ( targetRoot.NodeType == XmlDiffNodeType.Element )
                diffgramNode = new DiffgramAddNode( targetRoot, 0 );
            else
                diffgramNode = new DiffgramAddSubtrees( targetRoot, 0, !_xmlDiff.IgnoreChildOrder );

            // <remove> old node from old location -> add to postponed operations
            bool bSubtree = sourceRoot.NodeType != XmlDiffNodeType.Element;
            PostponedRemoveNode( sourceRoot, bSubtree, 0,
            //AddToPosponedOperations( new DiffgramRemoveNode( sourceRoot, bSubtree, 0 ),
                chOp._sourceIndex, chOp._sourceIndex );

            // recursively process children
            if ( sourceRoot.Left < chOp._sourceIndex ||
                targetRoot.Left < chOp._targetIndex )
            {
                Debug.Assert( targetRoot.NodeType == XmlDiffNodeType.Element );
                GenerateDiffgramAdd( (DiffgramParentOperation)diffgramNode, sourceRoot.Left, targetRoot.Left );
            }

            // add attributes, if element
            if ( targetRoot.NodeType == XmlDiffNodeType.Element )
                GenerateAddDiffgramForAttributes( (DiffgramParentOperation)diffgramNode, (XmlDiffElement)targetRoot );
            }
            else
            {
            ulong opid = 0;

            // change of namespace or prefix -> get the appropriate operation id
            if ( !_xmlDiff.IgnoreNamespaces &&
                 sourceRoot.NodeType == XmlDiffNodeType.Element )
            {
                XmlDiffElement sourceEl = (XmlDiffElement)sourceRoot;
                XmlDiffElement targetEl = (XmlDiffElement)targetRoot;

                if ( sourceEl.LocalName == targetEl.LocalName )
                {
                    opid = GetNamespaceChangeOpid( sourceEl.NamespaceURI, sourceEl.Prefix,
                                                   targetEl.NamespaceURI, targetEl.Prefix );
                }
            }

            if ( sourceRoot.NodeType == XmlDiffNodeType.Element )
            {
                if ( XmlDiff.IsChangeOperationOnAttributesOnly( chOp._changeOp ) )
                    diffgramNode = new DiffgramPosition( sourceRoot );
                else
                {
                    Debug.Assert( (int)chOp._changeOp == (int)XmlDiffOperation.ChangeElementName ||
                                  ( (int)chOp._changeOp >= (int)XmlDiffOperation.ChangeElementNameAndAttr1 &&
                                    (int)chOp._changeOp <= (int)XmlDiffOperation.ChangeElementNameAndAttr2 ) );

                    diffgramNode = new DiffgramChangeNode( sourceRoot, targetRoot, XmlDiffOperation.ChangeElementName, opid );
                }

                // recursively process children
                if ( sourceRoot.Left < chOp._sourceIndex ||
                    targetRoot.Left < chOp._targetIndex )
                {
                    GenerateDiffgramMatch( (DiffgramParentOperation) diffgramNode, sourceRoot.Left, targetRoot.Left );
                }

                GenerateChangeDiffgramForAttributes( (DiffgramParentOperation)diffgramNode, (XmlDiffElement)sourceRoot, (XmlDiffElement)targetRoot );
            }
            else
            {
                // '<change>'
                diffgramNode = new DiffgramChangeNode( sourceRoot, targetRoot, chOp._changeOp, opid );
                Debug.Assert( !sourceRoot.HasChildNodes );
            }
            }

            parent.InsertAtBeginning( diffgramNode );
        }
Exemplo n.º 9
0
// Constructor
    internal EditScriptAdd( int startTargetIndex, int endTargetIndex, EditScript next )
        : base ( next )
    {
        Debug.Assert( endTargetIndex - startTargetIndex >= 0 );
        Debug.Assert( startTargetIndex > 0 );
        Debug.Assert( endTargetIndex > 0 );

        _startTargetIndex = startTargetIndex;
        _endTargetIndex = endTargetIndex;
    }
Exemplo n.º 10
0
// Constructor
    internal EditScriptRemove( int startSourceIndex, int endSourceIndex, EditScript next )
        : base ( next )
    {
        Debug.Assert( endSourceIndex - startSourceIndex >= 0 );
        Debug.Assert( startSourceIndex > 0 );
        Debug.Assert( endSourceIndex > 0 );

        _startSourceIndex = startSourceIndex;
        _endSourceIndex = endSourceIndex;
    }
Exemplo n.º 11
0
// Constructor
        internal EditScriptRemoveOpened(int startSourceIndex, EditScript next)
            : base(next)
        {
            Debug.Assert(startSourceIndex > 0);
            _startSourceIndex = startSourceIndex;
        }
Exemplo n.º 12
0
// Constructor
        internal EditScript(EditScript next)
        {
            _nextEditScript = next;
        }
Exemplo n.º 13
0
// Constructor
        internal EditScriptAddOpened(int startTargetIndex, EditScript next)
            : base(next)
        {
            Debug.Assert(startTargetIndex > 0);
            _startTargetIndex = startTargetIndex;
        }
Exemplo n.º 14
0
        private void GenerateDiffgramPostponed( DiffgramParentOperation parent, ref EditScript editScript, int sourceBorderIndex, int targetBorderIndex )
        {
            while ( _curSourceIndex >= sourceBorderIndex  &&  editScript != null )
            {
            EditScriptPostponed esp = editScript as EditScriptPostponed;
            if ( esp == null ) {
                GenerateDiffgramMatch( parent, sourceBorderIndex, targetBorderIndex );
                return;
            }

            Debug.Assert( esp._endSourceIndex == _curSourceIndex );

            int sourceStartIndex = esp._startSourceIndex;
            int sourceLeft = _sourceNodes[ esp._endSourceIndex ].Left;
            DiffgramOperation diffOp = esp._diffOperation;

            // adjust current source index
            _curSourceIndex = esp._startSourceIndex - 1;

            // move to next edit script
            editScript = esp._nextEditScript;

            // not a subtree or leaf node operation -> process child operations
            if ( sourceStartIndex > sourceLeft ) {
                GenerateDiffgramPostponed( (DiffgramParentOperation) diffOp, ref editScript, sourceLeft, targetBorderIndex );
            }

            // insert operation
            parent.InsertAtBeginning( diffOp );
            }
        }
Exemplo n.º 15
0
// Constructor
    internal EditScriptOpened( EditScript next ) : base ( next ) {}
Exemplo n.º 16
0
        // returns true if a positioning <node> element is needed in diffgram
        private bool OnAdd( DiffgramParentOperation parent, int sourceBorderIndex, int targetBorderIndex )
        {
            EditScriptAdd addOp = _editScript as EditScriptAdd;

            Debug.Assert( addOp._endTargetIndex == _curTargetIndex );
            XmlDiffNode targetRoot = _targetNodes[ addOp._endTargetIndex ];

            // add subtree or leaf node and no descendant node matches (= has been moved from somewhere else)
            if ( addOp._startTargetIndex <= targetRoot.Left &&
             !targetRoot._bSomeDescendantMatches )
            {
            switch ( targetRoot.NodeType )
            {
                case XmlDiffNodeType.ShrankNode:
                    XmlDiffShrankNode shrankNode = (XmlDiffShrankNode)targetRoot;

                    if ( shrankNode.MoveOperationId == 0 )
                        shrankNode.MoveOperationId = GenerateOperationID( XmlDiffDescriptorType.Move );

                    parent.InsertAtBeginning( new DiffgramCopy( shrankNode.MatchingShrankNode, true, shrankNode.MoveOperationId ) );
                    break;

                case XmlDiffNodeType.XmlDeclaration:
                case XmlDiffNodeType.DocumentType:
                case XmlDiffNodeType.EntityReference:
                    parent.InsertAtBeginning( new DiffgramAddNode( targetRoot, 0 ) );
                    break;

                default:
                    if ( !parent.MergeAddSubtreeAtBeginning( targetRoot ) )
                    {
                        parent.InsertAtBeginning( new DiffgramAddSubtrees( targetRoot, 0, !_xmlDiff.IgnoreChildOrder ) );
                    }
                    break;
            }
            // adjust current position
            _curTargetIndex = targetRoot.Left - 1;

            // adjust boundaries in the edit script or move to next edit script operation
            addOp._endTargetIndex = targetRoot.Left - 1;
            if ( addOp._startTargetIndex > addOp._endTargetIndex )
                _editScript = _editScript._nextEditScript;
            }
            // add single but non-leaf node, or some descendant matches (= has been moved from somewhere else )
            // -> recursively process diffgram subtree
            else
            {
            Debug.Assert( !( targetRoot is XmlDiffShrankNode) );
            DiffgramAddNode addNode = new DiffgramAddNode( targetRoot, 0 );

            // adjust current position
            _curTargetIndex--;

            // adjust boundaries in the edit script or move to next edit script operation
            addOp._endTargetIndex--;
            if ( addOp._startTargetIndex > addOp._endTargetIndex )
                _editScript = _editScript._nextEditScript;

            if ( _bBuildingAddTree )
            {
                GenerateDiffgramAdd( addNode, sourceBorderIndex, targetRoot.Left );
            }
            else
            {
                // switch to 'building add-tree' mode
                _postponedEditScript.Reset();
                _bBuildingAddTree = true;

                // generate new tree
                GenerateDiffgramAdd( addNode, sourceBorderIndex, targetRoot.Left );

                _bBuildingAddTree = false;

                // attach postponed edit script to _editScript for futher processing
                if ( _postponedEditScript._firstES != null )
                {
                    Debug.Assert( _postponedEditScript._lastES != null );
                    Debug.Assert( _postponedEditScript._startSourceIndex != 0 );
                    Debug.Assert( _postponedEditScript._endSourceIndex != 0 );
                    _curSourceIndex = _postponedEditScript._endSourceIndex;
                    _postponedEditScript._lastES._nextEditScript = _editScript;
                    _editScript = _postponedEditScript._firstES;
                }
            }

            // add attributes
            if ( targetRoot.NodeType == XmlDiffNodeType.Element )
                GenerateAddDiffgramForAttributes( addNode, (XmlDiffElement)targetRoot );

            parent.InsertAtBeginning( addNode );
            }

            // return true if positioning <node> element is needed in diffgram
            if ( _bChildOrderSignificant ) {
            return !_bBuildingAddTree;
            }
            else {
            return false;
            }
        }
Exemplo n.º 17
0
// Constructor
    internal EditScriptMatchOpened( int startSourceIndex, int startTargetIndex, EditScript next )
        : base ( next )
    {
        Debug.Assert( startSourceIndex > 0 );
        Debug.Assert( startTargetIndex > 0 );

        _startSourceIndex = startSourceIndex;
        _startTargetIndex = startTargetIndex;
    }
Exemplo n.º 18
0
        void OnEditScriptPostponed( DiffgramParentOperation parent, int targetBorderIndex )
        {
            EditScriptPostponed esp = (EditScriptPostponed)_editScript;
            Debug.Assert( _curSourceIndex == esp._endSourceIndex );

            DiffgramOperation diffOp = esp._diffOperation;
            int sourceStartIndex = esp._startSourceIndex;
            int sourceLeft = _sourceNodes[ esp._endSourceIndex ].Left;

            // adjust current source index
            _curSourceIndex = esp._startSourceIndex - 1;

            // move to next edit script
            _editScript = esp._nextEditScript;

            // not a subtree or leaf node operation -> process child operations
            if ( sourceStartIndex > sourceLeft ) {
            GenerateDiffgramPostponed( (DiffgramParentOperation)diffOp, ref _editScript, sourceLeft, targetBorderIndex );
            }

            parent.InsertAtBeginning( diffOp );
        }
Exemplo n.º 19
0
// Constructor
    internal EditScriptAddOpened( int startTargetIndex, EditScript next )
        : base ( next )
    {
        Debug.Assert( startTargetIndex > 0 );
        _startTargetIndex = startTargetIndex;
    }
Exemplo n.º 20
0
        // Methods
        internal Diffgram GenerateFromEditScript( EditScript editScript )
        {
            Debug.Assert( editScript != null );

            Debug.Assert( _xmlDiff._sourceNodes != null );
            Debug.Assert( _xmlDiff._targetNodes != null );
            _sourceNodes = _xmlDiff._sourceNodes;
            _targetNodes = _xmlDiff._targetNodes;

            Diffgram diffgram = new Diffgram( _xmlDiff );

            // root nodes always match; remove them from the edit script
            EditScriptMatch esm = editScript as EditScriptMatch;
            if ( editScript.Operation == EditScriptOperation.Match  &&
             ( esm._firstSourceIndex + esm._length == _sourceNodes.Length  &&
               esm._firstTargetIndex + esm._length == _targetNodes.Length ) )
            {
            esm._length--;
            if ( esm._length == 0 )
                editScript = esm._nextEditScript;
            }
            else
            Debug.Assert( false, "The root nodes does not match!" );

            // init globals
            _curSourceIndex = _sourceNodes.Length - 2;
            _curTargetIndex = _targetNodes.Length - 2;
            _editScript = editScript;

            // generate diffgram
            GenerateDiffgramMatch( diffgram, 1, 1 );

            // add descriptors
            AppendDescriptors( diffgram );

            return diffgram;
        }
Exemplo n.º 21
0
// Constructor
    internal EditScriptRemoveOpened( int startSourceIndex, EditScript next )
        : base ( next )
    {
        Debug.Assert( startSourceIndex > 0 );
        _startSourceIndex = startSourceIndex;
    }
Exemplo n.º 22
0
        // Static methods
        // This method expands 'reference edit script' items and removes the last item
        // (which is the static instance of EmptyEditScript).
        private static EditScript NormalizeScript( EditScript es )
        {
            EditScript returnES = es;
            EditScript curES = es;
            EditScript prevES = null;

            while ( curES != EmptyEditScript )
            {
            Debug.Assert( curES != null );

            if ( curES.Operation != EditScriptOperation.EditScriptReference )
            {
                prevES = curES;
                curES = curES._nextEditScript;
            }
            else
            {
                EditScriptReference refES = curES as EditScriptReference;

                EditScript lastES = refES._editScriptReference;
                Debug.Assert( lastES != EmptyEditScript  && lastES != null );
                while ( lastES.Next != EmptyEditScript )
                {
                    lastES = lastES._nextEditScript;
                    Debug.Assert( lastES != null );
                }

                lastES._nextEditScript = curES._nextEditScript;
                curES = refES._editScriptReference;

                if ( prevES == null )
                    returnES = curES;
                else
                    prevES._nextEditScript = curES;
            }
            }

            if ( prevES != null )
            prevES._nextEditScript = null;
            else
            returnES = null;

            return returnES;
        }
Exemplo n.º 23
0
// Constructor
        internal EditScriptChange(int sourceIndex, int targetIndex, XmlDiffOperation changeOp, EditScript next)
            : base(next)
        {
            Debug.Assert(sourceIndex > 0);
            Debug.Assert(targetIndex > 0);
            Debug.Assert(XmlDiff.IsChangeOperation(changeOp));

            _sourceIndex = sourceIndex;
            _targetIndex = targetIndex;
            _changeOp    = changeOp;
        }