Lines Matching refs:Diff
2 * Diff Match and Patch
118 * The data structure representing a diff is a Linked list of Diff objects:
119 * {Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"),
120 * Diff(Operation.EQUAL, " world.")}
135 * @return Linked List of Diff objects.
137 public LinkedList<Diff> diff_main(String text1, String text2) {
149 * @return Linked List of Diff objects.
151 public LinkedList<Diff> diff_main(String text1, String text2,
159 LinkedList<Diff> diffs;
161 diffs = new LinkedList<Diff>();
162 diffs.add(new Diff(Operation.EQUAL, text1));
183 diffs.addFirst(new Diff(Operation.EQUAL, commonprefix));
186 diffs.addLast(new Diff(Operation.EQUAL, commonsuffix));
202 * @return Linked List of Diff objects.
204 protected LinkedList<Diff> diff_compute(String text1, String text2,
206 LinkedList<Diff> diffs = new LinkedList<Diff>();
210 diffs.add(new Diff(Operation.INSERT, text2));
216 diffs.add(new Diff(Operation.DELETE, text1));
227 diffs.add(new Diff(op, longtext.substring(0, i)));
228 diffs.add(new Diff(Operation.EQUAL, shorttext));
229 diffs.add(new Diff(op, longtext.substring(i + shorttext.length())));
244 LinkedList<Diff> diffs_a = diff_main(text1_a, text2_a, checklines);
245 LinkedList<Diff> diffs_b = diff_main(text1_b, text2_b, checklines);
248 diffs.add(new Diff(Operation.EQUAL, mid_common));
269 diffs = new LinkedList<Diff>();
270 diffs.add(new Diff(Operation.DELETE, text1));
271 diffs.add(new Diff(Operation.INSERT, text2));
282 diffs.add(new Diff(Operation.EQUAL, ""));
287 ListIterator<Diff> pointer = diffs.listIterator();
288 Diff thisDiff = pointer.next();
308 for (Diff newDiff : diff_main(text_delete, text_insert, false)) {
391 * @param diffs LinkedList of Diff objects.
394 protected void diff_charsToLines(LinkedList<Diff> diffs,
397 for (Diff diff : diffs) {
411 * @return LinkedList of Diff objects or null if no diff available.
413 protected LinkedList<Diff> diff_map(String text1, String text2) {
479 LinkedList<Diff> a = diff_path1(v_map1, text1.substring(0, x),
521 LinkedList<Diff> a
541 * @return LinkedList of Diff objects.
543 protected LinkedList<Diff> diff_path1(List<Set<Long>> v_map,
545 LinkedList<Diff> path = new LinkedList<Diff>();
556 path.addFirst(new Diff(Operation.DELETE,
566 path.addFirst(new Diff(Operation.INSERT,
579 path.addFirst(new Diff(Operation.EQUAL, text1.substring(x, x + 1)));
594 * @return LinkedList of Diff objects.
596 protected LinkedList<Diff> diff_path2(List<Set<Long>> v_map,
598 LinkedList<Diff> path = new LinkedList<Diff>();
609 path.addLast(new Diff(Operation.DELETE,
619 path.addLast(new Diff(Operation.INSERT,
633 path.addLast(new Diff(Operation.EQUAL,
785 * @param diffs LinkedList of Diff objects.
787 public void diff_cleanupSemantic(LinkedList<Diff> diffs) {
792 Stack<Diff> equalities = new Stack<Diff>(); // Stack of qualities.
794 ListIterator<Diff> pointer = diffs.listIterator();
799 Diff thisDiff = pointer.next();
820 pointer.set(new Diff(Operation.DELETE, lastequality));
822 pointer.add(new Diff(Operation.INSERT, lastequality));
862 * @param diffs LinkedList of Diff objects.
864 public void diff_cleanupSemanticLossless(LinkedList<Diff> diffs) {
871 ListIterator<Diff> pointer = diffs.listIterator();
872 Diff prevDiff = pointer.hasNext() ? pointer.next() : null;
873 Diff thisDiff = pointer.hasNext() ? pointer.next() : null;
874 Diff nextDiff = pointer.hasNext() ? pointer.next() : null;
996 * @param diffs LinkedList of Diff objects.
998 public void diff_cleanupEfficiency(LinkedList<Diff> diffs) {
1003 Stack<Diff> equalities = new Stack<Diff>(); // Stack of equalities.
1005 ListIterator<Diff> pointer = diffs.listIterator();
1014 Diff thisDiff = pointer.next();
1015 Diff safeDiff = thisDiff; // The last Diff that is known to be unsplitable.
1060 pointer.set(new Diff(Operation.DELETE, lastequality));
1062 pointer.add(thisDiff = new Diff(Operation.INSERT, lastequality));
1105 * @param diffs LinkedList of Diff objects.
1107 public void diff_cleanupMerge(LinkedList<Diff> diffs) {
1108 diffs.add(new Diff(Operation.EQUAL, "")); // Add a dummy entry at the end.
1109 ListIterator<Diff> pointer = diffs.listIterator();
1114 Diff thisDiff = pointer.next();
1115 Diff prevEqual = null;
1152 pointer.add(new Diff(Operation.EQUAL,
1173 pointer.add(new Diff(Operation.DELETE, text_delete));
1176 pointer.add(new Diff(Operation.INSERT, text_insert));
1210 Diff prevDiff = pointer.hasNext() ? pointer.next() : null;
1212 Diff nextDiff = pointer.hasNext() ? pointer.next() : null;
1257 * @param diffs LinkedList of Diff objects.
1261 public int diff_xIndex(LinkedList<Diff> diffs, int loc) {
1266 Diff lastDiff = null;
1267 for (Diff aDiff : diffs) {
1294 * Convert a Diff list into a pretty HTML report.
1295 * @param diffs LinkedList of Diff objects.
1298 public String diff_prettyHtml(LinkedList<Diff> diffs) {
1301 for (Diff aDiff : diffs) {
1328 * @param diffs LinkedList of Diff objects.
1331 public String diff_text1(LinkedList<Diff> diffs) {
1333 for (Diff aDiff : diffs) {
1344 * @param diffs LinkedList of Diff objects.
1347 public String diff_text2(LinkedList<Diff> diffs) {
1349 for (Diff aDiff : diffs) {
1361 * @param diffs LinkedList of Diff objects.
1364 public int diff_levenshtein(LinkedList<Diff> diffs) {
1368 for (Diff aDiff : diffs) {
1397 public String diff_toDelta(LinkedList<Diff> diffs) {
1399 for (Diff aDiff : diffs) {
1436 public LinkedList<Diff> diff_fromDelta(String text1, String delta)
1438 LinkedList<Diff> diffs = new LinkedList<Diff>();
1463 diffs.add(new Diff(Operation.INSERT, param));
1488 diffs.add(new Diff(Operation.EQUAL, text));
1490 diffs.add(new Diff(Operation.DELETE, text));
1716 patch.diffs.addFirst(new Diff(Operation.EQUAL, prefix));
1722 patch.diffs.addLast(new Diff(Operation.EQUAL, suffix));
1746 LinkedList<Diff> diffs = diff_main(text1, text2, true);
1761 public LinkedList<Patch> patch_make(LinkedList<Diff> diffs) {
1778 * @deprecated Prefer patch_make(String text1, LinkedList<Diff> diffs).
1781 LinkedList<Diff> diffs) {
1793 public LinkedList<Patch> patch_make(String text1, LinkedList<Diff> diffs) {
1810 for (Diff aDiff : diffs) {
1883 for (Diff aDiff : aPatch.diffs) {
1884 Diff diffCopy = new Diff(aDiff.operation, aDiff.text);
1970 LinkedList<Diff> diffs = diff_main(text1, text2, false);
1979 for (Diff aDiff : aPatch.diffs) {
2030 LinkedList<Diff> diffs = patch.diffs;
2033 diffs.addFirst(new Diff(Operation.EQUAL, nullPadding));
2040 Diff firstDiff = diffs.getFirst();
2055 diffs.addLast(new Diff(Operation.EQUAL, nullPadding));
2060 Diff lastDiff = diffs.getLast();
2105 patch.diffs.add(new Diff(Operation.EQUAL, precontext));
2124 patch.diffs.add(new Diff(diff_type, diff_text));
2138 patch.diffs.add(new Diff(diff_type, diff_text));
2164 patch.diffs.add(new Diff(Operation.EQUAL, postcontext));
2264 patch.diffs.add(new Diff(Operation.DELETE, line));
2267 patch.diffs.add(new Diff(Operation.INSERT, line));
2270 patch.diffs.add(new Diff(Operation.EQUAL, line));
2289 public static class Diff {
2304 public Diff(Operation operation, String text) {
2312 * Display a human-readable version of this Diff.
2317 return "Diff(" + this.operation + ",\"" + prettyText + "\")";
2322 * Is this Diff equivalent to another Diff?
2323 * @param d Another Diff to compare against.
2328 return (((Diff) d).operation == this.operation)
2329 && (((Diff) d).text.equals(this.text));
2341 public LinkedList<Diff> diffs;
2352 this.diffs = new LinkedList<Diff>();
2382 for (Diff aDiff : this.diffs) {