com.github.difflib

Class DiffUtils

java.lang.Object

com.github.difflib.DiffUtils

public final class DiffUtils
extends Object

Utility class to implement the difference and patching engine.

Method Summary

Modifier and Type	Method and Description
static <T> Patch<T>	diff(List<T> original, List<T> revised) Computes the difference between two sequences of elements using the default diff algorithm.
static <T> Patch<T>	diff(List<T> source, List<T> target, BiPredicate<T,T> equalizer) Computes the difference between the original and revised list of elements with default diff algorithm
static <T> Patch<T>	diff(List<T> original, List<T> revised, boolean includeEqualParts) Computes the difference between two sequences of elements using the default diff algorithm.
static <T> Patch<T>	diff(List<T> original, List<T> revised, DiffAlgorithmI<T> algorithm) Computes the difference between the original and revised list of elements with default diff algorithm
static <T> Patch<T>	diff(List<T> original, List<T> revised, DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress)
static <T> Patch<T>	diff(List<T> original, List<T> revised, DiffAlgorithmI<T> algorithm, DiffAlgorithmListener progress, boolean includeEqualParts) Computes the difference between the original and revised list of elements with default diff algorithm
static <T> Patch<T>	diff(List<T> original, List<T> revised, DiffAlgorithmListener progress) Computes the difference between two sequences of elements using the default diff algorithm.
static Patch<String>	diff(String sourceText, String targetText, DiffAlgorithmListener progress) Computes the difference between two strings using the default diff algorithm.
static Patch<String>	diffInline(String original, String revised) Computes the difference between the given texts inline.
static <T> List<T>	patch(List<T> original, Patch<T> patch) Applies the given patch to the original list and returns the revised list.
static <T> List<T>	unpatch(List<T> revised, Patch<T> patch) Applies the given patch to the revised list and returns the original list.
static void	withDefaultDiffAlgorithmFactory(DiffAlgorithmFactory factory) Sets the default diff algorithm factory to be used by all diff routines.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

withDefaultDiffAlgorithmFactory

public static void withDefaultDiffAlgorithmFactory(DiffAlgorithmFactory factory)

Sets the default diff algorithm factory to be used by all diff routines.

Parameters:

factory - a DiffAlgorithmFactory representing the new default diff algorithm factory.

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised,
                                DiffAlgorithmListener progress)

Computes the difference between two sequences of elements using the default diff algorithm.

Type Parameters:

T - a generic representing the type of the elements to be compared.

Parameters:

original - a List representing the original sequence of elements. Must not be null.

revised - a List representing the revised sequence of elements. Must not be null.

progress - a DiffAlgorithmListener representing the progress listener. Can be null.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised)

Computes the difference between two sequences of elements using the default diff algorithm.

Type Parameters:

T - a generic representing the type of the elements to be compared.

Parameters:

original - a List representing the original sequence of elements. Must not be null.

revised - a List representing the revised sequence of elements. Must not be null.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised,
                                boolean includeEqualParts)

Computes the difference between two sequences of elements using the default diff algorithm.

Type Parameters:

T - a generic representing the type of the elements to be compared.

Parameters:

original - a List representing the original sequence of elements. Must not be null.

revised - a List representing the revised sequence of elements. Must not be null.

includeEqualParts - a boolean representing whether to include equal parts in the resulting patch.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diff

public static Patch<String> diff(String sourceText,
                                 String targetText,
                                 DiffAlgorithmListener progress)

Computes the difference between two strings using the default diff algorithm.

Parameters:

sourceText - a String representing the original string. Must not be null.

targetText - a String representing the revised string. Must not be null.

progress - a DiffAlgorithmListener representing the progress listener. Can be null.

Returns:

The patch describing the difference between the original and revised strings. Never null.

diff

public static <T> Patch<T> diff(List<T> source,
                                List<T> target,
                                BiPredicate<T,T> equalizer)

Computes the difference between the original and revised list of elements with default diff algorithm

Parameters:

source - a List representing the original text. Must not be null.

target - a List representing the revised text. Must not be null.

equalizer - a BiPredicate representing the equalizer object to replace the default compare algorithm (Object.equals). If null the default equalizer of the default algorithm is used.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised,
                                DiffAlgorithmI<T> algorithm,
                                DiffAlgorithmListener progress)

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised,
                                DiffAlgorithmI<T> algorithm,
                                DiffAlgorithmListener progress,
                                boolean includeEqualParts)

Computes the difference between the original and revised list of elements with default diff algorithm

Parameters:

original - a List representing the original text. Must not be null.

revised - a List representing the revised text. Must not be null.

algorithm - a DiffAlgorithmI representing the diff algorithm. Must not be null.

progress - a DiffAlgorithmListener representing the diff algorithm listener.

includeEqualParts - Include equal data parts into the patch.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diff

public static <T> Patch<T> diff(List<T> original,
                                List<T> revised,
                                DiffAlgorithmI<T> algorithm)

Computes the difference between the original and revised list of elements with default diff algorithm

Parameters:

original - a List representing the original text. Must not be null.

revised - a List representing the revised text. Must not be null.

algorithm - a DiffAlgorithmI representing the diff algorithm. Must not be null.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

diffInline

public static Patch<String> diffInline(String original,
                                       String revised)

Computes the difference between the given texts inline. This one uses the "trick" to make out of texts lists of characters, like DiffRowGenerator does and merges those changes at the end together again.

Parameters:

original - a String representing the original text. Must not be null.

revised - a String representing the revised text. Must not be null.

Returns:

The patch describing the difference between the original and revised sequences. Never null.

patch

public static <T> List<T> patch(List<T> original,
                                Patch<T> patch)
                         throws PatchFailedException

Applies the given patch to the original list and returns the revised list.

Parameters:

original - a List representing the original list.

patch - a List representing the patch to apply.

Returns:

the revised list.

Throws:

PatchFailedException - if the patch cannot be applied.

unpatch

public static <T> List<T> unpatch(List<T> revised,
                                  Patch<T> patch)

Applies the given patch to the revised list and returns the original list.

Parameters:

revised - a List representing the revised list.

patch - a Patch representing the patch to apply.

Returns:

the original list.

Throws:

PatchFailedException - if the patch cannot be applied.