Esempio n. 1
0
        /// <summary>Compare two sequences and identify a list of edits between them.</summary>
        /// <remarks>Compare two sequences and identify a list of edits between them.</remarks>
        /// <?></?>
        /// <param name="cmp">the comparator supplying the element equivalence function.</param>
        /// <param name="a">
        /// the first (also known as old or pre-image) sequence. Edits
        /// returned by this algorithm will reference indexes using the
        /// 'A' side:
        /// <see cref="Edit.GetBeginA()">Edit.GetBeginA()</see>
        /// ,
        /// <see cref="Edit.GetEndA()">Edit.GetEndA()</see>
        /// .
        /// </param>
        /// <param name="b">
        /// the second (also known as new or post-image) sequence. Edits
        /// returned by this algorithm will reference indexes using the
        /// 'B' side:
        /// <see cref="Edit.GetBeginB()">Edit.GetBeginB()</see>
        /// ,
        /// <see cref="Edit.GetEndB()">Edit.GetEndB()</see>
        /// .
        /// </param>
        /// <returns>
        /// a modifiable edit list comparing the two sequences. If empty, the
        /// sequences are identical according to
        /// <code>cmp</code>
        /// 's rules. The
        /// result list is never null.
        /// </returns>
        public virtual EditList Diff <S>(SequenceComparator <S> cmp, S a, S b) where
        S : Sequence
        {
            Edit region = cmp.ReduceCommonStartEnd(a, b, CoverEdit(a, b));

            switch (region.GetType())
            {
            case Edit.Type.INSERT:
            case Edit.Type.DELETE:
            {
                return(EditList.Singleton(region));
            }

            case Edit.Type.REPLACE:
            {
                SubsequenceComparator <S> cs  = new SubsequenceComparator <S>(cmp);
                Subsequence <S>           @as = Subsequence <S> .A(a, region);

                Subsequence <S> bs = Subsequence <S> .B(b, region);

                EditList e = Subsequence <S> .ToBase(DiffNonCommon(cs, @as, bs), @as, bs);

                // The last insertion may need to be shifted later if it
                // inserts elements that were previously reduced out as
                // common at the end.
                //
                Edit last = e[e.Count - 1];
                if (last.GetType() == Edit.Type.INSERT)
                {
                    while (last.endB < b.Size() && cmp.Equals(b, last.beginB, b, last.endB))
                    {
                        last.beginA++;
                        last.endA++;
                        last.beginB++;
                        last.endB++;
                    }
                }
                return(e);
            }

            case Edit.Type.EMPTY:
            {
                return(new EditList(0));
            }

            default:
            {
                throw new InvalidOperationException();
            }
            }
        }
        public override EditList DiffNonCommon <S>(SequenceComparator <S> cmp, S a,
                                                   S b)
        {
            HashedSequencePair <S>       p  = new HashedSequencePair <S>(cmp, a, b);
            HashedSequenceComparator <S> hc = p.GetComparator();
            HashedSequence <S>           ha = p.GetA();
            HashedSequence <S>           hb = p.GetB();

            p = null;
            EditList res    = new EditList();
            Edit     region = new Edit(0, a.Size(), 0, b.Size());

            DiffNonCommon(res, hc, ha, hb, region);
            return(res);
        }
Esempio n. 3
0
 /// <summary>Construct a comparator wrapping another comparator.</summary>
 /// <remarks>Construct a comparator wrapping another comparator.</remarks>
 /// <param name="cmp">the real comparator.</param>
 public SubsequenceComparator(SequenceComparator <S> cmp)
 {
     this.cmp = cmp;
 }
Esempio n. 4
0
 /// <summary>Compare two sequences and identify a list of edits between them.</summary>
 /// <remarks>
 /// Compare two sequences and identify a list of edits between them.
 /// This method should be invoked only after the two sequences have been
 /// proven to have no common starting or ending elements. The expected
 /// elimination of common starting and ending elements is automatically
 /// performed by the
 /// <see cref="Diff{S}(SequenceComparator{S}, Sequence, Sequence)">Diff&lt;S&gt;(SequenceComparator&lt;S&gt;, Sequence, Sequence)
 ///     </see>
 /// method, which invokes this method using
 /// <see cref="Subsequence{S}">Subsequence&lt;S&gt;</see>
 /// s.
 /// </remarks>
 /// <?></?>
 /// <param name="cmp">the comparator supplying the element equivalence function.</param>
 /// <param name="a">
 /// the first (also known as old or pre-image) sequence. Edits
 /// returned by this algorithm will reference indexes using the
 /// 'A' side:
 /// <see cref="Edit.GetBeginA()">Edit.GetBeginA()</see>
 /// ,
 /// <see cref="Edit.GetEndA()">Edit.GetEndA()</see>
 /// .
 /// </param>
 /// <param name="b">
 /// the second (also known as new or post-image) sequence. Edits
 /// returned by this algorithm will reference indexes using the
 /// 'B' side:
 /// <see cref="Edit.GetBeginB()">Edit.GetBeginB()</see>
 /// ,
 /// <see cref="Edit.GetEndB()">Edit.GetEndB()</see>
 /// .
 /// </param>
 /// <returns>a modifiable edit list comparing the two sequences.</returns>
 public abstract EditList DiffNonCommon <S>(SequenceComparator <S> cmp, S a,
                                            S b) where S : Sequence;
Esempio n. 5
0
 /// <summary>Construct a pair to provide fast hash codes.</summary>
 /// <remarks>Construct a pair to provide fast hash codes.</remarks>
 /// <param name="cmp">the base comparator for the sequence elements.</param>
 /// <param name="a">the A sequence.</param>
 /// <param name="b">the B sequence.</param>
 public HashedSequencePair(SequenceComparator <S> cmp, S a, S b)
 {
     this.cmp   = cmp;
     this.baseA = a;
     this.baseB = b;
 }
 internal HashedSequenceComparator(SequenceComparator <S> cmp)
 {
     this.cmp = cmp;
 }