/// <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);
}
/// <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;
}
/// <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<S>(SequenceComparator<S>, Sequence, Sequence)
/// </see>
/// method, which invokes this method using
/// <see cref="Subsequence{S}">Subsequence<S></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;
/// <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;
}