Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.util;
 
 import java.util.List;

Output in unified format. See http://en.wikipedia.org/wiki/Diff
 
 public class Diff {
     public static String diff(String leftStrString rightStr) {
         return diff(leftStrrightStrfalse, 0);
     }
 
     public static String diff(String leftStrString rightStrboolean rangeint context) {
         return diff(leftStrrightStrrangecontextfalse);
     }
 
     public static String diff(String leftStrString rightStrboolean rangeint contextboolean escape) {
         return diff(..split(leftStr), ..split(rightStr), rangecontextescape);
     }
 
     public static String diff(List<StringleftList<Stringrightboolean rangeint contextboolean escape) {
         List<Stringcommons;
         List<Chunkchunks;
         Chunk chunk;
         StringBuilder result;
         int ci;
         Chunk last;
 
         commons = Lcs.compute(leftright);
         chunks = diff(leftcommonsright);
         result = new StringBuilder();
         last = null;
         for (int c = 0; c < chunks.size(); c++) {
             chunk = chunks.get(c);
             if (range && (last == null || !last.touches(chunkcontext))) {
                 addRange(resultchunksccommons.size(), context);
             }
             ci = Math.max(chunk.common - contextc == 0 ? 0 : chunks.get(c - 1).);
             for (int i = cii < chunk.commoni++) {
                 result.append(" ").append(commons.get(i));
             }
             if (chunk.delete > 0) {
                 for (int i = chunk.lefti < chunk.left + chunk.deletei++) {
                     result.append('-');
                     appendEscaped(left.get(i), escaperesult);
                 }
             }
             if (chunk.add.size() > 0) {
                 for (String line : chunk.add) {
                     result.append("+");
                     appendEscaped(lineescaperesult);
                 }
             }
             ci = Math.min(chunk.common + contextc == chunks.size() - 1 ? commons.size() : chunks.get(c + 1). - context);
             for (int i = chunk.commoni < cii++) {
                 result.append(" ").append(commons.get(i));
             }
             last = chunk;
         }
         return result.toString();
     }
 
     public static void appendEscaped(String strboolean escapeStringBuilder dest) {
         int max;
         char c;
         if (escape) {
             max = str.length();
             for (int i = 0; i < maxi++) {
                 c = str.charAt(i);
                 switch (c) {
                 case '\t':
                     dest.append("\\t");
                     break;
                 case '\r':
                     dest.append("\\r");
                     break;
                 case '\n':
                     dest.append("\\n");
                     break;
                 default:
                     if (c < ' ') {
                        dest.append('[').append((intc).append(']');
                    } else {
                        dest.append(c);
                    }
                }
            }
        } else {
            dest.append(str);
        }
    }
    public static List<Chunkdiff(List<StringleftList<StringcommonsList<Stringright) {
        Chunk chunk;
        List<Chunkresult;
        int li;
        int ri;
        int lmax;
        int rmax;
        String common;
        result = new ArrayList<Chunk>();
        lmax = left.size();
        rmax = right.size();
        li = 0;
        ri = 0;
        for (int ci = 0; ci <= commons.size(); ci++) {
            common = ci < commons.size() ? commons.get(ci) : null;
            if (li < lmax && !left.get(li).equals(common)) {
                chunk = new Chunk(liciri);
                result.add(chunk);
                do {
                    li++;
                } while (li < lmax && !left.get(li).equals(common));
                chunk.delete = li - chunk.left;
            } else {
                // definite assignment
                chunk = null;
            }
            if (ri < rmax && !right.get(ri).equals(common)) {
                if (chunk == null) {
                    chunk = new Chunk(liciri);
                    result.add(chunk);
                }
                do {
                    chunk.add.add(right.get(ri++));
                } while (ri < rmax && !right.get(ri).equals(common));
            }
            li++;
            ri++;
        }
        return result;
    }
    private static void addRange(StringBuilder resultList<Chunkchunksint ofsint cmaxint context) {
        Chunk first;
        Chunk prev;
        Chunk current;
        int leftStart;
        int leftCount;
        int rightStart;
        int rightCount;
        first = chunks.get(ofs);
        leftStart = Math.max(first.left - context, 0);
        rightStart = Math.max(first.right - context, 0);
        leftCount = first.left - leftStart;
        rightCount = first.right - rightStart;
        prev = null;
        for ( ; ofs < chunks.size(); ofs++) {
            current = chunks.get(ofs);
            if (prev != null && !prev.touches(currentcontext)) {
                break;
            }
            leftCount += current.delete;
            rightCount += current.add.size();
            prev = current;
        }
        current = chunks.get(ofs - 1);
        leftCount += current.common - first.common;
        leftCount += Math.min(current.common + contextcmax) - current.common;
        rightCount += current.common - first.common;
        rightCount += Math.min(current.common + contextcmax) - current.common;
        result.append("@@ -");
        addRange(resultleftStartleftCount);
        result.append(" +");
        addRange(resultrightStartrightCount);
        result.append(" @@\n");
    }
    private static void addRange(StringBuilder resultint idxint count) {
        result.append(idx + 1);
        if (count != 1) {
            result.append(',').append(count);
        }
    }
    private static class Chunk {
        public final int left;
        public final int common;
        public final int right;
        public int delete;
        public final List<Stringadd;
        public Chunk(int leftint commonint right) {
            this. = left;
            this. = right;
            this. = common;
            this. = new ArrayList<String>();
        }
        public boolean touches(Chunk chunkint context) {
            return Math.abs( - chunk.common) <= context * 2;
        }
        public String range() {
            return "@@ -" + ( + 1) + "," +  + " +" + ( + 1) + "," + .size() + " @@\n";
        }
    }
New to GrepCode? Check out our FAQ X