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

annotate src/org/tmatesoft/hg/internal/AnnotateFacility.java @ 554:a5fd757d1b5d

Access to content of annotated files through BlockData interface

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Thu, 21 Feb 2013 21:53:55 +0100
parents	093a2022dad5
children	e623aa2ca526

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.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	24 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	25
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 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	27 import org.tmatesoft.hg.core.Nodeid;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	28 import org.tmatesoft.hg.internal.AnnotateFacility.BlockData;
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	29 import org.tmatesoft.hg.internal.DiffHelper.LineSequence;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	30 import org.tmatesoft.hg.internal.DiffHelper.LineSequence.ByteChain;
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?
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	247 void start(BlockData originContent, BlockData targetContent);
545 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
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	251 /**
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	252 * Represents content of a block, either as a sequence of bytes or a
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	253 * sequence of smaller blocks (lines), if appropriate (according to usage context).
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	254 *
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	255 * This approach allows line-by-line access to content data along with complete byte sequence for the whole block, i.e.
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	256 * <pre>
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	257 * BlockData bd = addBlock.addedLines()
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	258 * // bd describes data from the addition completely.
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	259 * // elements of the BlockData are lines
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	260 * bd.elementCount() == addBlock.totalAddedLines();
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	261 * // one cat obtain complete addition with
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	262 * byte[] everythingAdded = bd.asArray();
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	263 * // or iterate line by line
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	264 * for (int i = 0; i < bd.elementCount(); i++) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	265 * byte[] lineContent = bd.elementAt(i);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	266 * String line = new String(lineContent, fileEncodingCharset);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	267 * }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	268 * where bd.elementAt(0) is the line at index addBlock.firstAddedLine()
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	269 * </pre>
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	270 *
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	271 * LineData or ChunkData?
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	272 */
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	273 public interface BlockData {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	274 BlockData elementAt(int index);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	275 int elementCount();
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	276 byte[] asArray();
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	277 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	278
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	279 public interface Block {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	280 int originChangesetIndex();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	281 int targetChangesetIndex();
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	282 // boolean isMergeRevision();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	283 // int fileRevisionIndex();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	284 // int originFileRevisionIndex();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	285 // String[] lines();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	286 // byte[] data();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	287 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	288
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	289 public interface EqualBlock extends Block {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	290 int originStart();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	291 int targetStart();
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	292 int length();
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	293 BlockData content();
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	294 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	295
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	296 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	297 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	298 int firstAddedLine();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	299 int totalAddedLines();
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	300 BlockData addedLines();
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	301 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	302 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	303 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	304 int firstRemovedLine();
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	305 int totalRemovedLines();
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	306 BlockData removedLines();
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	307 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	308 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	309 }
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	310
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	311 @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	312 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	313 /**
ab21ac7dd833 Line-by-line annotation API and support code in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 546 diff changeset	314 * 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	315 */
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	316 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	317 }
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	318
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	319 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	320 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	321 }
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	322
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	323
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	324
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	325 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	326 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	327 private final int csetOrigin;
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	328 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	329 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	330 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	331 private IntVector mergeRanges;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	332 private ContentBlock originContent, targetContent;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	333
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	334 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	335 assert inspector != null;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	336 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	337 csetOrigin = originCset;
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	338 csetTarget = targetCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	339 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	340
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	341 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	342 p2MergeCommon = p2Merge;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	343 csetMergeParent = parentCset2;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	344 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	345 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	346
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	347 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	348 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	349 super.begin(s1, s2);
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	350 originContent = new ContentBlock(s1);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	351 targetContent = new ContentBlock(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	352 if (insp instanceof BlockInspectorEx) {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	353 ((BlockInspectorEx) insp).start(originContent, targetContent);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	354 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	355 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	356
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	357 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	358 public void end() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	359 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	360 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	361 ((BlockInspectorEx) insp).done();
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	362 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	363 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	364
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	365 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	366 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	367 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	368 mergeRanges.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	369 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	370
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 * Usecases:
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	373 * 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	374 * 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	375 *
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	376 * 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	377 * 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	378 */
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	379 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	380
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	381 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	382 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	383 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	384 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	385 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	386 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	387 // 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	388 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	389 if (s1LinesToBorrow > 0) {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	390 ChangeBlockImpl block = new ChangeBlockImpl(originContent, targetContent, s1Start, s1LinesToBorrow, rangeStart, rangeLen, s1Start, rangeStart);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	391 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	392 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	393 s1ConsumedLines += s1LinesToBorrow;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	394 s1Start += s1LinesToBorrow;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	395 } else {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	396 ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, s1Start);
549 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(rangeOrigin, 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 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	400 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	401 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	402 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	403 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	404 } else {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	405 ChangeBlockImpl block = new ChangeBlockImpl(originContent, targetContent, s1From, s1To-s1From, s2From, s2To - s2From, s1From, s2From);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	406 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	407 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	408 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	409 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	410
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	411 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	412 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	413 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	414 mergeRanges.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	415 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	416 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	417 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	418 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	419 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	420 int rangeLen = mergeRanges.get(i+2);
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	421 ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, insPoint);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	422 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	423 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	424 // 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	425 insPoint += rangeLen;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	426 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	427 } else {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	428 ChangeBlockImpl block = getAddBlock(s2From, s2To - s2From, s1InsertPoint);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	429 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	430 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	431 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	432 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	433
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	434 @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	435 protected void deleted(int s2DeletePoint, int s1From, int s1To) {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	436 ChangeBlockImpl block = new ChangeBlockImpl(originContent, 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	437 block.setOriginAndTarget(csetOrigin, csetTarget);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	438 insp.deleted(block);
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	439 }
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 @Override
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	442 protected void unchanged(int s1From, int s2From, int length) {
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	443 EqualBlockImpl block = new EqualBlockImpl(s1From, s2From, length, targetContent);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	444 block.setOriginAndTarget(csetOrigin, csetTarget);
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	445 insp.same(block);
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	446 }
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	447
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	448 private ChangeBlockImpl getAddBlock(int start, int len, int insPoint) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	449 return new ChangeBlockImpl(null, targetContent, -1, -1, start, len, insPoint, -1);
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	450 }
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	451 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	452
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	453 static class BlockImpl implements Block {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	454
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	455 private int originCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	456 private int targetCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	457
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	458 void setOriginAndTarget(int originChangesetIndex, int targetChangesetIndex) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	459 // 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	460 // 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	461 // is not yet clear to me
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	462 originCset = originChangesetIndex;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	463 targetCset = targetChangesetIndex;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	464 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	465
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	466 public int originChangesetIndex() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	467 return originCset;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	468 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	469
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	470 public int targetChangesetIndex() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	471 return targetCset;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	472 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	473 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	474
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	475 static class EqualBlockImpl extends BlockImpl implements EqualBlock {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	476 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	477 private final int length;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	478 private final ContentBlock fullContent;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	479 private FilterBlock myContent;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	480
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	481 EqualBlockImpl(int blockStartSeq1, int blockStartSeq2, int blockLength, ContentBlock targetContent) {
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	482 start1 = blockStartSeq1;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	483 start2 = blockStartSeq2;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	484 length = blockLength;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	485 fullContent = targetContent;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	486 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	487
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	488 public int originStart() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	489 return start1;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	490 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	491
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	492 public int targetStart() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	493 return start2;
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	494 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	495
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	496 public int length() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	497 return length;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	498 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	499
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	500 public BlockData content() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	501 if (myContent == null) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	502 myContent = new FilterBlock(fullContent, start2, length);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	503 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	504 return myContent;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	505 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	506
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	507 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	508 public String toString() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	509 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	510 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	511 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	512
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	513 static class ChangeBlockImpl extends BlockImpl implements ChangeBlock {
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	514
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	515 private final ContentBlock oldContent;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	516 private final ContentBlock newContent;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	517 private final int s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	518 private final int s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	519 private final int s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	520 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	521 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	522 private final int s2DeletePoint;
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	523 private FilterBlock addedBlock, removedBlock;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	524
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	525 public ChangeBlockImpl(ContentBlock c1, ContentBlock c2, int s1Start, int s1Len, int s2Start, int s2Len, int s1InsertPoint, int s2DeletePoint) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	526 oldContent = c1;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	527 newContent = c2;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	528 this.s1Start = s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	529 this.s1Len = s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	530 this.s2Start = s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	531 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	532 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	533 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	534 }
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	535
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	536 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	537 return s1InsertPoint;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	538 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	539
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	540 public int firstAddedLine() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	541 return s2Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	542 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	543
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	544 public int totalAddedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	545 return s2Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	546 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	547
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	548 public BlockData addedLines() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	549 if (addedBlock == null) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	550 addedBlock = new FilterBlock(newContent, firstAddedLine(), totalAddedLines());
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	551 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	552 return addedBlock;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	553 }
543 1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	554
1e95f48d9886 Report line index for insertion and deletion, test against 'hg diff' output Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 542 diff changeset	555 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	556 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	557 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	558
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	559 public int firstRemovedLine() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	560 return s1Start;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	561 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	562
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	563 public int totalRemovedLines() {
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	564 return s1Len;
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	565 }
a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	566
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	567 public BlockData removedLines() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	568 if (removedBlock == null) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	569 removedBlock = new FilterBlock(oldContent, firstRemovedLine(), totalRemovedLines());
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	570 }
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	571 return removedBlock;
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	572 }
545 15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	573
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	574 @Override
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	575 public String toString() {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	576 if (s2DeletePoint == -1) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	577 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	578 } else if (s1InsertPoint == -1) {
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	579 // delete only
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	580 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	581 }
15b406c7cd9d First round of annotate file is functional Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 544 diff changeset	582 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	583 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	584 }
554 a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	585
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	586 private static class SingleLine implements BlockData {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	587 private final ByteChain line;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	588
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	589 public SingleLine(ByteChain lineContent) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	590 line = lineContent;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	591 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	592
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	593 public BlockData elementAt(int index) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	594 assert false;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	595 return null;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	596 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	597
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	598 public int elementCount() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	599 return 0;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	600 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	601
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	602 public byte[] asArray() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	603 return line.data();
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	604 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	605 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	606
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	607 private static class ContentBlock implements BlockData {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	608 private final LineSequence seq;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	609
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	610 public ContentBlock(LineSequence sequence) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	611 seq = sequence;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	612 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	613
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	614 public BlockData elementAt(int index) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	615 return new SingleLine(seq.chunk(index));
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	616 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	617
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	618 public int elementCount() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	619 return seq.chunkCount() - 1;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	620 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	621
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	622 public byte[] asArray() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	623 return seq.data(0, seq.chunkCount() - 1);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	624 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	625 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	626
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	627 private static class FilterBlock implements BlockData {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	628 private final ContentBlock contentBlock;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	629 private final int from;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	630 private final int length;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	631
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	632 public FilterBlock(ContentBlock bd, int startFrom, int len) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	633 assert bd != null;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	634 assert startFrom + len < bd.seq.chunkCount(); // there's one extra chunk in the end, so strict less is ok
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	635 contentBlock = bd;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	636 from = startFrom;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	637 length = len;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	638 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	639
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	640 public BlockData elementAt(int index) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	641 if (index < 0 \|\| index >= length) {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	642 throw new IllegalArgumentException(String.format("Expected value from [0..%d), got %d", length, index));
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	643 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	644 return contentBlock.elementAt(from + index);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	645 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	646
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	647 public int elementCount() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	648 return length;
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	649 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	650
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	651 public byte[] asArray() {
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	652 return contentBlock.seq.data(from, from + length);
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	653 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	654 }
a5fd757d1b5d Access to content of annotated files through BlockData interface Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 553 diff changeset	655
549 83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	656
551 4ea0351ca878 Better (precise) name for diff facility, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 549 diff changeset	657 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	658 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	659
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	660 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	661 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	662
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	663 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	664 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	665 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	666 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	667 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	668
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	669 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	670 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	671
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	672 // 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	673 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	674 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	675 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	676
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	677 // 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	678 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	679 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	680 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	681
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	682 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	683 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	684 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	685 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	686 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	687 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	688 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	689 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	690 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	691 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	692 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	693 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	694 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	695 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	696 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	697 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	698
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	699 /*
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	700 * 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	701 * 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	702 * 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	703 * (markerTarget)
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	704 */
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	705 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	706 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	707 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	708 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	709 // 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	710 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	711 // 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	712 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	713 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	714 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	715 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	716 // 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	717 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	718 } else {
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	719 // 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	720 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	721 // 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	722 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	723 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	724 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	725 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	726 // 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	727 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	728 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	729 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	730 // 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	731 // 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	732 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	733 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	734 // 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	735 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	736 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	737 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	738 } 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	739 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	740 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	741 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	742 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	743 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	744 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	745
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	746 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	747 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	748 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	749 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	750 return false;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	751 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	752 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	753 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	754 return true;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	755 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	756 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	757 return false;
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	758 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	759 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	760
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	761 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	762 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	763 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	764 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	765 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	766 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	767 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	768 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	769 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	770 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	771 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	772 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	773 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	774 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	775 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	776 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	777 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	778 r.clear();
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	779 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	780 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	781 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	782 }
83afa680555d Annotate merge revision (combined diff against two parents without looking further) Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 548 diff changeset	783 }
542 a71a05ec11bc Towards annotate/blame support: general outline of the functionality Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	784 }

Mercurial > hg4j

annotate src/org/tmatesoft/hg/internal/AnnotateFacility.java @ 554:a5fd757d1b5d