Modifier and Type	Class and Description
public static enum	DiffAlgorithm.SupportedAlgorithm Supported diff algorithm

Access	Constructor and Description
public	DiffAlgorithm()

Method Summary

Modifier and Type	Method and Description
private static <S extends Sequence> Edit	coverEdit(S a, S b)
public < type of sequence being compared. S extends Sequence> EditList	Returns: a modifiable edit list comparing the two sequences. If empty, the sequences are identical according to `cmp`'s rules. The result list is never null. diff(SequenceComparator<? super S> the comparator supplying the element equivalence function. cmp, S the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: `org.eclipse.jgit.diff.Edit#getBeginA()`, `org.eclipse.jgit.diff.Edit#getEndA()`. a, S the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: `org.eclipse.jgit.diff.Edit#getBeginB()`, `org.eclipse.jgit.diff.Edit#getEndB()`. b) Compare two sequences and identify a list of edits between them.
public abstract < type of sequence being compared. S extends Sequence> EditList	Returns: a modifiable edit list comparing the two sequences. diffNonCommon(SequenceComparator<? super S> the comparator supplying the element equivalence function. cmp, S the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: `org.eclipse.jgit.diff.Edit#getBeginA()`, `org.eclipse.jgit.diff.Edit#getEndA()`. a, S the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: `org.eclipse.jgit.diff.Edit#getBeginB()`, `org.eclipse.jgit.diff.Edit#getEndB()`. b) Compare two sequences and identify a list of edits between them.
public static DiffAlgorithm	Returns: an implementation of the specified diff algorithm getAlgorithm(DiffAlgorithm.SupportedAlgorithm the diff algorithm for which an implementation should be returned alg) Get diff algorithm
private static < type of sequence being compared. S extends Sequence> EditList	Returns: a modifiable edit list with edit regions shifted to their latest possible location. The result list is never null. normalize(SequenceComparator<? super S> the comparator supplying the element equivalence function. cmp, EditList a modifiable edit list comparing the provided sequences. e, S the first (also known as old or pre-image) sequence. a, S the second (also known as new or post-image) sequence. b) Reorganize an `EditList` for better diff consistency.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Constructor Detail

DiffAlgorithm	back to summary
public DiffAlgorithm()

Method Detail

coverEdit	back to summary
private static <S extends Sequence> Edit coverEdit(S a, S b)

diff back to summary

diff	back to summary
public <S extends Sequence> EditList diff(SequenceComparator<? super S> cmp, S a, S b) Compare two sequences and identify a list of edits between them. Parameters <S> type of sequence being compared. cmp:SequenceComparator<? super S> the comparator supplying the element equivalence function. a:S the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: `org.eclipse.jgit.diff.Edit#getBeginA()`, `org.eclipse.jgit.diff.Edit#getEndA()`. b:S the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: `org.eclipse.jgit.diff.Edit#getBeginB()`, `org.eclipse.jgit.diff.Edit#getEndB()`. Returns:EditList a modifiable edit list comparing the two sequences. If empty, the sequences are identical according to `cmp`'s rules. The result list is never null.

public <S extends Sequence> EditList diff(SequenceComparator<? super S> cmp, S a, S b)

Compare two sequences and identify a list of edits between them.

Parameters

<S>: type of sequence being compared.
cmp:SequenceComparator<? super S>: the comparator supplying the element equivalence function.
a:S: the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: org.eclipse.jgit.diff.Edit#getBeginA(), org.eclipse.jgit.diff.Edit#getEndA().
b:S: the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: org.eclipse.jgit.diff.Edit#getBeginB(), org.eclipse.jgit.diff.Edit#getEndB().

Returns:EditList

a modifiable edit list comparing the two sequences. If empty, the sequences are identical according to cmp's rules. The result list is never null.

diffNonCommon back to summary

diffNonCommon	back to summary
public abstract <S extends Sequence> EditList diffNonCommon(SequenceComparator<? super S> cmp, S a, S b) 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 `diff(SequenceComparator, Sequence, Sequence)` method, which invokes this method using `org.eclipse.jgit.diff.Subsequence`s. Parameters <S> type of sequence being compared. cmp:SequenceComparator<? super S> the comparator supplying the element equivalence function. a:S the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: `org.eclipse.jgit.diff.Edit#getBeginA()`, `org.eclipse.jgit.diff.Edit#getEndA()`. b:S the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: `org.eclipse.jgit.diff.Edit#getBeginB()`, `org.eclipse.jgit.diff.Edit#getEndB()`. Returns:EditList a modifiable edit list comparing the two sequences.

public abstract <S extends Sequence> EditList diffNonCommon(SequenceComparator<? super S> cmp, S a, S b)

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 diff(SequenceComparator, Sequence, Sequence) method, which invokes this method using org.eclipse.jgit.diff.Subsequences.

Parameters

<S>: type of sequence being compared.
cmp:SequenceComparator<? super S>: the comparator supplying the element equivalence function.
a:S: the first (also known as old or pre-image) sequence. Edits returned by this algorithm will reference indexes using the 'A' side: org.eclipse.jgit.diff.Edit#getBeginA(), org.eclipse.jgit.diff.Edit#getEndA().
b:S: the second (also known as new or post-image) sequence. Edits returned by this algorithm will reference indexes using the 'B' side: org.eclipse.jgit.diff.Edit#getBeginB(), org.eclipse.jgit.diff.Edit#getEndB().

