/// <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 bool Equals(Subsequence <S> a, int ai, Subsequence <S> b, int bi)
{
return(cmp.Equals(a.@base, ai + a.begin, b.@base, bi + b.begin));
}
public override bool Equals(HashedSequence <S> a, int ai, HashedSequence <S> b, int
bi)
{
//
return(a.hashes[ai] == b.hashes[bi] && cmp.Equals(a.@base, ai, b.@base, bi));
}