DiffMatchPatch (Jahia Server Implementation 8.0.0.0 API)

java.lang.Object
- name.fraser.neil.plaintext.DiffMatchPatch

```
public class DiffMatchPatch
extends 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`	`DiffMatchPatch.Diff` Class representing one diff operation.
`static class`	`DiffMatchPatch.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`	`DiffMatchPatch.Patch` Class representing one patch operation.

Field Summary

Fields
Modifier and Type	Field and Description
`short`	`Diff_DualThreshold`
`short`	`Diff_EditCost`
`float`	`Diff_Timeout`
`float`	`Match_Balance`
`int`	`Match_MaxLength`
`int`	`Match_MinLength`
`float`	`Match_Threshold`
`short`	`Patch_Margin`

Constructor Summary

Constructors
Constructor and Description

DiffMatchPatch()

Constructors
Constructor and Description
`DiffMatchPatch()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`diff_charsToLines(LinkedList<DiffMatchPatch.Diff> diffs, List<String> lineArray)` Rehydrate the text in a diff from a string of line hashes to real lines of text.
`void`	`diff_cleanupEfficiency(LinkedList<DiffMatchPatch.Diff> diffs)` Reduce the number of edits by eliminating operationally trivial equalities.
`void`	`diff_cleanupMerge(LinkedList<DiffMatchPatch.Diff> diffs)` Reorder and merge like edit sections.
`void`	`diff_cleanupSemantic(LinkedList<DiffMatchPatch.Diff> diffs)` Reduce the number of edits by eliminating semantically trivial equalities.
`void`	`diff_cleanupSemanticLossless(LinkedList<DiffMatchPatch.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(String text1, String text2)` Determine the common prefix of two strings
`int`	`diff_commonSuffix(String text1, String text2)` Determine the common suffix of two strings
`protected LinkedList<DiffMatchPatch.Diff>`	`diff_compute(String text1, String text2, boolean checklines)` Find the differences between two texts.
`protected Long`	`diff_footprint(int x, int y)` Compute a good hash of two integers.
`LinkedList<DiffMatchPatch.Diff>`	`diff_fromDelta(String text1, String delta)` Given the original text1, and an encoded string which describes the operations required to transform text1 into text2, compute the full diff.
`protected String[]`	`diff_halfMatch(String text1, String text2)` Do the two texts share a substring which is at least half the length of the longer text?
`protected Object[]`	`diff_linesToChars(String text1, String text2)` Split two texts into a list of strings.
`LinkedList<DiffMatchPatch.Diff>`	`diff_main(String text1, String text2)` Find the differences between two texts.
`LinkedList<DiffMatchPatch.Diff>`	`diff_main(String text1, String text2, boolean checklines)` Find the differences between two texts.
`protected LinkedList<DiffMatchPatch.Diff>`	`diff_map(String text1, String text2)` Explore the intersection points between the two texts.
`protected LinkedList<DiffMatchPatch.Diff>`	`diff_path1(List<Set<Long>> v_map, String text1, String text2)` Work from the middle back to the start to determine the path.
`protected LinkedList<DiffMatchPatch.Diff>`	`diff_path2(List<Set<Long>> v_map, String text1, String text2)` Work from the middle back to the end to determine the path.
`String`	`diff_prettyHtml(LinkedList<DiffMatchPatch.Diff> diffs)` Convert a Diff list into a pretty HTML report.
`String`	`diff_text1(LinkedList<DiffMatchPatch.Diff> diffs)` Compute and return the source text (all equalities and deletions).
`String`	`diff_text2(LinkedList<DiffMatchPatch.Diff> diffs)` Compute and return the destination text (all equalities and insertions).
`String`	`diff_toDelta(LinkedList<DiffMatchPatch.Diff> diffs)` Crush the diff into an encoded string which describes the operations required to transform text1 into text2.
`int`	`diff_xIndex(LinkedList<DiffMatchPatch.Diff> diffs, int loc)` loc is a location in text1, compute and return the equivalent location in text2.
`protected Map<Character,Integer>`	`match_alphabet(String pattern)` Initialise the alphabet for the Bitap algorithm.
`protected int`	`match_bitap(String text, String pattern, int loc)` Locate the best instance of 'pattern' in 'text' near 'loc' using the Bitap algorithm.
`int`	`match_main(String text, String pattern, int loc)` Locate the best instance of 'pattern' in 'text' near 'loc'.
`protected void`	`patch_addContext(DiffMatchPatch.Patch patch, String text)` Increase the context until it is unique, but don't let the pattern expand beyond Match_MaxBits.
`protected String`	`patch_addPadding(LinkedList<DiffMatchPatch.Patch> patches)` Add some padding on text start and end so that edges can match something.
`Object[]`	`patch_apply(LinkedList<DiffMatchPatch.Patch> patches, String text)` Merge a set of patches onto the text.
`protected LinkedList<DiffMatchPatch.Patch>`	`patch_deepCopy(LinkedList<DiffMatchPatch.Patch> patches)` Given an array of patches, return another array that is identical.
`List<DiffMatchPatch.Patch>`	`patch_fromText(String textline)` Parse a textual representation of patches and return a List of Patch objects.
`LinkedList<DiffMatchPatch.Patch>`	`patch_make(LinkedList<DiffMatchPatch.Diff> diffs)` Compute a list of patches to turn text1 into text2.
`LinkedList<DiffMatchPatch.Patch>`	`patch_make(String text1, LinkedList<DiffMatchPatch.Diff> diffs)` Compute a list of patches to turn text1 into text2.
`LinkedList<DiffMatchPatch.Patch>`	`patch_make(String text1, String text2)` Compute a list of patches to turn text1 into text2.
`void`	`patch_splitMax(LinkedList<DiffMatchPatch.Patch> patches)` Look through the patches and break up any which are longer than the maximum limit of the match algorithm.
`String`	`patch_toText(List<DiffMatchPatch.Patch> patches)` Take a list of patches and return a textual representation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - Diff_Timeout
```
public float Diff_Timeout
```
  - Diff_EditCost
```
public short Diff_EditCost
```
  - Diff_DualThreshold
```
public short Diff_DualThreshold
```
  - Match_Balance
```
public float Match_Balance
```
  - Match_Threshold
```
public float Match_Threshold
```
  - Match_MinLength
```
public int Match_MinLength
```
  - Match_MaxLength
```
public int Match_MaxLength
```
  - Patch_Margin
```
public short Patch_Margin
```
- Constructor Detail
  - DiffMatchPatch
```
public DiffMatchPatch()
```
- Method Detail
  - diff_main
```
public LinkedList<DiffMatchPatch.Diff> diff_main(String text1,
                                                 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 LinkedList<DiffMatchPatch.Diff> diff_main(String text1,
                                                 String text2,
                                                 boolean checklines)
```
    Find the differences between two texts. Simplifies the problem by stripping any common prefix or suffix off the texts before diffing.
    
    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_compute
```
protected LinkedList<DiffMatchPatch.Diff> diff_compute(String text1,
                                                       String text2,
                                                       boolean checklines)
```
    Find the differences between two texts. Assumes that the texts do not have any common prefix or suffix.
    
    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_linesToChars
```
protected Object[] diff_linesToChars(String text1,
                                     String text2)
```
    Split two texts into a list of strings. Reduce the texts to a string of hashes where each Unicode character represents one line.
    
    Parameters:
    
    text1 - First string.
    
    text2 - Second string.
    
    Returns:
    
    Three element Object array, containing the encoded text1, the encoded text2 and the List of unique strings. The zeroth element of the List of unique strings is intentionally blank.
  - diff_charsToLines
```
protected void diff_charsToLines(LinkedList<DiffMatchPatch.Diff> diffs,
                                 List<String> lineArray)
```
    Rehydrate the text in a diff from a string of line hashes to real lines of text.
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
    
    lineArray - List of unique strings.
  - diff_map
```
protected LinkedList<DiffMatchPatch.Diff> diff_map(String text1,
                                                   String text2)
```
    Explore the intersection points between the two texts.
    
    Parameters:
    
    text1 - Old string to be diffed.
    
    text2 - New string to be diffed.
    
    Returns:
    
    LinkedList of Diff objects or null if no diff available.
  - diff_path1
```
protected LinkedList<DiffMatchPatch.Diff> diff_path1(List<Set<Long>> v_map,
                                                     String text1,
                                                     String text2)
```
    Work from the middle back to the start to determine the path.
    
    Parameters:
    
    v_map - List of path sets.
    
    text1 - Old string fragment to be diffed.
    
    text2 - New string fragment to be diffed.
    
    Returns:
    
    LinkedList of Diff objects.
  - diff_path2
```
protected LinkedList<DiffMatchPatch.Diff> diff_path2(List<Set<Long>> v_map,
                                                     String text1,
                                                     String text2)
```
    Work from the middle back to the end to determine the path.
    
    Parameters:
    
    v_map - List of path sets.
    
    text1 - Old string fragment to be diffed.
    
    text2 - New string fragment to be diffed.
    
    Returns:
    
    LinkedList of Diff objects.
  - diff_footprint
```
protected Long diff_footprint(int x,
                              int y)
```
    Compute a good hash of two integers.
    
    Parameters:
    
    x - First int.
    
    y - Second int.
    
    Returns:
    
    A long made up of both ints.
  - diff_commonPrefix
```
public int diff_commonPrefix(String text1,
                             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(String text1,
                             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_halfMatch
```
protected String[] diff_halfMatch(String text1,
                                  String text2)
```
    Do the two texts share a substring which is at least half the length of the longer text?
    
    Parameters:
    
    text1 - First string.
    
    text2 - Second string.
    
    Returns:
    
    Five element String array, containing the prefix of text1, the suffix of text1, the prefix of text2, the suffix of text2 and the common middle. Or null if there was no match.
  - diff_cleanupSemantic
```
public void diff_cleanupSemantic(LinkedList<DiffMatchPatch.Diff> diffs)
```
    Reduce the number of edits by eliminating semantically trivial equalities.
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
  - diff_cleanupSemanticLossless
```
public void diff_cleanupSemanticLossless(LinkedList<DiffMatchPatch.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 cat came. -> The cat came.
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
  - diff_cleanupEfficiency
```
public void diff_cleanupEfficiency(LinkedList<DiffMatchPatch.Diff> diffs)
```
    Reduce the number of edits by eliminating operationally trivial equalities.
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
  - diff_cleanupMerge
```
public void diff_cleanupMerge(LinkedList<DiffMatchPatch.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(LinkedList<DiffMatchPatch.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 String diff_prettyHtml(LinkedList<DiffMatchPatch.Diff> diffs)
```
    Convert a Diff list into a pretty HTML report.
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
    
    Returns:
    
    HTML representation.
  - diff_text1
```
public String diff_text1(LinkedList<DiffMatchPatch.Diff> diffs)
```
    Compute and return the source text (all equalities and deletions).
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
    
    Returns:
    
    Source text.
  - diff_text2
```
public String diff_text2(LinkedList<DiffMatchPatch.Diff> diffs)
```
    Compute and return the destination text (all equalities and insertions).
    
    Parameters:
    
    diffs - LinkedList of Diff objects.
    
    Returns:
    
    Destination text.
  - diff_toDelta
```
public String diff_toDelta(LinkedList<DiffMatchPatch.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 tuples.
    
    Returns:
    
    Delta text.
  - diff_fromDelta
```
public LinkedList<DiffMatchPatch.Diff> diff_fromDelta(String text1,
                                                      String delta)
                                               throws 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 tuples or null if invalid.
    
    Throws:
    
    IllegalArgumentException
  - match_main
```
public int match_main(String text,
                      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.
  - match_bitap
```
protected int match_bitap(String text,
                          String pattern,
                          int loc)
```
    Locate the best instance of 'pattern' in 'text' near 'loc' using the Bitap algorithm. 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.
  - match_alphabet
```
protected Map<Character,Integer> match_alphabet(String pattern)
```
    Initialise the alphabet for the Bitap algorithm.
    
    Parameters:
    
    pattern - The text to encode.
    
    Returns:
    
    Hash of character locations.
  - patch_addContext
```
protected void patch_addContext(DiffMatchPatch.Patch patch,
                                String text)
```
    Increase the context until it is unique, but don't let the pattern expand beyond Match_MaxBits.
    
    Parameters:
    
    patch - The patch to grow.
    
    text - Source text.
  - patch_make
```
public LinkedList<DiffMatchPatch.Patch> patch_make(String text1,
                                                   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 LinkedList<DiffMatchPatch.Patch> patch_make(LinkedList<DiffMatchPatch.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 tuples for text1 to text2.
    
    Returns:
    
    LinkedList of Patch objects.
  - patch_make
```
public LinkedList<DiffMatchPatch.Patch> patch_make(String text1,
                                                   LinkedList<DiffMatchPatch.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 tuples for text1 to text2.
    
    Returns:
    
    LinkedList of Patch objects.
  - patch_deepCopy
```
protected LinkedList<DiffMatchPatch.Patch> patch_deepCopy(LinkedList<DiffMatchPatch.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 Object[] patch_apply(LinkedList<DiffMatchPatch.Patch> patches,
                            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
```
protected String patch_addPadding(LinkedList<DiffMatchPatch.Patch> patches)
```
    Add some padding on text start and end so that edges can match something.
    
    Parameters:
    
    patches - Array of patch objects.
    
    Returns:
    
    The padding string added to each side.
  - patch_splitMax
```
public void patch_splitMax(LinkedList<DiffMatchPatch.Patch> patches)
```
    Look through the patches and break up any which are longer than the maximum limit of the match algorithm.
    
    Parameters:
    
    patches - LinkedList of Patch objects.
  - patch_toText
```
public String patch_toText(List<DiffMatchPatch.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 List<DiffMatchPatch.Patch> patch_fromText(String textline)
                                          throws 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:
    
    IllegalArgumentException - If invalid input.

Class DiffMatchPatch

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Diff_Timeout

Diff_EditCost

Diff_DualThreshold

Match_Balance

Match_Threshold

Match_MinLength

Match_MaxLength

Patch_Margin

Constructor Detail

DiffMatchPatch

Method Detail

diff_main

diff_main

diff_compute

diff_linesToChars

diff_charsToLines

diff_map

diff_path1

diff_path2

diff_footprint

diff_commonPrefix

diff_commonSuffix

diff_halfMatch

diff_cleanupSemantic

diff_cleanupSemanticLossless

diff_cleanupEfficiency

diff_cleanupMerge

diff_xIndex

diff_prettyHtml

diff_text1

diff_text2

diff_toDelta

diff_fromDelta

match_main

match_bitap

match_alphabet

patch_addContext

patch_make

patch_make

patch_make

patch_deepCopy

patch_apply

patch_addPadding

patch_splitMax

patch_toText

patch_fromText