com.wantedtech.common.xpresso.strings

Class diff_match_patch

java.lang.Object

com.wantedtech.common.xpresso.strings.diff_match_patch

public class diff_match_patch
extends java.lang.Object

Class containing the diff, match and patch methods. Also contains the behaviour settings.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	diff_match_patch.Diff Class representing one diff operation.
static class	diff_match_patch.Operation The data structure representing a diff is a Linked list of Diff objects: {Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"), Diff(Operation.EQUAL, " world.")} which means: delete "Hello", add "Goodbye" and keep " world."
static class	diff_match_patch.Patch Class representing one patch operation.

Field Summary

Fields

Modifier and Type	Field and Description
short	Diff_EditCost Cost of an empty edit operation in terms of edit characters.
float	Diff_Timeout Number of seconds to map a diff before giving up (0 for infinity).
int	Match_Distance How far to search for a match (0 = exact location, 1000+ = broad match).
float	Match_Threshold At what point is no match declared (0.0 = perfection, 1.0 = very loose).
float	Patch_DeleteThreshold When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents.
short	Patch_Margin Chunk size for context length.

Constructor Summary

Constructors

Constructor and Description
diff_match_patch()

Method Summary

Modifier and Type	Method and Description
void	diff_cleanupEfficiency(java.util.LinkedList<diff_match_patch.Diff> diffs) Reduce the number of edits by eliminating operationally trivial equalities.
void	diff_cleanupMerge(java.util.LinkedList<diff_match_patch.Diff> diffs) Reorder and merge like edit sections.
void	diff_cleanupSemantic(java.util.LinkedList<diff_match_patch.Diff> diffs) Reduce the number of edits by eliminating semantically trivial equalities.
void	diff_cleanupSemanticLossless(java.util.LinkedList<diff_match_patch.Diff> diffs) Look for single edits surrounded on both sides by equalities which can be shifted sideways to align the edit to a word boundary.
int	diff_commonPrefix(java.lang.String text1, java.lang.String text2) Determine the common prefix of two strings
int	diff_commonSuffix(java.lang.String text1, java.lang.String text2) Determine the common suffix of two strings
java.util.LinkedList<diff_match_patch.Diff>	diff_fromDelta(java.lang.String text1, java.lang.String delta) Given the original text1, and an encoded string which describes the operations required to transform text1 into text2, compute the full diff.
int	diff_levenshtein(java.util.LinkedList<diff_match_patch.Diff> diffs) Compute the Levenshtein distance; the number of inserted, deleted or substituted characters.
java.util.LinkedList<diff_match_patch.Diff>	diff_main(java.lang.String text1, java.lang.String text2) Find the differences between two texts.
java.util.LinkedList<diff_match_patch.Diff>	diff_main(java.lang.String text1, java.lang.String text2, boolean checklines) Find the differences between two texts.
java.lang.String	diff_prettyHtml(java.util.LinkedList<diff_match_patch.Diff> diffs) Convert a Diff list into a pretty HTML report.
java.lang.String	diff_text1(java.util.LinkedList<diff_match_patch.Diff> diffs) Compute and return the source text (all equalities and deletions).
java.lang.String	diff_text2(java.util.LinkedList<diff_match_patch.Diff> diffs) Compute and return the destination text (all equalities and insertions).
java.lang.String	diff_toDelta(java.util.LinkedList<diff_match_patch.Diff> diffs) Crush the diff into an encoded string which describes the operations required to transform text1 into text2.
int	diff_xIndex(java.util.LinkedList<diff_match_patch.Diff> diffs, int loc) loc is a location in text1, compute and return the equivalent location in text2.
int	match_main(java.lang.String text, java.lang.String pattern, int loc) Locate the best instance of 'pattern' in 'text' near 'loc'.
java.lang.String	patch_addPadding(java.util.LinkedList<diff_match_patch.Patch> patches) Add some padding on text start and end so that edges can match something.
java.lang.Object[]	patch_apply(java.util.LinkedList<diff_match_patch.Patch> patches, java.lang.String text) Merge a set of patches onto the text.
java.util.LinkedList<diff_match_patch.Patch>	patch_deepCopy(java.util.LinkedList<diff_match_patch.Patch> patches) Given an array of patches, return another array that is identical.
java.util.List<diff_match_patch.Patch>	patch_fromText(java.lang.String textline) Parse a textual representation of patches and return a List of Patch objects.
java.util.LinkedList<diff_match_patch.Patch>	patch_make(java.util.LinkedList<diff_match_patch.Diff> diffs) Compute a list of patches to turn text1 into text2.
java.util.LinkedList<diff_match_patch.Patch>	patch_make(java.lang.String text1, java.util.LinkedList<diff_match_patch.Diff> diffs) Compute a list of patches to turn text1 into text2.
java.util.LinkedList<diff_match_patch.Patch>	patch_make(java.lang.String text1, java.lang.String text2) Compute a list of patches to turn text1 into text2.
java.util.LinkedList<diff_match_patch.Patch>	patch_make(java.lang.String text1, java.lang.String text2, java.util.LinkedList<diff_match_patch.Diff> diffs) Deprecated. Prefer patch_make(String text1, LinkedList<Diff> diffs).
void	patch_splitMax(java.util.LinkedList<diff_match_patch.Patch> patches) Look through the patches and break up any which are longer than the maximum limit of the match algorithm.
java.lang.String	patch_toText(java.util.List<diff_match_patch.Patch> patches) Take a list of patches and return a textual representation.

Methods inherited from class java.lang.Object

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

Field Detail

Diff_Timeout

public float Diff_Timeout

Number of seconds to map a diff before giving up (0 for infinity).

Diff_EditCost

public short Diff_EditCost

Cost of an empty edit operation in terms of edit characters.

Match_Threshold

public float Match_Threshold

At what point is no match declared (0.0 = perfection, 1.0 = very loose).

Match_Distance

public int Match_Distance

How far to search for a match (0 = exact location, 1000+ = broad match). A match this many characters away from the expected location will add 1.0 to the score (0.0 is a perfect match).

Patch_DeleteThreshold

public float Patch_DeleteThreshold

When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents. (0.0 = perfection, 1.0 = very loose). Note that Match_Threshold controls how closely the end points of a delete need to match.

Patch_Margin

public short Patch_Margin

Chunk size for context length.

Constructor Detail

diff_match_patch

public diff_match_patch()

Method Detail

diff_main

public java.util.LinkedList<diff_match_patch.Diff> diff_main(java.lang.String text1,
                                                             java.lang.String text2)

Find the differences between two texts. Run a faster, slightly less optimal diff. This method allows the 'checklines' of diff_main() to be optional. Most of the time checklines is wanted, so default to true.

Parameters:

text1 - Old string to be diffed.

text2 - New string to be diffed.

Returns:

Linked List of Diff objects.

diff_main

public java.util.LinkedList<diff_match_patch.Diff> diff_main(java.lang.String text1,
                                                             java.lang.String text2,
                                                             boolean checklines)

Find the differences between two texts.

Parameters:

text1 - Old string to be diffed.

text2 - New string to be diffed.

checklines - Speedup flag. If false, then don't run a line-level diff first to identify the changed areas. If true, then run a faster slightly less optimal diff.

Returns:

Linked List of Diff objects.

diff_commonPrefix

public int diff_commonPrefix(java.lang.String text1,
                             java.lang.String text2)

Determine the common prefix of two strings

Parameters:

text1 - First string.

text2 - Second string.

Returns:

The number of characters common to the start of each string.

diff_commonSuffix

public int diff_commonSuffix(java.lang.String text1,
                             java.lang.String text2)

Determine the common suffix of two strings

Parameters:

text1 - First string.

text2 - Second string.

Returns:

The number of characters common to the end of each string.

diff_cleanupSemantic

public void diff_cleanupSemantic(java.util.LinkedList<diff_match_patch.Diff> diffs)

Reduce the number of edits by eliminating semantically trivial equalities.

Parameters:

diffs - LinkedList of Diff objects.

diff_cleanupSemanticLossless

public void diff_cleanupSemanticLossless(java.util.LinkedList<diff_match_patch.Diff> diffs)

Look for single edits surrounded on both sides by equalities which can be shifted sideways to align the edit to a word boundary. e.g: The c

at c

ame. -> The

cat 

came.

Parameters:

diffs - LinkedList of Diff objects.

diff_cleanupEfficiency

public void diff_cleanupEfficiency(java.util.LinkedList<diff_match_patch.Diff> diffs)

Reduce the number of edits by eliminating operationally trivial equalities.

Parameters:

diffs - LinkedList of Diff objects.

diff_cleanupMerge

public void diff_cleanupMerge(java.util.LinkedList<diff_match_patch.Diff> diffs)

Reorder and merge like edit sections. Merge equalities. Any edit section can move as long as it doesn't cross an equality.

Parameters:

diffs - LinkedList of Diff objects.

diff_xIndex

public int diff_xIndex(java.util.LinkedList<diff_match_patch.Diff> diffs,
                       int loc)

loc is a location in text1, compute and return the equivalent location in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8

Parameters:

diffs - LinkedList of Diff objects.

loc - Location within text1.

Returns:

Location within text2.

diff_prettyHtml

public java.lang.String diff_prettyHtml(java.util.LinkedList<diff_match_patch.Diff> diffs)

Convert a Diff list into a pretty HTML report.

Parameters:

diffs - LinkedList of Diff objects.

Returns:

HTML representation.

diff_text1

public java.lang.String diff_text1(java.util.LinkedList<diff_match_patch.Diff> diffs)

Compute and return the source text (all equalities and deletions).

Parameters:

diffs - LinkedList of Diff objects.

Returns:

Source text.

diff_text2

public java.lang.String diff_text2(java.util.LinkedList<diff_match_patch.Diff> diffs)

Compute and return the destination text (all equalities and insertions).

Parameters:

diffs - LinkedList of Diff objects.

Returns:

Destination text.

diff_levenshtein

public int diff_levenshtein(java.util.LinkedList<diff_match_patch.Diff> diffs)

Compute the Levenshtein distance; the number of inserted, deleted or substituted characters.

Parameters:

diffs - LinkedList of Diff objects.

Returns:

Number of changes.

diff_toDelta

public java.lang.String diff_toDelta(java.util.LinkedList<diff_match_patch.Diff> diffs)

Crush the diff into an encoded string which describes the operations required to transform text1 into text2. E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. Operations are tab-separated. Inserted text is escaped using %xx notation.

Parameters:

diffs - Array of Diff objects.

Returns:

Delta text.

diff_fromDelta

public java.util.LinkedList<diff_match_patch.Diff> diff_fromDelta(java.lang.String text1,
                                                                  java.lang.String delta)
                                                           throws java.lang.IllegalArgumentException

Given the original text1, and an encoded string which describes the operations required to transform text1 into text2, compute the full diff.

Parameters:

text1 - Source string for the diff.

delta - Delta text.

Returns:

Array of Diff objects or null if invalid.

Throws:

java.lang.IllegalArgumentException - If invalid input.

match_main

public int match_main(java.lang.String text,
                      java.lang.String pattern,
                      int loc)

Locate the best instance of 'pattern' in 'text' near 'loc'. Returns -1 if no match found.

Parameters:

text - The text to search.

pattern - The pattern to search for.

loc - The location to search around.

Returns:

Best match index or -1.

patch_make

public java.util.LinkedList<diff_match_patch.Patch> patch_make(java.lang.String text1,
                                                               java.lang.String text2)

Compute a list of patches to turn text1 into text2. A set of diffs will be computed.

Parameters:

text1 - Old text.

text2 - New text.

Returns:

LinkedList of Patch objects.

patch_make

public java.util.LinkedList<diff_match_patch.Patch> patch_make(java.util.LinkedList<diff_match_patch.Diff> diffs)

Compute a list of patches to turn text1 into text2. text1 will be derived from the provided diffs.

Parameters:

diffs - Array of Diff objects for text1 to text2.

Returns:

LinkedList of Patch objects.

patch_make

public java.util.LinkedList<diff_match_patch.Patch> patch_make(java.lang.String text1,
                                                               java.lang.String text2,
                                                               java.util.LinkedList<diff_match_patch.Diff> diffs)

Deprecated. Prefer patch_make(String text1, LinkedList<Diff> diffs).

Compute a list of patches to turn text1 into text2. text2 is ignored, diffs are the delta between text1 and text2.

Parameters:

text1 - Old text

text2 - Ignored.

diffs - Array of Diff objects for text1 to text2.

Returns:

LinkedList of Patch objects.

patch_make

public java.util.LinkedList<diff_match_patch.Patch> patch_make(java.lang.String text1,
                                                               java.util.LinkedList<diff_match_patch.Diff> diffs)

Compute a list of patches to turn text1 into text2. text2 is not provided, diffs are the delta between text1 and text2.

Parameters:

text1 - Old text.

diffs - Array of Diff objects for text1 to text2.

Returns:

LinkedList of Patch objects.

patch_deepCopy

public java.util.LinkedList<diff_match_patch.Patch> patch_deepCopy(java.util.LinkedList<diff_match_patch.Patch> patches)

Given an array of patches, return another array that is identical.

Parameters:

patches - Array of Patch objects.

Returns:

Array of Patch objects.

patch_apply

public java.lang.Object[] patch_apply(java.util.LinkedList<diff_match_patch.Patch> patches,
                                      java.lang.String text)

Merge a set of patches onto the text. Return a patched text, as well as an array of true/false values indicating which patches were applied.

Parameters:

patches - Array of Patch objects

text - Old text.

Returns:

Two element Object array, containing the new text and an array of boolean values.

patch_addPadding

public java.lang.String patch_addPadding(java.util.LinkedList<diff_match_patch.Patch> patches)

Add some padding on text start and end so that edges can match something. Intended to be called only from within patch_apply.

Parameters:

patches - Array of Patch objects.

Returns:

The padding string added to each side.

patch_splitMax

public void patch_splitMax(java.util.LinkedList<diff_match_patch.Patch> patches)

Look through the patches and break up any which are longer than the maximum limit of the match algorithm. Intended to be called only from within patch_apply.

Parameters:

patches - LinkedList of Patch objects.

patch_toText

public java.lang.String patch_toText(java.util.List<diff_match_patch.Patch> patches)

Take a list of patches and return a textual representation.

Parameters:

patches - List of Patch objects.

Returns:

Text representation of patches.

patch_fromText

public java.util.List<diff_match_patch.Patch> patch_fromText(java.lang.String textline)
                                                      throws java.lang.IllegalArgumentException

Parse a textual representation of patches and return a List of Patch objects.

Parameters:

textline - Text representation of patches.

Returns:

List of Patch objects.

Throws:

java.lang.IllegalArgumentException - If invalid input.