| /* |
| * Copyright (C) 2009-2010, Google Inc. |
| * Copyright (C) 2008-2009, Johannes E. Schindelin <johannes.schindelin@gmx.de> |
| * and other copyright owners as documented in the project's IP log. |
| * |
| * This program and the accompanying materials are made available |
| * under the terms of the Eclipse Distribution License v1.0 which |
| * accompanies this distribution, is reproduced below, and is |
| * available at http://www.eclipse.org/org/documents/edl-v10.php |
| * |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or |
| * without modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * |
| * - Neither the name of the Eclipse Foundation, Inc. nor the |
| * names of its contributors may be used to endorse or promote |
| * products derived from this software without specific prior |
| * written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package org.eclipse.jgit.diff; |
| |
| import static org.eclipse.jgit.util.RawCharUtil.isWhitespace; |
| import static org.eclipse.jgit.util.RawCharUtil.trimLeadingWhitespace; |
| import static org.eclipse.jgit.util.RawCharUtil.trimTrailingWhitespace; |
| |
| import org.eclipse.jgit.util.IntList; |
| |
| /** Equivalence function for {@link RawText}. */ |
| public abstract class RawTextComparator extends SequenceComparator<RawText> { |
| /** No special treatment. */ |
| public static final RawTextComparator DEFAULT = new RawTextComparator() { |
| @Override |
| public boolean equals(RawText a, int ai, RawText b, int bi) { |
| ai++; |
| bi++; |
| |
| int as = a.lines.get(ai); |
| int bs = b.lines.get(bi); |
| final int ae = a.lines.get(ai + 1); |
| final int be = b.lines.get(bi + 1); |
| |
| if (ae - as != be - bs) |
| return false; |
| |
| while (as < ae) { |
| if (a.content[as++] != b.content[bs++]) |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| protected int hashRegion(final byte[] raw, int ptr, final int end) { |
| int hash = 5381; |
| for (; ptr < end; ptr++) |
| hash = ((hash << 5) + hash) + (raw[ptr] & 0xff); |
| return hash; |
| } |
| }; |
| |
| /** Ignores all whitespace. */ |
| public static final RawTextComparator WS_IGNORE_ALL = new RawTextComparator() { |
| @Override |
| public boolean equals(RawText a, int ai, RawText b, int bi) { |
| ai++; |
| bi++; |
| |
| int as = a.lines.get(ai); |
| int bs = b.lines.get(bi); |
| int ae = a.lines.get(ai + 1); |
| int be = b.lines.get(bi + 1); |
| |
| ae = trimTrailingWhitespace(a.content, as, ae); |
| be = trimTrailingWhitespace(b.content, bs, be); |
| |
| while (as < ae && bs < be) { |
| byte ac = a.content[as]; |
| byte bc = b.content[bs]; |
| |
| while (as < ae - 1 && isWhitespace(ac)) { |
| as++; |
| ac = a.content[as]; |
| } |
| |
| while (bs < be - 1 && isWhitespace(bc)) { |
| bs++; |
| bc = b.content[bs]; |
| } |
| |
| if (ac != bc) |
| return false; |
| |
| as++; |
| bs++; |
| } |
| |
| return as == ae && bs == be; |
| } |
| |
| @Override |
| protected int hashRegion(byte[] raw, int ptr, int end) { |
| int hash = 5381; |
| for (; ptr < end; ptr++) { |
| byte c = raw[ptr]; |
| if (!isWhitespace(c)) |
| hash = ((hash << 5) + hash) + (c & 0xff); |
| } |
| return hash; |
| } |
| }; |
| |
| /** Ignores leading whitespace. */ |
| public static final RawTextComparator WS_IGNORE_LEADING = new RawTextComparator() { |
| @Override |
| public boolean equals(RawText a, int ai, RawText b, int bi) { |
| ai++; |
| bi++; |
| |
| int as = a.lines.get(ai); |
| int bs = b.lines.get(bi); |
| int ae = a.lines.get(ai + 1); |
| int be = b.lines.get(bi + 1); |
| |
| as = trimLeadingWhitespace(a.content, as, ae); |
| bs = trimLeadingWhitespace(b.content, bs, be); |
| |
| if (ae - as != be - bs) |
| return false; |
| |
| while (as < ae) { |
| if (a.content[as++] != b.content[bs++]) |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| protected int hashRegion(final byte[] raw, int ptr, int end) { |
| int hash = 5381; |
| ptr = trimLeadingWhitespace(raw, ptr, end); |
| for (; ptr < end; ptr++) |
| hash = ((hash << 5) + hash) + (raw[ptr] & 0xff); |
| return hash; |
| } |
| }; |
| |
| /** Ignores trailing whitespace. */ |
| public static final RawTextComparator WS_IGNORE_TRAILING = new RawTextComparator() { |
| @Override |
| public boolean equals(RawText a, int ai, RawText b, int bi) { |
| ai++; |
| bi++; |
| |
| int as = a.lines.get(ai); |
| int bs = b.lines.get(bi); |
| int ae = a.lines.get(ai + 1); |
| int be = b.lines.get(bi + 1); |
| |
| ae = trimTrailingWhitespace(a.content, as, ae); |
| be = trimTrailingWhitespace(b.content, bs, be); |
| |
| if (ae - as != be - bs) |
| return false; |
| |
| while (as < ae) { |
| if (a.content[as++] != b.content[bs++]) |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| protected int hashRegion(final byte[] raw, int ptr, int end) { |
| int hash = 5381; |
| end = trimTrailingWhitespace(raw, ptr, end); |
| for (; ptr < end; ptr++) |
| hash = ((hash << 5) + hash) + (raw[ptr] & 0xff); |
| return hash; |
| } |
| }; |
| |
| /** Ignores whitespace occurring between non-whitespace characters. */ |
| public static final RawTextComparator WS_IGNORE_CHANGE = new RawTextComparator() { |
| @Override |
| public boolean equals(RawText a, int ai, RawText b, int bi) { |
| ai++; |
| bi++; |
| |
| int as = a.lines.get(ai); |
| int bs = b.lines.get(bi); |
| int ae = a.lines.get(ai + 1); |
| int be = b.lines.get(bi + 1); |
| |
| ae = trimTrailingWhitespace(a.content, as, ae); |
| be = trimTrailingWhitespace(b.content, bs, be); |
| |
| while (as < ae && bs < be) { |
| byte ac = a.content[as]; |
| byte bc = b.content[bs]; |
| |
| if (ac != bc) |
| return false; |
| |
| if (isWhitespace(ac)) |
| as = trimLeadingWhitespace(a.content, as, ae); |
| else |
| as++; |
| |
| if (isWhitespace(bc)) |
| bs = trimLeadingWhitespace(b.content, bs, be); |
| else |
| bs++; |
| } |
| return as == ae && bs == be; |
| } |
| |
| @Override |
| protected int hashRegion(final byte[] raw, int ptr, int end) { |
| int hash = 5381; |
| end = trimTrailingWhitespace(raw, ptr, end); |
| while (ptr < end) { |
| byte c = raw[ptr]; |
| hash = ((hash << 5) + hash) + (c & 0xff); |
| if (isWhitespace(c)) |
| ptr = trimLeadingWhitespace(raw, ptr, end); |
| else |
| ptr++; |
| } |
| return hash; |
| } |
| }; |
| |
| @Override |
| public int hash(RawText seq, int lno) { |
| final int begin = seq.lines.get(lno + 1); |
| final int end = seq.lines.get(lno + 2); |
| return hashRegion(seq.content, begin, end); |
| } |
| |
| @Override |
| public Edit reduceCommonStartEnd(RawText a, RawText b, Edit e) { |
| // This is a faster exact match based form that tries to improve |
| // performance for the common case of the header and trailer of |
| // a text file not changing at all. After this fast path we use |
| // the slower path based on the super class' using equals() to |
| // allow for whitespace ignore modes to still work. |
| |
| if (e.beginA == e.endA || e.beginB == e.endB) |
| return e; |
| |
| byte[] aRaw = a.content; |
| byte[] bRaw = b.content; |
| |
| int aPtr = a.lines.get(e.beginA + 1); |
| int bPtr = a.lines.get(e.beginB + 1); |
| |
| int aEnd = a.lines.get(e.endA + 1); |
| int bEnd = b.lines.get(e.endB + 1); |
| |
| // This can never happen, but the JIT doesn't know that. If we |
| // define this assertion before the tight while loops below it |
| // should be able to skip the array bound checks on access. |
| // |
| if (aPtr < 0 || bPtr < 0 || aEnd > aRaw.length || bEnd > bRaw.length) |
| throw new ArrayIndexOutOfBoundsException(); |
| |
| while (aPtr < aEnd && bPtr < bEnd && aRaw[aPtr] == bRaw[bPtr]) { |
| aPtr++; |
| bPtr++; |
| } |
| |
| while (aPtr < aEnd && bPtr < bEnd && aRaw[aEnd - 1] == bRaw[bEnd - 1]) { |
| aEnd--; |
| bEnd--; |
| } |
| |
| e.beginA = findForwardLine(a.lines, e.beginA, aPtr); |
| e.beginB = findForwardLine(b.lines, e.beginB, bPtr); |
| |
| e.endA = findReverseLine(a.lines, e.endA, aEnd); |
| |
| final boolean partialA = aEnd < a.lines.get(e.endA + 1); |
| if (partialA) |
| bEnd += a.lines.get(e.endA + 1) - aEnd; |
| |
| e.endB = findReverseLine(b.lines, e.endB, bEnd); |
| |
| if (!partialA && bEnd < b.lines.get(e.endB + 1)) |
| e.endA++; |
| |
| return super.reduceCommonStartEnd(a, b, e); |
| } |
| |
| private static int findForwardLine(IntList lines, int idx, int ptr) { |
| final int end = lines.size() - 2; |
| while (idx < end && lines.get(idx + 2) < ptr) |
| idx++; |
| return idx; |
| } |
| |
| private static int findReverseLine(IntList lines, int idx, int ptr) { |
| while (0 < idx && ptr <= lines.get(idx)) |
| idx--; |
| return idx; |
| } |
| |
| /** |
| * Compute a hash code for a region. |
| * |
| * @param raw |
| * the raw file content. |
| * @param ptr |
| * first byte of the region to hash. |
| * @param end |
| * 1 past the last byte of the region. |
| * @return hash code for the region <code>[ptr, end)</code> of raw. |
| */ |
| protected abstract int hashRegion(byte[] raw, int ptr, int end); |
| } |