hg4j: src/org/tmatesoft/hg/internal/AnnotateFacility.java annotate

annotate src/org/tmatesoft/hg/internal/AnnotateFacility.java @ 552:45751456b471

Annotate file changes through few revisions, walking either direction (old to new and vice versa)

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Wed, 20 Feb 2013 22:23:50 +0100
parents	4ea0351ca878
children	093a2022dad5

rev	line source
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	1 /*
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	2 * Copyright (c) 2013 TMate Software Ltd
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	3 *
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	4 * This program is free software; you can redistribute it and/or modify
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	5 * it under the terms of the GNU General Public License as published by
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	6 * the Free Software Foundation; version 2 of the License.
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	7 *
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	8 * This program is distributed in the hope that it will be useful,
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	11 * GNU General Public License for more details.
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	12 *
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	13 * For information on how to redistribute this software under
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	14 * the terms of a license other than GNU General Public License
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	15 * contact TMate Software at support@hg4j.com
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	16 */
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	17 package org.tmatesoft.hg.internal;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	18
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	19 import static org.tmatesoft.hg.repo.HgRepository.NO_REVISION;
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	20 import static org.tmatesoft.hg.repo.HgRepository.TIP;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	21
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	22 import java.util.BitSet;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	23 import java.util.HashSet;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	24 import java.util.LinkedHashMap;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	25 import java.util.LinkedList;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	26 import java.util.ListIterator;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	27
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	28 import org.tmatesoft.hg.core.HgIterateDirection;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	29 import org.tmatesoft.hg.core.Nodeid;
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	30 import org.tmatesoft.hg.internal.DiffHelper.LineSequence;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	31 import org.tmatesoft.hg.repo.HgDataFile;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	32 import org.tmatesoft.hg.repo.HgInvalidStateException;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	33 import org.tmatesoft.hg.util.CancelledException;
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	34 import org.tmatesoft.hg.util.Pair;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	35
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	36 /**
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	37 *
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	38 * @author Artem Tikhomirov
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	39 * @author TMate Software Ltd.
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	40 */
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	41 @Experimental(reason="work in progress")
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	42 public class AnnotateFacility {
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	43
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	44 /**
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	45 * mimic 'hg diff -r clogRevIndex1 -r clogRevIndex2'
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	46 */
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	47 public void diff(HgDataFile df, int clogRevIndex1, int clogRevIndex2, BlockInspector insp) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	48 int fileRevIndex1 = fileRevIndex(df, clogRevIndex1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	49 int fileRevIndex2 = fileRevIndex(df, clogRevIndex2);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	50 FileLinesCache fileInfoCache = new FileLinesCache(df, 5);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	51 LineSequence c1 = fileInfoCache.lines(fileRevIndex1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	52 LineSequence c2 = fileInfoCache.lines(fileRevIndex2);
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	53 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	54 pg.init(c1, c2);
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	55 pg.findMatchingBlocks(new BlameBlockInspector(insp, clogRevIndex1, clogRevIndex2));
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	56 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	57
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	58 public void annotate(HgDataFile df, int changelogRevisionIndex, BlockInspector insp, HgIterateDirection iterateOrder) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	59 if (!df.exists()) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	60 return;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	61 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	62 // Note, changelogRevisionIndex may be TIP, while #implAnnotateChange doesn't tolerate constants
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	63 //
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	64 // XXX df.indexWalk(0, fileRevIndex, ) might be more effective
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	65 int fileRevIndex = fileRevIndex(df, changelogRevisionIndex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	66 int[] fileRevParents = new int[2];
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	67 IntVector fileParentRevs = new IntVector((fileRevIndex+1) * 2, 0);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	68 fileParentRevs.add(NO_REVISION, NO_REVISION);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	69 for (int i = 1; i <= fileRevIndex; i++) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	70 df.parents(i, fileRevParents, null, null);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	71 fileParentRevs.add(fileRevParents[0], fileRevParents[1]);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	72 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	73 // collect file revisions to visit, from newest to oldest
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	74 IntVector fileRevsToVisit = new IntVector(fileRevIndex + 1, 0);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	75 LinkedList<Integer> queue = new LinkedList<Integer>();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	76 BitSet seen = new BitSet(fileRevIndex + 1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	77 queue.add(fileRevIndex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	78 do {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	79 int x = queue.removeFirst();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	80 if (seen.get(x)) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	81 continue;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	82 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	83 seen.set(x);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	84 fileRevsToVisit.add(x);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	85 int p1 = fileParentRevs.get(2*x);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	86 int p2 = fileParentRevs.get(2*x + 1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	87 if (p1 != NO_REVISION) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	88 queue.addLast(p1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	89 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	90 if (p2 != NO_REVISION) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	91 queue.addLast(p2);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	92 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	93 } while (!queue.isEmpty());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	94 FileLinesCache fileInfoCache = new FileLinesCache(df, 10);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	95 // fileRevsToVisit now { r10, r7, r6, r5, r0 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	96 // and we'll iterate it from behind, e.g. old to new unless reversed
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	97 if (iterateOrder == HgIterateDirection.NewToOld) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	98 fileRevsToVisit.reverse();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	99 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	100 for (int i = fileRevsToVisit.size() - 1; i >= 0; i--) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	101 int fri = fileRevsToVisit.get(i);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	102 int clogRevIndex = df.getChangesetRevisionIndex(fri);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	103 fileRevParents[0] = fileParentRevs.get(fri * 2);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	104 fileRevParents[1] = fileParentRevs.get(fri * 2 + 1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	105 implAnnotateChange(fileInfoCache, clogRevIndex, fri, fileRevParents, insp);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	106 }
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	107 }
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	108
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	109 /**
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	110 * Annotate file revision, line by line.
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	111 */
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	112 public void annotate(HgDataFile df, int changelogRevisionIndex, LineInspector insp) {
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	113 if (!df.exists()) {
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	114 return;
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	115 }
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	116 FileAnnotation fa = new FileAnnotation(insp);
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	117 annotate(df, changelogRevisionIndex, fa, HgIterateDirection.NewToOld);
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	118 }
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	119
544 7f5998a9619d Refactor PatchGenerator to be generic and welcome sequence of any nature Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 543 diff changeset	120 /**
7f5998a9619d Refactor PatchGenerator to be generic and welcome sequence of any nature Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 543 diff changeset	121 * Annotates changes of the file against its parent(s)
7f5998a9619d Refactor PatchGenerator to be generic and welcome sequence of any nature Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 543 diff changeset	122 */
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	123 public void annotateChange(HgDataFile df, int changelogRevisionIndex, BlockInspector insp) {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	124 // TODO detect if file is text/binary (e.g. looking for chars < ' ' and not \t\r\n\f
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	125 int fileRevIndex = fileRevIndex(df, changelogRevisionIndex);
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	126 int[] fileRevParents = new int[2];
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	127 df.parents(fileRevIndex, fileRevParents, null, null);
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	128 if (changelogRevisionIndex == TIP) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	129 changelogRevisionIndex = df.getChangesetRevisionIndex(fileRevIndex);
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	130 }
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	131 implAnnotateChange(new FileLinesCache(df, 5), changelogRevisionIndex, fileRevIndex, fileRevParents, insp);
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	132 }
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	133
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	134 private void implAnnotateChange(FileLinesCache fl, int csetRevIndex, int fileRevIndex, int[] fileParentRevs, BlockInspector insp) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	135 final LineSequence fileRevLines = fl.lines(fileRevIndex);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	136 if (fileParentRevs[0] != NO_REVISION && fileParentRevs[1] != NO_REVISION) {
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	137 LineSequence p1Lines = fl.lines(fileParentRevs[0]);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	138 LineSequence p2Lines = fl.lines(fileParentRevs[1]);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	139 int p1ClogIndex = fl.getChangesetRevisionIndex(fileParentRevs[0]);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	140 int p2ClogIndex = fl.getChangesetRevisionIndex(fileParentRevs[1]);
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	141 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	142 pg.init(p2Lines, fileRevLines);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	143 EqualBlocksCollector p2MergeCommon = new EqualBlocksCollector();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	144 pg.findMatchingBlocks(p2MergeCommon);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	145 //
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	146 pg.init(p1Lines);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	147 BlameBlockInspector bbi = new BlameBlockInspector(insp, p1ClogIndex, csetRevIndex);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	148 bbi.setMergeParent2(p2MergeCommon, p2ClogIndex);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	149 pg.findMatchingBlocks(bbi);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	150 } else if (fileParentRevs[0] == fileParentRevs[1]) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	151 // may be equal iff both are unset
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	152 assert fileParentRevs[0] == NO_REVISION;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	153 // everything added
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	154 BlameBlockInspector bbi = new BlameBlockInspector(insp, NO_REVISION, csetRevIndex);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	155 bbi.begin(LineSequence.newlines(new byte[0]), fileRevLines);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	156 bbi.match(0, fileRevLines.chunkCount()-1, 0);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	157 bbi.end();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	158 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	159 int soleParent = fileParentRevs[0] == NO_REVISION ? fileParentRevs[1] : fileParentRevs[0];
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	160 assert soleParent != NO_REVISION;
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	161 LineSequence parentLines = fl.lines(soleParent);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	162
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	163 int parentChangesetRevIndex = fl.getChangesetRevisionIndex(soleParent);
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	164 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	165 pg.init(parentLines, fileRevLines);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	166 pg.findMatchingBlocks(new BlameBlockInspector(insp, parentChangesetRevIndex, csetRevIndex));
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	167 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	168 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	169
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	170 private static int fileRevIndex(HgDataFile df, int csetRevIndex) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	171 Nodeid fileRev = df.getRepo().getManifest().getFileRevision(csetRevIndex, df.getPath());
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	172 return df.getRevisionIndex(fileRev);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	173 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	174
552 45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	175 private static class FileLinesCache {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	176 private final HgDataFile df;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	177 private final LinkedList<Pair<Integer, LineSequence>> lruCache;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	178 private final int limit;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	179 private IntMap<Integer> fileToClogIndexMap = new IntMap<Integer>(20);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	180
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	181 public FileLinesCache(HgDataFile file, int lruLimit) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	182 df = file;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	183 limit = lruLimit;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	184 lruCache = new LinkedList<Pair<Integer, LineSequence>>();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	185 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	186
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	187 public int getChangesetRevisionIndex(int fileRevIndex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	188 Integer cached = fileToClogIndexMap.get(fileRevIndex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	189 if (cached == null) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	190 cached = df.getChangesetRevisionIndex(fileRevIndex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	191 fileToClogIndexMap.put(fileRevIndex, cached);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	192 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	193 return cached.intValue();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	194 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	195
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	196 public LineSequence lines(int fileRevIndex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	197 Pair<Integer, LineSequence> cached = checkCache(fileRevIndex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	198 if (cached != null) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	199 return cached.second();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	200 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	201 try {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	202 ByteArrayChannel c;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	203 df.content(fileRevIndex, c = new ByteArrayChannel());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	204 LineSequence rv = LineSequence.newlines(c.toArray());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	205 lruCache.addFirst(new Pair<Integer, LineSequence>(fileRevIndex, rv));
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	206 if (lruCache.size() > limit) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	207 lruCache.removeLast();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	208 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	209 return rv;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	210 } catch (CancelledException ex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	211 // TODO likely it was bad idea to throw cancelled exception from content()
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	212 // deprecate and provide alternative?
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	213 HgInvalidStateException ise = new HgInvalidStateException("ByteArrayChannel never throws CancelledException");
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	214 ise.initCause(ex);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	215 throw ise;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	216 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	217 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	218
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	219 private Pair<Integer,LineSequence> checkCache(int fileRevIndex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	220 Pair<Integer, LineSequence> rv = null;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	221 for (ListIterator<Pair<Integer, LineSequence>> it = lruCache.listIterator(); it.hasNext(); ) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	222 Pair<Integer, LineSequence> p = it.next();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	223 if (p.first() == fileRevIndex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	224 rv = p;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	225 it.remove();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	226 break;
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	227 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	228 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	229 if (rv != null) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	230 lruCache.addFirst(rv);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	231 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 551 diff changeset	232 return rv;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	233 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	234 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	235
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	236 @Callback
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	237 public interface BlockInspector {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	238 void same(EqualBlock block);
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	239 void added(AddBlock block);
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	240 void changed(ChangeBlock block);
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	241 void deleted(DeleteBlock block);
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	242 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	243
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	244 @Callback
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	245 public interface BlockInspectorEx extends BlockInspector { // XXX better name
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	246 // XXX perhaps, shall pass object instead of separate values for future extension?
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	247 void start(int originLineCount, int targetLineCount);
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	248 void done();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	249 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	250
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	251 public interface Block {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	252 int originChangesetIndex();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	253 int targetChangesetIndex();
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	254 // boolean isMergeRevision();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	255 // int fileRevisionIndex();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	256 // int originFileRevisionIndex();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	257 // String[] lines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	258 // byte[] data();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	259 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	260
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	261 public interface EqualBlock extends Block {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	262 int originStart();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	263 int targetStart();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	264 int length();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	265 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	266
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	267 public interface AddBlock extends Block {
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	268 int insertedAt(); // line index in the old file
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	269 int firstAddedLine();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	270 int totalAddedLines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	271 String[] addedLines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	272 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	273 public interface DeleteBlock extends Block {
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	274 int removedAt(); // line index in the new file
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	275 int firstRemovedLine();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	276 int totalRemovedLines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	277 String[] removedLines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	278 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	279 public interface ChangeBlock extends AddBlock, DeleteBlock {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	280 }
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	281
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	282 @Callback
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	283 public interface LineInspector {
548 ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	284 /**
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	285 * Not necessarily invoked sequentially by line numbers
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	286 */
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	287 void line(int lineNumber, int changesetRevIndex, LineDescriptor ld);
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	288 }
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	289
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	290 public interface LineDescriptor {
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	291 int totalLines();
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	292 }
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	293
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	294
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	295
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	296 static class BlameBlockInspector extends DiffHelper.DeltaInspector<LineSequence> {
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	297 private final BlockInspector insp;
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	298 private final int csetOrigin;
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	299 private final int csetTarget;
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	300 private EqualBlocksCollector p2MergeCommon;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	301 private int csetMergeParent;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	302 private IntVector mergeRanges;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	303
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	304 public BlameBlockInspector(BlockInspector inspector, int originCset, int targetCset) {
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	305 assert inspector != null;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	306 insp = inspector;
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	307 csetOrigin = originCset;
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	308 csetTarget = targetCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	309 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	310
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	311 public void setMergeParent2(EqualBlocksCollector p2Merge, int parentCset2) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	312 p2MergeCommon = p2Merge;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	313 csetMergeParent = parentCset2;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	314 mergeRanges = new IntVector(310, 310);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	315 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	316
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	317 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	318 public void begin(LineSequence s1, LineSequence s2) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	319 super.begin(s1, s2);
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	320 if (insp instanceof BlockInspectorEx) {
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	321 ((BlockInspectorEx) insp).start(s1.chunkCount() - 1, s2.chunkCount() - 1);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	322 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	323 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	324
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	325 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	326 public void end() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	327 super.end();
546 cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	328 if(insp instanceof BlockInspectorEx) {
cd78e8b9d7bc File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 545 diff changeset	329 ((BlockInspectorEx) insp).done();
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	330 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	331 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	332
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	333 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	334 protected void changed(int s1From, int s1To, int s2From, int s2To) {
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	335 if (p2MergeCommon != null) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	336 mergeRanges.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	337 p2MergeCommon.combineAndMarkRangesWithTarget(s2From, s2To - s2From, csetOrigin, csetMergeParent, mergeRanges);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	338
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	339 /*
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	340 * Usecases:
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	341 * 3 lines changed to 10 lines. range of 10 lines breaks down to 2 from p2, 3 from p1, and 5 from p2.
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	342 * We report: 2 lines changed to 2(p2), then 1 line changed with 3(p1) and 5 lines added from p2.
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	343 *
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	344 * 10 lines changed to 3 lines, range of 3 lines breaks down to 2 line from p1 and 1 line from p2.
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	345 * We report: 2 lines changed to 2(p1) and 8 lines changed to 1(p2)
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	346 */
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	347 int s1TotalLines = s1To - s1From, s1ConsumedLines = 0, s1Start = s1From;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	348
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	349 for (int i = 0; i < mergeRanges.size(); i += 3) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	350 final int rangeOrigin = mergeRanges.get(i);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	351 final int rangeStart = mergeRanges.get(i+1);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	352 final int rangeLen = mergeRanges.get(i+2);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	353 final boolean lastRange = i+3 >= mergeRanges.size();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	354 final int s1LinesLeft = s1TotalLines - s1ConsumedLines;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	355 // how many lines we may reported as changed (don't use more than in range unless it's the very last range)
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	356 final int s1LinesToBorrow = lastRange ? s1LinesLeft : Math.min(s1LinesLeft, rangeLen);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	357 if (s1LinesToBorrow > 0) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	358 BlockImpl2 block = new BlockImpl2(seq1, seq2, s1Start, s1LinesToBorrow, rangeStart, rangeLen, s1Start, rangeStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	359 block.setOriginAndTarget(rangeOrigin, csetTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	360 insp.changed(block);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	361 s1ConsumedLines += s1LinesToBorrow;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	362 s1Start += s1LinesToBorrow;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	363 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	364 BlockImpl2 block = getAddBlock(rangeStart, rangeLen, s1Start);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	365 block.setOriginAndTarget(rangeOrigin, csetTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	366 insp.added(block);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	367 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	368 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	369 if (s1ConsumedLines != s1TotalLines) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	370 throw new HgInvalidStateException(String.format("Expected to process %d lines, but actually was %d", s1TotalLines, s1ConsumedLines));
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	371 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	372 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	373 BlockImpl2 block = new BlockImpl2(seq1, seq2, s1From, s1To-s1From, s2From, s2To - s2From, s1From, s2From);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	374 block.setOriginAndTarget(csetOrigin, csetTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	375 insp.changed(block);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	376 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	377 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	378
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	379 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	380 protected void added(int s1InsertPoint, int s2From, int s2To) {
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	381 if (p2MergeCommon != null) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	382 mergeRanges.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	383 p2MergeCommon.combineAndMarkRangesWithTarget(s2From, s2To - s2From, csetOrigin, csetMergeParent, mergeRanges);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	384 int insPoint = s1InsertPoint; // track changes to insertion point
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	385 for (int i = 0; i < mergeRanges.size(); i += 3) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	386 int rangeOrigin = mergeRanges.get(i);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	387 int rangeStart = mergeRanges.get(i+1);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	388 int rangeLen = mergeRanges.get(i+2);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	389 BlockImpl2 block = getAddBlock(rangeStart, rangeLen, insPoint);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	390 block.setOriginAndTarget(rangeOrigin, csetTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	391 insp.added(block);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	392 // indicate insPoint moved down number of lines we just reported
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	393 insPoint += rangeLen;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	394 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	395 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	396 BlockImpl2 block = getAddBlock(s2From, s2To - s2From, s1InsertPoint);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	397 block.setOriginAndTarget(csetOrigin, csetTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	398 insp.added(block);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	399 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	400 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	401
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	402 @Override
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	403 protected void deleted(int s2DeletePoint, int s1From, int s1To) {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	404 BlockImpl2 block = new BlockImpl2(seq1, null, s1From, s1To - s1From, -1, -1, -1, s2DeletePoint);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	405 block.setOriginAndTarget(csetOrigin, csetTarget);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	406 insp.deleted(block);
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	407 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	408
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	409 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	410 protected void unchanged(int s1From, int s2From, int length) {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	411 BlockImpl1 block = new BlockImpl1(s1From, s2From, length);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	412 block.setOriginAndTarget(csetOrigin, csetTarget);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	413 insp.same(block);
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	414 }
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	415
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	416 private BlockImpl2 getAddBlock(int start, int len, int insPoint) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	417 return new BlockImpl2(null, seq2, -1, -1, start, len, insPoint, -1);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	418 }
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	419 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	420
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	421 static class BlockImpl implements Block {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	422
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	423 private int originCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	424 private int targetCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	425
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	426 void setOriginAndTarget(int originChangesetIndex, int targetChangesetIndex) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	427 // XXX perhaps, shall be part of Inspector API, rather than Block's
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	428 // as they don't change between blocks (although the moment about merged revisions)
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	429 // is not yet clear to me
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	430 originCset = originChangesetIndex;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	431 targetCset = targetChangesetIndex;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	432 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	433
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	434 public int originChangesetIndex() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	435 return originCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	436 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	437
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	438 public int targetChangesetIndex() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	439 return targetCset;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	440 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	441 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	442
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	443 static class BlockImpl1 extends BlockImpl implements EqualBlock {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	444 private final int start1, start2;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	445 private final int length;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	446
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	447 BlockImpl1(int blockStartSeq1, int blockStartSeq2, int blockLength) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	448 start1 = blockStartSeq1;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	449 start2 = blockStartSeq2;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	450 length = blockLength;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	451 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	452
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	453 public int originStart() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	454 return start1;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	455 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	456
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	457 public int targetStart() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	458 return start2;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	459 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	460
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	461 public int length() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	462 return length;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	463 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	464
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	465 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	466 public String toString() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	467 return String.format("@@ [%d..%d) == [%d..%d) @@", start1, start1+length, start2, start2+length);
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	468 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	469 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	470
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	471 static class BlockImpl2 extends BlockImpl implements ChangeBlock {
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	472
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	473 private final LineSequence oldSeq;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	474 private final LineSequence newSeq;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	475 private final int s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	476 private final int s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	477 private final int s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	478 private final int s2Len;
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	479 private final int s1InsertPoint;
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	480 private final int s2DeletePoint;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	481
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	482 public BlockImpl2(LineSequence s1, LineSequence s2, int s1Start, int s1Len, int s2Start, int s2Len, int s1InsertPoint, int s2DeletePoint) {
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	483 oldSeq = s1;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	484 newSeq = s2;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	485 this.s1Start = s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	486 this.s1Len = s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	487 this.s2Start = s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	488 this.s2Len = s2Len;
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	489 this.s1InsertPoint = s1InsertPoint;
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	490 this.s2DeletePoint = s2DeletePoint;
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	491 }
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	492
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	493 public int insertedAt() {
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	494 return s1InsertPoint;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	495 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	496
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	497 public int firstAddedLine() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	498 return s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	499 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	500
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	501 public int totalAddedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	502 return s2Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	503 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	504
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	505 public String[] addedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	506 return generateLines(totalAddedLines(), firstAddedLine());
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	507 }
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	508
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	509 public int removedAt() {
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	510 return s2DeletePoint;
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	511 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	512
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	513 public int firstRemovedLine() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	514 return s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	515 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	516
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	517 public int totalRemovedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	518 return s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	519 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	520
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	521 public String[] removedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	522 return generateLines(totalRemovedLines(), firstRemovedLine());
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	523 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	524
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	525 private String[] generateLines(int count, int startFrom) {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	526 String[] rv = new String[count];
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	527 for (int i = 0; i < count; i++) {
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	528 rv[i] = String.format("LINE %d", startFrom + i+1);
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	529 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	530 return rv;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	531 }
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	532
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	533 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	534 public String toString() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	535 if (s2DeletePoint == -1) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	536 return String.format("@@ -%d,0 +%d,%d @@", insertedAt(), firstAddedLine(), totalAddedLines());
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	537 } else if (s1InsertPoint == -1) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	538 // delete only
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	539 return String.format("@@ -%d,%d +%d,0 @@", firstRemovedLine(), totalRemovedLines(), removedAt());
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	540 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	541 return String.format("@@ -%d,%d +%d,%d @@", firstRemovedLine(), totalRemovedLines(), firstAddedLine(), totalAddedLines());
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	542 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	543 }
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	544
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	545 static class EqualBlocksCollector implements DiffHelper.MatchInspector<LineSequence> {
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	546 private final IntVector matches = new IntVector(103, 23);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	547
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	548 public void begin(LineSequence s1, LineSequence s2) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	549 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	550
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	551 public void match(int startSeq1, int startSeq2, int matchLength) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	552 matches.add(startSeq1);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	553 matches.add(startSeq2);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	554 matches.add(matchLength);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	555 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	556
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	557 public void end() {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	558 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	559
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	560 // true when specified line in origin is equal to a line in target
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	561 public boolean includesOriginLine(int ln) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	562 return includes(ln, 0);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	563 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	564
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	565 // true when specified line in target is equal to a line in origin
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	566 public boolean includesTargetLine(int ln) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	567 return includes(ln, 1);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	568 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	569
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	570 public void intersectWithTarget(int start, int length, IntVector result) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	571 int s = start;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	572 for (int l = start, x = start + length; l < x; l++) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	573 if (!includesTargetLine(l)) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	574 if (l - s > 0) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	575 result.add(s);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	576 result.add(l - s);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	577 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	578 s = l+1;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	579 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	580 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	581 if (s < start+length) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	582 result.add(s);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	583 result.add((start + length) - s);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	584 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	585 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	586
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	587 /*
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	588 * intersects [start..start+length) with ranges of target lines, and based on the intersection
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	589 * breaks initial range into smaller ranges and records them into result, with marker to indicate
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	590 * whether the range is from initial range (markerSource) or is a result of the intersection with target
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	591 * (markerTarget)
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	592 */
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	593 public void combineAndMarkRangesWithTarget(int start, int length, int markerSource, int markerTarget, IntVector result) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	594 int sourceStart = start, targetStart = start, sourceEnd = start + length;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	595 for (int l = sourceStart; l < sourceEnd; l++) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	596 if (includesTargetLine(l)) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	597 // l is from target
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	598 if (sourceStart < l) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	599 // few lines from source range were not in the target, report them
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	600 result.add(markerSource);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	601 result.add(sourceStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	602 result.add(l - sourceStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	603 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	604 // indicate the earliest line from source range to use
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	605 sourceStart = l + 1;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	606 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	607 // l is not in target
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	608 if (targetStart < l) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	609 // report lines from target range
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	610 result.add(markerTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	611 result.add(targetStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	612 result.add(l - targetStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	613 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	614 // next line may be from target
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	615 targetStart = l + 1;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	616 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	617 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	618 // if source range end with line from target, sourceStart would be == sourceEnd, and we need to add range with markerTarget
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	619 // if source range doesn't end with target line, targetStart == sourceEnd, while sourceStart < sourceEnd
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	620 if (sourceStart < sourceEnd) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	621 assert targetStart == sourceEnd;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	622 // something left from the source range
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	623 result.add(markerSource);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	624 result.add(sourceStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	625 result.add(sourceEnd - sourceStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	626 } else if (targetStart < sourceEnd) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	627 assert sourceStart == sourceEnd;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	628 result.add(markerTarget);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	629 result.add(targetStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	630 result.add(sourceEnd - targetStart);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	631 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	632 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	633
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	634 private boolean includes(int ln, int o) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	635 for (int i = 2; i < matches.size(); o += 3, i+=3) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	636 int rangeStart = matches.get(o);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	637 if (rangeStart > ln) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	638 return false;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	639 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	640 int rangeLen = matches.get(i);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	641 if (rangeStart + rangeLen > ln) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	642 return true;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	643 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	644 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	645 return false;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	646 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	647 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	648
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	649 public static void main(String[] args) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	650 EqualBlocksCollector bc = new EqualBlocksCollector();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	651 bc.match(-1, 5, 3);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	652 bc.match(-1, 10, 2);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	653 bc.match(-1, 15, 3);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	654 bc.match(-1, 20, 3);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	655 assert !bc.includesTargetLine(4);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	656 assert bc.includesTargetLine(7);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	657 assert !bc.includesTargetLine(8);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	658 assert bc.includesTargetLine(10);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	659 assert !bc.includesTargetLine(12);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	660 IntVector r = new IntVector();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	661 bc.intersectWithTarget(7, 10, r);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	662 for (int i = 0; i < r.size(); i+=2) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	663 System.out.printf("[%d..%d) ", r.get(i), r.get(i) + r.get(i+1));
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	664 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	665 System.out.println();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	666 r.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	667 bc.combineAndMarkRangesWithTarget(0, 16, 508, 514, r);
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	668 for (int i = 0; i < r.size(); i+=3) {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	669 System.out.printf("%d:[%d..%d) ", r.get(i), r.get(i+1), r.get(i+1) + r.get(i+2));
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	670 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	671 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	672 }

Mercurial > hg4j

annotate src/org/tmatesoft/hg/internal/AnnotateFacility.java @ 552:45751456b471