DiffLists (Okapi Library with Helper Classes for Filters and Steps 0.35 API)

java.lang.Object
- net.sf.okapi.lib.extra.diff.incava.DiffLists<Type>

```
public class DiffLists<Type>
extends Object
```
Compares two lists, returning a list of the additions, changes, and deletions between them. A Comparator may be passed as an argument to the constructor, and will thus be used. If not provided, the initial value in the a ("from") list will be looked at to see if it supports the Comparable interface. If so, its equals and compareTo methods will be invoked on the instances in the "from" and "to" lists; otherwise, for speed, hash codes from the objects will be used instead for comparison.
The file FileDiff.java shows an example usage of this class, in an application similar to the Unix "diff" program.

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<Type>`	`a` The source list, AKA the "from" values.
`protected List<Type>`	`b` The target list, AKA the "to" values.
`protected List<Difference>`	`diffs` The list of differences, as `Difference` instances.

Constructor Summary

Constructors
Constructor and Description
`DiffLists(List<Type> a, List<Type> b)` Constructs the Diff object for the two lists, using the default comparison mechanism between the objects, such as `equals` and `compareTo`.
`DiffLists(List<Type> a, List<Type> b, Comparator<Type> comp)` Constructs the Diff object for the two lists, using the given comparator.
`DiffLists(Type[] a, Type[] b)` Constructs the Diff object for the two arrays, using the default comparison mechanism between the objects, such as `equals` and `compareTo`.
`DiffLists(Type[] a, Type[] b, Comparator<Type> comp)` Constructs the Diff object for the two arrays, using the given comparator.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`append(Integer value)` Adds the given value to the "end" of the threshold map, that is, with the greatest index/key.
`protected boolean`	`callFinishedA()` Override and return true in order to have `finishedA` invoked at the last element in the `a` array.
`protected boolean`	`callFinishedB()` Override and return true in order to have `finishedB` invoked at the last element in the `b` array.
`List<Difference>`	`diff()` Runs diff and returns the results.
`protected boolean`	`equals(Type x, Type y)` Compares the two objects, using the comparator provided with the constructor, if any.
`protected void`	`finishedA(int lastA)` Invoked at the last element in `a`, if `callFinishedA` returns true.
`protected void`	`finishedB(int lastB)` Invoked at the last element in `b`, if `callFinishedB` returns true.
`protected Integer`	`getLastValue()` Returns the value for the greatest key in the map.
`Map<Integer,Integer>`	`getMatches()`
`protected Integer`	`insert(Integer j, Integer k)` Inserts the given values into the threshold map.
`protected boolean`	`isGreaterThan(Integer index, Integer val)` Returns whether the value in the map for the given index is greater than the given value.
`protected boolean`	`isLessThan(Integer index, Integer val)` Returns whether the value in the map for the given index is less than the given value.
`protected static boolean`	`isNonzero(Integer i)` Returns whether the integer is not zero (including if it is not null).
`protected void`	`onANotB(int ai, int bi)` Invoked for elements in `a` and not in `b`.
`protected void`	`onBNotA(int ai, int bi)` Invoked for elements in `b` and not in `a`.
`protected void`	`onMatch(int ai, int bi)` Invoked for elements matching in `a` and `b`.
`protected void`	`traverseSequences()` Traverses the sequences, seeking the longest common subsequences, invoking the methods `finishedA`, `finishedB`, `onANotB`, and `onBNotA`.

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

- Field Detail
  - a
```
protected List<Type> a
```
    The source list, AKA the "from" values.
  - b
```
protected List<Type> b
```
    The target list, AKA the "to" values.
  - diffs
```
protected List<Difference> diffs
```
    The list of differences, as Difference instances.
- Constructor Detail
  - DiffLists
```
public DiffLists(Type[] a,
         Type[] b,
         Comparator<Type> comp)
```
    Constructs the Diff object for the two arrays, using the given comparator.
  - DiffLists
```
public DiffLists(Type[] a,
         Type[] b)
```
    Constructs the Diff object for the two arrays, using the default comparison mechanism between the objects, such as equals and compareTo.
  - DiffLists
```
public DiffLists(List<Type> a,
         List<Type> b,
         Comparator<Type> comp)
```
    Constructs the Diff object for the two lists, using the given comparator.
  - DiffLists
```
public DiffLists(List<Type> a,
         List<Type> b)
```
    Constructs the Diff object for the two lists, using the default comparison mechanism between the objects, such as equals and compareTo.
- Method Detail
  - diff
```
public List<Difference> diff()
```
    Runs diff and returns the results.
  - traverseSequences
```
protected void traverseSequences()
```
    Traverses the sequences, seeking the longest common subsequences, invoking the methods finishedA, finishedB, onANotB, and onBNotA.
  - callFinishedA
```
protected boolean callFinishedA()
```
    Override and return true in order to have finishedA invoked at the last element in the a array.
  - callFinishedB
```
protected boolean callFinishedB()
```
    Override and return true in order to have finishedB invoked at the last element in the b array.
  - finishedA
```
protected void finishedA(int lastA)
```
    Invoked at the last element in a, if callFinishedA returns true.
  - finishedB
```
protected void finishedB(int lastB)
```
    Invoked at the last element in b, if callFinishedB returns true.
  - onANotB
```
protected void onANotB(int ai,
           int bi)
```
    Invoked for elements in a and not in b.
  - onBNotA
```
protected void onBNotA(int ai,
           int bi)
```
    Invoked for elements in b and not in a.
  - onMatch
```
protected void onMatch(int ai,
           int bi)
```
    Invoked for elements matching in a and b.
  - equals
```
protected boolean equals(Type x,
             Type y)
```
    Compares the two objects, using the comparator provided with the constructor, if any.
  - getMatches
```
public Map<Integer,Integer> getMatches()
```
  - isNonzero
```
protected static boolean isNonzero(Integer i)
```
    Returns whether the integer is not zero (including if it is not null).
  - isGreaterThan
```
protected boolean isGreaterThan(Integer index,
                    Integer val)
```
    Returns whether the value in the map for the given index is greater than the given value.
  - isLessThan
```
protected boolean isLessThan(Integer index,
                 Integer val)
```
    Returns whether the value in the map for the given index is less than the given value.
  - getLastValue
```
protected Integer getLastValue()
```
    Returns the value for the greatest key in the map.
  - append
```
protected void append(Integer value)
```
    Adds the given value to the "end" of the threshold map, that is, with the greatest index/key.
  - insert
```
protected Integer insert(Integer j,
             Integer k)
```
    Inserts the given values into the threshold map.

Class DiffLists<Type>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

a

b

diffs

Constructor Detail

DiffLists

DiffLists

DiffLists

DiffLists

Method Detail

diff

traverseSequences

callFinishedA

callFinishedB

finishedA

finishedB

onANotB

onBNotA

onMatch

equals

getMatches

isNonzero

isGreaterThan

isLessThan

getLastValue

append

insert