Returns:EditList

a modifiable edit list comparing the two sequences.

getAlgorithm	back to summary
public static DiffAlgorithm getAlgorithm(DiffAlgorithm.SupportedAlgorithm alg) Get diff algorithm Parameters alg:DiffAlgorithm.SupportedAlgorithm the diff algorithm for which an implementation should be returned Returns:DiffAlgorithm an implementation of the specified diff algorithm

getAlgorithm

back to summary

public static DiffAlgorithm getAlgorithm(DiffAlgorithm.SupportedAlgorithm alg)

Get diff algorithm

Parameters

alg:DiffAlgorithm.SupportedAlgorithm: the diff algorithm for which an implementation should be returned

Returns:DiffAlgorithm

an implementation of the specified diff algorithm

normalize back to summary

normalize	back to summary
private static <S extends Sequence> EditList normalize(SequenceComparator<? super S> cmp, EditList e, S a, S b) Reorganize an `EditList` for better diff consistency. `DiffAlgorithms` may return `Edit.Type#INSERT` or `Edit.Type#DELETE` edits that can be "shifted". For example, the deleted section -a -b -c a b c can be shifted down by 1, 2 or 3 locations. To avoid later merge issues, we shift such edits to a consistent location. `normalize` uses a simple strategy of shifting such edits to their latest possible location. This strategy may not always produce an aesthetically pleasing diff. For instance, it works well with function1 { ... } +function2 { + ... +} + function3 { ... } but less so for # # comment1 # function1() { } # +# comment3 +# +function3() { +} + +# # comment2 # function2() { } More sophisticated strategies are possible, say by calculating a suitable "aesthetic cost" for each possible position and using the lowest cost, but `normalize` just shifts edits to the end as much as possible. Parameters <S> type of sequence being compared. cmp:SequenceComparator<? super S> the comparator supplying the element equivalence function. e:EditList a modifiable edit list comparing the provided sequences. a:S the first (also known as old or pre-image) sequence. b:S the second (also known as new or post-image) sequence. Returns:EditList a modifiable edit list with edit regions shifted to their latest possible location. The result list is never null. Since 4.7

private static <S extends Sequence> EditList normalize(SequenceComparator<? super S> cmp, EditList e, S a, S b)

Reorganize an EditList for better diff consistency.

DiffAlgorithms may return Edit.Type#INSERT or Edit.Type#DELETE edits that can be "shifted". For example, the deleted section

-a
-b
-c
 a
 b
 c

can be shifted down by 1, 2 or 3 locations.

To avoid later merge issues, we shift such edits to a consistent location. normalize uses a simple strategy of shifting such edits to their latest possible location.

This strategy may not always produce an aesthetically pleasing diff. For instance, it works well with

 function1 {
  ...
 }

+function2 {
+ ...
+}
+
function3 {
...
}

but less so for

 #
 # comment1
 #
 function1() {
 }

 #
+# comment3
+#
+function3() {
+}
+
+#
 # comment2
 #
 function2() {
 }

More sophisticated strategies are possible, say by calculating a suitable "aesthetic cost" for each possible position and using the lowest cost, but normalize just shifts edits to the end as much as possible.

Parameters

<S>: type of sequence being compared.
cmp:SequenceComparator<? super S>: the comparator supplying the element equivalence function.
e:EditList: a modifiable edit list comparing the provided sequences.
a:S: the first (also known as old or pre-image) sequence.
b:S: the second (also known as new or post-image) sequence.

Returns:EditList

a modifiable edit list with edit regions shifted to their latest possible location. The result list is never null.

Since

4.7

org.eclipse.jgit.diff back to summary

public final Enum DiffAlgorithm.SupportedAlgorithm

Class Inheritance

extends Enum<DiffAlgorithm.SupportedAlgorithm>

java.lang.Object
java.lang.Enum
org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm

Supported diff algorithm

Field Summary

Modifier and Type	Field and Description
public static final DiffAlgorithm.SupportedAlgorithm	HISTOGRAM Histogram diff algorithm
public static final DiffAlgorithm.SupportedAlgorithm	MYERS Myers diff algorithm

Constructor Summary

Access	Constructor and Description
private	SupportedAlgorithm()

Method Summary

Modifier and Type	Method and Description
public static DiffAlgorithm.SupportedAlgorithm	valueOf(String name)
public static DiffAlgorithm.SupportedAlgorithm[]	values()

Inherited from java.lang.Enum:: clone compareTo describeConstable equals finalize getDeclaringClass hashCode name ordinal toString valueOf

Field Detail

HISTOGRAM	back to summary
public static final DiffAlgorithm.SupportedAlgorithm HISTOGRAM Histogram diff algorithm

MYERS	back to summary
public static final DiffAlgorithm.SupportedAlgorithm MYERS Myers diff algorithm

Constructor Detail

SupportedAlgorithm	back to summary
private SupportedAlgorithm()

Method Detail

valueOf	back to summary
public static DiffAlgorithm.SupportedAlgorithm valueOf(String name)

values	back to summary
public static DiffAlgorithm.SupportedAlgorithm[] values()

public abstract Class DiffAlgorithm

Nested and Inner Type Summary

Constructor Summary

Method Summary

Constructor Detail

Method Detail

public final Enum DiffAlgorithm.SupportedAlgorithm

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail