jhg: src/org/tmatesoft/hg/internal/BlameHelper.java annotate

annotate src/org/tmatesoft/hg/internal/BlameHelper.java @ 680:58a6900f845d

Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Sun, 21 Jul 2013 17:15:34 +0200
parents	8625cba0a5a8
children

rev	line source
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	1 /*
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	2 * Copyright (c) 2013 TMate Software Ltd
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	3 *
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	4 * This program is free software; you can redistribute it and/or modify
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	5 * it under the terms of the GNU General Public License as published by
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	6 * the Free Software Foundation; version 2 of the License.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	7 *
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	8 * This program is distributed in the hope that it will be useful,
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	11 * GNU General Public License for more details.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	12 *
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	13 * For information on how to redistribute this software under
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	14 * the terms of a license other than GNU General Public License
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	15 * contact TMate Software at support@hg4j.com
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	16 */
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	17 package org.tmatesoft.hg.internal;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	18
625 b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	19 import static org.tmatesoft.hg.core.HgIterateDirection.OldToNew;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	20 import static org.tmatesoft.hg.repo.HgRepository.NO_REVISION;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	21
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	22 import java.util.ArrayList;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	23 import java.util.Arrays;
674 cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	24 import java.util.Iterator;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	25 import java.util.LinkedList;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	26 import java.util.List;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	27 import java.util.ListIterator;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	28
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	29 import org.tmatesoft.hg.core.HgCallbackTargetException;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	30 import org.tmatesoft.hg.core.Nodeid;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	31 import org.tmatesoft.hg.internal.DiffHelper.LineSequence;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	32 import org.tmatesoft.hg.internal.DiffHelper.LineSequence.ByteChain;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	33 import org.tmatesoft.hg.internal.diff.DiffRangeMap;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	34 import org.tmatesoft.hg.internal.diff.DiffRangeMap.RangePair;
629 5f52074707b2 Diff/blame methods as command, their residence in HgDataFile was a mistake Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 628 diff changeset	35 import org.tmatesoft.hg.core.HgBlameInspector;
5f52074707b2 Diff/blame methods as command, their residence in HgDataFile was a mistake Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 628 diff changeset	36 import org.tmatesoft.hg.core.HgBlameInspector.*;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	37 import org.tmatesoft.hg.repo.HgChangelog;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	38 import org.tmatesoft.hg.repo.HgDataFile;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	39 import org.tmatesoft.hg.repo.HgInvalidStateException;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	40 import org.tmatesoft.hg.repo.HgParentChildMap;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	41 import org.tmatesoft.hg.repo.HgRepository;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	42 import org.tmatesoft.hg.repo.HgRevisionMap;
628 6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 625 diff changeset	43 import org.tmatesoft.hg.repo.HgRuntimeException;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	44 import org.tmatesoft.hg.util.Adaptable;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	45 import org.tmatesoft.hg.util.CancelledException;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	46 import org.tmatesoft.hg.util.Pair;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	47
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	48 /**
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	49 * Blame implementation
603 707b5c7c6fa4 Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 569 diff changeset	50 * @see HgBlameInspector
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	51 * @author Artem Tikhomirov
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	52 * @author TMate Software Ltd.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	53 */
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	54 public class BlameHelper {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	55
603 707b5c7c6fa4 Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 569 diff changeset	56 private final HgBlameInspector insp;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	57 private FileLinesCache linesCache;
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	58 private HgParentChildMap<HgChangelog> clogMap;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	59
625 b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	60 public BlameHelper(HgBlameInspector inspector) {
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	61 insp = inspector;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	62 }
625 b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	63
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	64 /**
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	65 * Build history of the file for the specified range (follow renames if necessary). This history
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	66 * is used to access various file revision data during subsequent {@link #diff(int, int, int, int)} and
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	67 * {@link #annotateChange(int, int, int[], int[])} calls. Callers can use returned history for own approaches
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	68 * to iteration over file history.
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	69
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	70 * <p>NOTE, clogRevIndexEnd has to list name of the supplied file in the corresponding manifest,
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	71 * as it's not possible to trace rename history otherwise.
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	72 */
628 6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 625 diff changeset	73 public FileHistory prepare(HgDataFile df, int clogRevIndexStart, int clogRevIndexEnd) throws HgRuntimeException {
625 b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	74 assert clogRevIndexStart <= clogRevIndexEnd;
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	75 FileHistory fileHistory = new FileHistory(df, clogRevIndexStart, clogRevIndexEnd);
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	76 fileHistory.build();
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	77 int cacheHint = 5; // cache comes useful when we follow merge branches and don't want to
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	78 // parse base revision twice. There's no easy way to determine max(distance(all(base,merge))),
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	79 // hence the heuristics to use the longest history chunk:
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	80 for (FileRevisionHistoryChunk c : fileHistory.iterate(OldToNew)) {
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	81 // iteration order is not important here
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	82 if (c.revisionCount() > cacheHint) {
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	83 cacheHint = c.revisionCount();
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	84 }
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	85 }
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	86 linesCache = new FileLinesCache(cacheHint);
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	87 for (FileRevisionHistoryChunk fhc : fileHistory.iterate(OldToNew)) {
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	88 // iteration order is not important here
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	89 linesCache.useFileUpTo(fhc.getFile(), fhc.getEndChangeset());
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	90 }
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	91 return fileHistory;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	92 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	93
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	94 // NO_REVISION is not allowed as any argument
628 6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 625 diff changeset	95 public void diff(int fileRevIndex1, int clogRevIndex1, int fileRevIndex2, int clogRevIndex2) throws HgCallbackTargetException, HgRuntimeException {
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	96 HgDataFile targetFile = linesCache.getFile(clogRevIndex2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	97 LineSequence c1 = linesCache.lines(clogRevIndex1, fileRevIndex1);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	98 LineSequence c2 = linesCache.lines(clogRevIndex2, fileRevIndex2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	99 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	100 pg.init(c1, c2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	101 BlameBlockInspector bbi = new BlameBlockInspector(targetFile, fileRevIndex2, insp, clogRevIndex1, clogRevIndex2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	102 pg.findMatchingBlocks(bbi);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	103 bbi.checkErrors();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	104 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	105
628 6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 625 diff changeset	106 public void annotateChange(int fileRevIndex, int csetRevIndex, int[] fileParentRevs, int[] fileParentClogRevs) throws HgCallbackTargetException, HgRuntimeException {
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	107 HgDataFile targetFile = linesCache.getFile(csetRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	108 final LineSequence fileRevLines = linesCache.lines(csetRevIndex, fileRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	109 if (fileParentClogRevs[0] != NO_REVISION && fileParentClogRevs[1] != NO_REVISION) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	110 int p1ClogIndex = fileParentClogRevs[0];
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	111 int p2ClogIndex = fileParentClogRevs[1];
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	112 LineSequence p1Lines = linesCache.lines(p1ClogIndex, fileParentRevs[0]);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	113 LineSequence p2Lines = linesCache.lines(p2ClogIndex, fileParentRevs[1]);
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	114 MergeResolutionStrategy mergeResolver = createMergeStrategy(fileRevLines, p1Lines, p2Lines, csetRevIndex, fileParentClogRevs);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	115 //
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	116 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	117 pg.init(p1Lines, fileRevLines);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	118 BlameBlockInspector bbi = new BlameBlockInspector(targetFile, fileRevIndex, insp, p1ClogIndex, csetRevIndex);
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	119 bbi.setMergeParent2(mergeResolver, p2ClogIndex);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	120 pg.findMatchingBlocks(bbi);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	121 bbi.checkErrors();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	122 } else if (fileParentClogRevs[0] == fileParentClogRevs[1]) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	123 // may be equal iff both are unset
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	124 assert fileParentClogRevs[0] == NO_REVISION;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	125 // everything added
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	126 BlameBlockInspector bbi = new BlameBlockInspector(targetFile, fileRevIndex, insp, NO_REVISION, csetRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	127 bbi.begin(LineSequence.newlines(new byte[0]), fileRevLines);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	128 bbi.match(0, fileRevLines.chunkCount()-1, 0);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	129 bbi.end();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	130 bbi.checkErrors();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	131 } else {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	132 int soleParentIndex = fileParentClogRevs[0] == NO_REVISION ? 1 : 0;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	133 assert fileParentClogRevs[soleParentIndex] != NO_REVISION;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	134 LineSequence parentLines = linesCache.lines(fileParentClogRevs[soleParentIndex], fileParentRevs[soleParentIndex]);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	135
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	136 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	137 pg.init(parentLines, fileRevLines);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	138 BlameBlockInspector bbi = new BlameBlockInspector(targetFile, fileRevIndex, insp, fileParentClogRevs[soleParentIndex], csetRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	139 pg.findMatchingBlocks(bbi);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	140 bbi.checkErrors();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	141 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	142 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	143
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	144 private static final boolean useNewStrategy = Boolean.TRUE.booleanValue();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	145
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	146 private MergeResolutionStrategy createMergeStrategy(LineSequence fileRevLines, LineSequence p1Lines, LineSequence p2Lines, int csetRevIndex, int[] fileParentClogRevs) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	147 DiffHelper<LineSequence> pg = new DiffHelper<LineSequence>();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	148 if (useNewStrategy) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	149 final ArrayList<RangePairSeq> allMatches = new ArrayList<RangePairSeq>();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	150 pg.init(p2Lines, fileRevLines);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	151 pg.findAllMatchAlternatives(new DiffHelper.MatchInspector<LineSequence>() {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	152 private RangePairSeq matches;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	153
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	154 public void begin(LineSequence s1, LineSequence s2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	155 matches = new RangePairSeq();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	156 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	157
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	158 public void match(int startSeq1, int startSeq2, int matchLength) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	159 matches.add(startSeq1, startSeq2, matchLength);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	160 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	161
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	162 public void end() {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	163 if (matches.size() > 0) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	164 allMatches.add(matches);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	165 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	166 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	167
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	168 });
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	169 //
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	170 LineSequence baseLines = getBaseRevisionLines(csetRevIndex, fileParentClogRevs);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	171 pg.init(p1Lines, baseLines);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	172 DiffRangeMap p1ToBase = new DiffRangeMap().fill(pg);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	173 pg.init(baseLines, p2Lines);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	174 DiffRangeMap baseToP2 = new DiffRangeMap().fill(pg);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	175 return new MergeStrategy2(allMatches, p1ToBase, baseToP2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	176 } else {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	177 pg.init(p2Lines, fileRevLines);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	178 EqualBlocksCollector p2MergeCommon = new EqualBlocksCollector();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	179 pg.findMatchingBlocks(p2MergeCommon);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	180 return new MergeStrategy1(p2MergeCommon.matches);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	181 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	182 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	183
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	184 private LineSequence getBaseRevisionLines(int clogRevIndex, int[] fileParentClogRevs) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	185 assert fileParentClogRevs[0] >= 0;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	186 assert fileParentClogRevs[1] >= 0;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	187 HgDataFile targetFile = linesCache.getFile(clogRevIndex);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	188 final HgRepository repo = targetFile.getRepo();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	189 if (clogMap == null) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	190 // FIXME replace HgParentChildMap with revlog.indexWalk(AncestorIterator))
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	191 clogMap = new HgParentChildMap<HgChangelog>(repo.getChangelog());
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	192 clogMap.init();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	193 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	194 final HgRevisionMap<HgChangelog> m = clogMap.getRevisionMap();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	195 Nodeid ancestor = clogMap.ancestor(m.revision(fileParentClogRevs[0]), m.revision(fileParentClogRevs[1]));
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	196 final int ancestorRevIndex = m.revisionIndex(ancestor);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	197 Nodeid fr = repo.getManifest().getFileRevision(ancestorRevIndex, targetFile.getPath());
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	198 if (fr == null) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	199 return LineSequence.newlines(new byte[0]);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	200 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	201 return linesCache.lines(ancestorRevIndex, targetFile.getRevisionIndex(fr));
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	202 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	203
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	204 private static class FileLinesCache {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	205 private final LinkedList<Pair<Integer, LineSequence>> lruCache;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	206 private final int limit;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	207 private final LinkedList<Pair<Integer, HgDataFile>> files; // TODO in fact, need sparse array
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	208
625 b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	209 /**
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	210 * @param lruLimit how many parsed file revisions to keep
b4948b159ab1 Refactor internals of blame support, tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 603 diff changeset	211 */
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	212 public FileLinesCache(int lruLimit) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	213 limit = lruLimit;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	214 lruCache = new LinkedList<Pair<Integer, LineSequence>>();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	215 files = new LinkedList<Pair<Integer,HgDataFile>>();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	216 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	217
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	218 public void useFileUpTo(HgDataFile df, int clogRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	219 Pair<Integer, HgDataFile> newEntry = new Pair<Integer, HgDataFile>(clogRevIndex, df);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	220 for (ListIterator<Pair<Integer, HgDataFile>> it = files.listIterator(); it.hasNext();) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	221 Pair<Integer, HgDataFile> e = it.next();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	222 if (e.first() == clogRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	223 assert e.second().getPath().equals(df.getPath());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	224 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	225 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	226 if (e.first() > clogRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	227 // insert new entry before current
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	228 it.previous();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	229 it.add(newEntry);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	230 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	231 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	232 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	233 files.add(newEntry);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	234 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	235
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	236 public HgDataFile getFile(int clogRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	237 for (Pair<Integer, HgDataFile> e : files) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	238 if (e.first() >= clogRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	239 return e.second();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	240 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	241 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	242 throw new HgInvalidStateException(String.format("Got %d file-changelog mappings, but no luck for revision %d.", files.size(), clogRevIndex));
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	243 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	244
628 6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 625 diff changeset	245 public LineSequence lines(int clogRevIndex, int fileRevIndex) throws HgRuntimeException {
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	246 Pair<Integer, LineSequence> cached = checkCache(clogRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	247 if (cached != null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	248 return cached.second();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	249 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	250 HgDataFile df = getFile(clogRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	251 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	252 ByteArrayChannel c;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	253 df.content(fileRevIndex, c = new ByteArrayChannel());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	254 LineSequence rv = LineSequence.newlines(c.toArray());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	255 lruCache.addFirst(new Pair<Integer, LineSequence>(clogRevIndex, rv));
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	256 if (lruCache.size() > limit) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	257 lruCache.removeLast();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	258 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	259 return rv;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	260 } catch (CancelledException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	261 // TODO likely it was bad idea to throw cancelled exception from content()
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	262 // deprecate and provide alternative?
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	263 HgInvalidStateException ise = new HgInvalidStateException("ByteArrayChannel never throws CancelledException");
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	264 ise.initCause(ex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	265 throw ise;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	266 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	267 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	268
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	269 private Pair<Integer,LineSequence> checkCache(int fileRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	270 Pair<Integer, LineSequence> rv = null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	271 for (ListIterator<Pair<Integer, LineSequence>> it = lruCache.listIterator(); it.hasNext(); ) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	272 Pair<Integer, LineSequence> p = it.next();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	273 if (p.first() == fileRevIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	274 rv = p;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	275 it.remove();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	276 break;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	277 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	278 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	279 if (rv != null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	280 lruCache.addFirst(rv);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	281 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	282 return rv;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	283 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	284 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	285
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	286 private static class BlameBlockInspector extends DiffHelper.DeltaInspector<LineSequence> {
603 707b5c7c6fa4 Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 569 diff changeset	287 private final HgBlameInspector insp;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	288 private final int csetOrigin;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	289 private final int csetTarget;
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	290 private MergeResolutionStrategy p2MergeCommon;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	291 private int csetMergeParent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	292 private final AnnotateRev annotatedRevision;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	293 private HgCallbackTargetException error;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	294
603 707b5c7c6fa4 Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 569 diff changeset	295 public BlameBlockInspector(HgDataFile df, int fileRevIndex, HgBlameInspector inspector, int originCset, int targetCset) {
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	296 assert inspector != null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	297 insp = inspector;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	298 annotatedRevision = new AnnotateRev();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	299 annotatedRevision.set(df, fileRevIndex);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	300 csetOrigin = originCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	301 csetTarget = targetCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	302 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	303
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	304 public void setMergeParent2(MergeResolutionStrategy p2MergeStrategy, int parentCset2) {
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	305 p2MergeCommon = p2MergeStrategy;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	306 csetMergeParent = parentCset2;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	307 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	308
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	309 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	310 public void begin(LineSequence s1, LineSequence s2) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	311 super.begin(s1, s2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	312 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	313 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	314 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	315 ContentBlock originContent = new ContentBlock(s1);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	316 ContentBlock targetContent = new ContentBlock(s2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	317 annotatedRevision.set(originContent, targetContent);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	318 annotatedRevision.set(csetOrigin, csetTarget, p2MergeCommon != null ? csetMergeParent : NO_REVISION);
629 5f52074707b2 Diff/blame methods as command, their residence in HgDataFile was a mistake Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 628 diff changeset	319 RevisionDescriptor.Recipient curious = Adaptable.Factory.getAdapter(insp, RevisionDescriptor.Recipient.class, null);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	320 if (curious != null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	321 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	322 curious.start(annotatedRevision);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	323 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	324 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	325 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	326 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	327 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	328
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	329 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	330 public void end() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	331 super.end();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	332 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	333 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	334 }
629 5f52074707b2 Diff/blame methods as command, their residence in HgDataFile was a mistake Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 628 diff changeset	335 RevisionDescriptor.Recipient curious = Adaptable.Factory.getAdapter(insp, RevisionDescriptor.Recipient.class, null);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	336 if (curious != null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	337 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	338 curious.done(annotatedRevision);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	339 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	340 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	341 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	342 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	343 p2MergeCommon = null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	344 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	345
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	346 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	347 protected void changed(int s1From, int s1To, int s2From, int s2To) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	348 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	349 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	350 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	351 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	352 if (p2MergeCommon != null) {
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	353 IntSliceSeq mergeRanges = p2MergeCommon.combineAndMarkRangesWithSource(s1From, s1To, s2From, s2To, csetOrigin, csetMergeParent);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	354
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	355 /*
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	356 * Usecases, how it USED TO BE initially:
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	357 * 3 lines changed to 10 lines. range of 10 lines breaks down to 2 from p2, 3 from p1, and 5 from p2.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	358 * We report: 2 lines changed to 2(p2), then 1 line changed with 3(p1) and 5 lines added from p2.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	359 *
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	360 * 10 lines changed to 3 lines, range of 3 lines breaks down to 2 line from p1 and 1 line from p2.
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	361 * We report: 2 lines changed to 2(p1) and 8 lines changed to 1(p2)
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	362 *
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	363 * NOW, lines from p2 are always reported as pure add (since we need their insertion point to be in p2, not in p1)
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	364 * and we try to consume p1 changes as soon as we see first p1's range
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	365 */
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	366 int s1TotalLines = s1To - s1From, s1ConsumedLines = 0, s1Start = s1From;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	367
674 cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	368 for (Iterator<IntTuple> it = mergeRanges.iterator(); it.hasNext();) {
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	369 IntTuple mergeRange = it.next();
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	370 final int rangeOrigin = mergeRange.at(0);
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	371 final int rangeStart = mergeRange.at(1);
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	372 final int rangeLen = mergeRange.at(2);
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	373 final boolean lastRange = it.hasNext();
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	374 final int s1LinesLeft = s1TotalLines - s1ConsumedLines;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	375 // how many lines we may report as changed (don't use more than in range unless it's the very last range)
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	376 final int s1LinesToBorrow = lastRange ? s1LinesLeft : Math.min(s1LinesLeft, rangeLen);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	377 if (rangeOrigin != csetMergeParent && s1LinesToBorrow > 0) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	378 ChangeBlockImpl block = getChangeBlock(s1Start, s1LinesToBorrow, rangeStart, rangeLen);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	379 block.setOriginAndTarget(rangeOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	380 insp.changed(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	381 s1ConsumedLines += s1LinesToBorrow;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	382 s1Start += s1LinesToBorrow;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	383 } else {
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	384 int blockInsPoint = rangeOrigin != csetMergeParent ? s1Start : p2MergeCommon.getLineInP2(rangeStart);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	385 ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, blockInsPoint);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	386 block.setOriginAndTarget(rangeOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	387 insp.added(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	388 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	389 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	390 if (s1ConsumedLines != s1TotalLines) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	391 assert s1ConsumedLines < s1TotalLines : String.format("Expected to process %d lines, but actually was %d", s1TotalLines, s1ConsumedLines);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	392 // either there were no ranges from p1, whole s2From..s2To range came from p2, shall report as deleted
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	393 // or the ranges found were not enough to consume whole s2From..s2To
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	394 // The "deletion point" is shifted to the end of last csetOrigin->csetTarget change
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	395 int s2DeletePoint = s2From + s1ConsumedLines;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	396 ChangeBlockImpl block = new ChangeBlockImpl(annotatedRevision.origin, null, s1Start, s1To - s1Start, -1, -1, -1, s2DeletePoint);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	397 block.setOriginAndTarget(csetOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	398 insp.deleted(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	399 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	400 } else {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	401 ChangeBlockImpl block = getChangeBlock(s1From, s1To - s1From, s2From, s2To - s2From);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	402 block.setOriginAndTarget(csetOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	403 insp.changed(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	404 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	405 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	406 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	407 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	408 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	409
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	410 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	411 protected void added(int s1InsertPoint, int s2From, int s2To) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	412 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	413 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	414 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	415 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	416 if (p2MergeCommon != null) {
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	417 IntSliceSeq mergeRanges = p2MergeCommon.combineAndMarkRangesWithSource(s1InsertPoint, s2From, s2To, csetOrigin, csetMergeParent);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	418 int insPoint = s1InsertPoint; // track changes to insertion point
674 cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	419 for (IntTuple mergeRange : mergeRanges) {
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	420 int rangeOrigin = mergeRange.at(0);
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	421 int rangeStart = mergeRange.at(1);
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	422 int rangeLen = mergeRange.at(2);
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	423 // XXX likely need somewhat similar to the code above:
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	424 // int blockInsPoint = rangeOrigin != csetMergeParent ? s1Start : p2MergeCommon.reverseMapLine(rangeStart);
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	425 //
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	426 ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, insPoint);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	427 block.setOriginAndTarget(rangeOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	428 insp.added(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	429 // indicate insPoint moved down number of lines we just reported
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	430 insPoint += rangeLen;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	431 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	432 } else {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	433 ChangeBlockImpl block = getAddBlock(s2From, s2To - s2From, s1InsertPoint);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	434 block.setOriginAndTarget(csetOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	435 insp.added(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	436 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	437 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	438 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	439 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	440 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	441
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	442 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	443 protected void deleted(int s2DeletePoint, int s1From, int s1To) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	444 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	445 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	446 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	447 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	448 ChangeBlockImpl block = new ChangeBlockImpl(annotatedRevision.origin, null, s1From, s1To - s1From, -1, -1, -1, s2DeletePoint);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	449 block.setOriginAndTarget(csetOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	450 insp.deleted(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	451 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	452 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	453 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	454 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	455
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	456 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	457 protected void unchanged(int s1From, int s2From, int length) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	458 if (shallStop()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	459 return;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	460 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	461 try {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	462 EqualBlockImpl block = new EqualBlockImpl(s1From, s2From, length, annotatedRevision.target);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	463 block.setOriginAndTarget(csetOrigin, csetTarget);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	464 insp.same(block);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	465 } catch (HgCallbackTargetException ex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	466 error = ex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	467 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	468 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	469
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	470 void checkErrors() throws HgCallbackTargetException {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	471 if (error != null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	472 throw error;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	473 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	474 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	475
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	476 private boolean shallStop() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	477 return error != null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	478 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	479
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	480 private ChangeBlockImpl getAddBlock(int start, int len, int insPoint) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	481 return new ChangeBlockImpl(null, annotatedRevision.target, -1, -1, start, len, insPoint, -1);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	482 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	483
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	484 private ChangeBlockImpl getChangeBlock(int start1, int len1, int start2, int len2) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	485 return new ChangeBlockImpl(annotatedRevision.origin, annotatedRevision.target, start1, len1, start2, len2, start1, start2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	486 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	487 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	488
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	489 private static class BlockImpl implements Block {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	490 private int originCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	491 private int targetCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	492
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	493 void setOriginAndTarget(int originChangesetIndex, int targetChangesetIndex) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	494 // XXX perhaps, shall be part of Inspector API, rather than Block's
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	495 // as they don't change between blocks (although the moment about merged revisions)
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	496 // is not yet clear to me
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	497 originCset = originChangesetIndex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	498 targetCset = targetChangesetIndex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	499 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	500
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	501 public int originChangesetIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	502 return originCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	503 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	504
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	505 public int targetChangesetIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	506 return targetCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	507 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	508 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	509
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	510 private static class EqualBlockImpl extends BlockImpl implements EqualBlock {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	511 private final int start1, start2;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	512 private final int length;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	513 private final ContentBlock fullContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	514 private FilterBlock myContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	515
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	516 EqualBlockImpl(int blockStartSeq1, int blockStartSeq2, int blockLength, ContentBlock targetContent) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	517 start1 = blockStartSeq1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	518 start2 = blockStartSeq2;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	519 length = blockLength;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	520 fullContent = targetContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	521 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	522
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	523 public int originStart() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	524 return start1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	525 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	526
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	527 public int targetStart() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	528 return start2;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	529 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	530
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	531 public int length() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	532 return length;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	533 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	534
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	535 public BlockData content() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	536 if (myContent == null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	537 myContent = new FilterBlock(fullContent, start2, length);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	538 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	539 return myContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	540 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	541
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	542 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	543 public String toString() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	544 return String.format("@@ [%d..%d) == [%d..%d) @@", start1, start1+length, start2, start2+length);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	545 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	546 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	547
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	548 private static class ChangeBlockImpl extends BlockImpl implements ChangeBlock {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	549 private final ContentBlock oldContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	550 private final ContentBlock newContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	551 private final int s1Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	552 private final int s1Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	553 private final int s2Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	554 private final int s2Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	555 private final int s1InsertPoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	556 private final int s2DeletePoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	557 private FilterBlock addedBlock, removedBlock;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	558
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	559 public ChangeBlockImpl(ContentBlock c1, ContentBlock c2, int s1Start, int s1Len, int s2Start, int s2Len, int s1InsertPoint, int s2DeletePoint) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	560 oldContent = c1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	561 newContent = c2;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	562 this.s1Start = s1Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	563 this.s1Len = s1Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	564 this.s2Start = s2Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	565 this.s2Len = s2Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	566 this.s1InsertPoint = s1InsertPoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	567 this.s2DeletePoint = s2DeletePoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	568 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	569
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	570 public int insertedAt() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	571 return s1InsertPoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	572 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	573
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	574 public int firstAddedLine() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	575 return s2Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	576 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	577
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	578 public int totalAddedLines() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	579 return s2Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	580 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	581
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	582 public BlockData addedLines() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	583 if (addedBlock == null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	584 addedBlock = new FilterBlock(newContent, firstAddedLine(), totalAddedLines());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	585 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	586 return addedBlock;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	587 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	588
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	589 public int removedAt() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	590 return s2DeletePoint;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	591 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	592
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	593 public int firstRemovedLine() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	594 return s1Start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	595 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	596
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	597 public int totalRemovedLines() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	598 return s1Len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	599 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	600
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	601 public BlockData removedLines() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	602 if (removedBlock == null) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	603 removedBlock = new FilterBlock(oldContent, firstRemovedLine(), totalRemovedLines());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	604 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	605 return removedBlock;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	606 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	607
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	608 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	609 public String toString() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	610 if (s2DeletePoint == -1) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	611 return String.format("@@ -%d,0 +%d,%d @@", insertedAt(), firstAddedLine(), totalAddedLines());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	612 } else if (s1InsertPoint == -1) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	613 // delete only
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	614 return String.format("@@ -%d,%d +%d,0 @@", firstRemovedLine(), totalRemovedLines(), removedAt());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	615 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	616 return String.format("@@ -%d,%d +%d,%d @@", firstRemovedLine(), totalRemovedLines(), firstAddedLine(), totalAddedLines());
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	617 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	618 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	619
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	620 private static class SingleLine implements BlockData {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	621 private final ByteChain line;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	622
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	623 public SingleLine(ByteChain lineContent) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	624 line = lineContent;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	625 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	626
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	627 public BlockData elementAt(int index) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	628 assert false;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	629 return null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	630 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	631
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	632 public int elementCount() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	633 return 0;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	634 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	635
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	636 public byte[] asArray() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	637 return line.data();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	638 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	639 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	640
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	641 private static class ContentBlock implements BlockData {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	642 private final LineSequence seq;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	643
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	644 public ContentBlock(LineSequence sequence) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	645 seq = sequence;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	646 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	647
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	648 public BlockData elementAt(int index) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	649 return new SingleLine(seq.chunk(index));
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	650 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	651
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	652 public int elementCount() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	653 return seq.chunkCount() - 1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	654 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	655
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	656 public byte[] asArray() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	657 return seq.data(0, seq.chunkCount() - 1);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	658 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	659 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	660
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	661 private static class FilterBlock implements BlockData {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	662 private final ContentBlock contentBlock;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	663 private final int from;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	664 private final int length;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	665
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	666 public FilterBlock(ContentBlock bd, int startFrom, int len) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	667 assert bd != null;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	668 assert startFrom + len < bd.seq.chunkCount(); // there's one extra chunk in the end, so strict less is ok
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	669 contentBlock = bd;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	670 from = startFrom;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	671 length = len;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	672 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	673
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	674 public BlockData elementAt(int index) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	675 if (index < 0 \|\| index >= length) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	676 throw new IllegalArgumentException(String.format("Expected value from [0..%d), got %d", length, index));
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	677 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	678 return contentBlock.elementAt(from + index);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	679 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	680
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	681 public int elementCount() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	682 return length;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	683 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	684
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	685 public byte[] asArray() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	686 return contentBlock.seq.data(from, from + length);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	687 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	688 }
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	689
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	690 private static class EqualBlocksCollector implements DiffHelper.MatchInspector<LineSequence> {
674 cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	691 private final RangePairSeq matches = new RangePairSeq();
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	692
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	693 public void begin(LineSequence s1, LineSequence s2) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	694 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	695
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	696 public void match(int startSeq1, int startSeq2, int matchLength) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	697 matches.add(startSeq1, startSeq2, matchLength);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	698 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	699
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	700 public void end() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	701 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	702
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	703 public void intersectWithTarget(int start, int length, IntVector result) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	704 int s = start;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	705 for (int l = start, x = start + length; l < x; l++) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	706 if (!matches.includesTargetLine(l)) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	707 if (l - s > 0) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	708 result.add(s);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	709 result.add(l - s);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	710 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	711 s = l+1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	712 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	713 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	714 if (s < start+length) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	715 result.add(s);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	716 result.add((start + length) - s);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	717 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	718 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	719
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	720 }
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	721
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	722 interface MergeResolutionStrategy {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	723 /**
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	724 * breaks region [start2..end2) into ranges according to deduced (or simply guessed)
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	725 * matching of [start1..end1) lines to lines in source1 and source2
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	726 * @return list of tuples (source, start, length), where source is one of the identifiers supplied
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	727 */
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	728 public IntSliceSeq combineAndMarkRangesWithSource(int start1, int end1, int start2, int end2, int source1, int source2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	729 public IntSliceSeq combineAndMarkRangesWithSource(int insPoint, int start, int end, int source1, int source2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	730 public int getLineInP2(int mergeLine);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	731 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	732
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	733 // report lines as merged from p2 solely based on whether target line belongs
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	734 // to a region that is equal to p2 region
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	735 private static class MergeStrategy1 implements MergeResolutionStrategy {
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	736 // equal ranges in p2 and merged revision
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	737 private final RangePairSeq matches;
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	738 private final IntSliceSeq mergeRanges;
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	739
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	740 public MergeStrategy1(RangePairSeq p2EqualToM) {
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	741 matches = p2EqualToM;
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	742 mergeRanges = new IntSliceSeq(3, 10, 10);
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	743 }
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	744
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	745 /*
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	746 * intersects [start..start+length) with ranges of target lines, and based on the intersection
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	747 * breaks initial range into smaller ranges and records them into result, with marker to indicate
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	748 * whether the range is from initial range (markerSource) or is a result of the intersection with target
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	749 * (markerTarget)
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	750 */
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	751 private IntSliceSeq doCombine(int start, int length, int markerSource, int markerTarget) {
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	752 mergeRanges.clear();
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	753 assert mergeRanges.sliceSize() == 3;
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	754 int sourceStart = start, targetStart = start, sourceEnd = start + length;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	755 for (int l = sourceStart; l < sourceEnd; l++) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	756 if (matches.includesTargetLine(l)) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	757 // l is from target
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	758 if (sourceStart < l) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	759 // few lines from source range were not in the target, report them
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	760 mergeRanges.add(markerSource, sourceStart, l - sourceStart);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	761 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	762 // indicate the earliest line from source range to use
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	763 sourceStart = l + 1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	764 } else {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	765 // l is not in target
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	766 if (targetStart < l) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	767 // report lines from target range
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	768 mergeRanges.add(markerTarget, targetStart, l - targetStart);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	769 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	770 // next line may be from target
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	771 targetStart = l + 1;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	772 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	773 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	774 // if source range end with line from target, sourceStart would be == sourceEnd, and we need to add range with markerTarget
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	775 // if source range doesn't end with target line, targetStart == sourceEnd, while sourceStart < sourceEnd
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	776 if (sourceStart < sourceEnd) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	777 assert targetStart == sourceEnd;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	778 // something left from the source range
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	779 mergeRanges.add(markerSource, sourceStart, sourceEnd - sourceStart);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	780 } else if (targetStart < sourceEnd) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	781 assert sourceStart == sourceEnd;
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	782 mergeRanges.add(markerTarget, targetStart, sourceEnd - targetStart);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	783 }
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	784 return mergeRanges;
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	785 }
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	786
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	787 public int getLineInP2(int mergeLine) {
8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	788 return matches.reverseMapLine(mergeLine);
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	789 }
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	790
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	791 public IntSliceSeq combineAndMarkRangesWithSource(int start1, int end1, int start2, int end2, int source1, int source2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	792 return doCombine(start2, end2 - start2, source1, source2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	793 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	794
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	795 public IntSliceSeq combineAndMarkRangesWithSource(int insPoint, int start, int end, int source1, int source2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	796 return doCombine(start, end - start, source1, source2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	797 }
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	798 }
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	799
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	800 private static class MergeStrategy2 implements MergeResolutionStrategy {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	801 // equal ranges in p2 and merged revision
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	802 private final List<RangePairSeq> matches;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	803 private final IntSliceSeq mergeRanges;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	804 private final DiffRangeMap p1ToBase;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	805 private final DiffRangeMap baseToP2;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	806
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	807 public MergeStrategy2(List<RangePairSeq> p2EqualToM, DiffRangeMap p1ToBaseRanges, DiffRangeMap baseToP2Ranges) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	808 matches = p2EqualToM;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	809 p1ToBase = p1ToBaseRanges;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	810 baseToP2= baseToP2Ranges;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	811 mergeRanges = new IntSliceSeq(3, 10, 10);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	812 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	813
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	814
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	815 public IntSliceSeq combineAndMarkRangesWithSource(int insPoint, int start, int end, int source1, int source2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	816 return combineAndMarkRangesWithSource(insPoint, insPoint, start, end, source1, source2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	817 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	818
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	819 public IntSliceSeq combineAndMarkRangesWithSource(int start1, int end1, int start2, int end2, int source1, int source2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	820 mergeRanges.clear();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	821 IntSliceSeq mergedLines = new IntSliceSeq(2, end2-start2, 0);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	822 for (int i = start2; i < end2; i++) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	823 mergedLines.add(source1, 0);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	824 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	825 // [s1Start..s1End) // range in p1 seen as changed in m
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	826 for (RangePair p1_b : p1ToBase.findInSource(start1, end1)) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	827 // there might be few ranges in (p1-base) that overlap with (p1-m) changes
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	828 for (RangePair b_p2 : baseToP2.findInSource(p1_b.start2(), p1_b.end2())) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	829 // regions in p2 that correspond to affected regions in base
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	830 for (int p2Line = b_p2.start2(); p2Line < b_p2.end2(); p2Line++) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	831 for (RangePairSeq eq : matches) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	832 if (eq.includesOriginLine(p2Line)) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	833 // this line in p2 is equal to some line in merge
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	834 int mergeLine = eq.mapLineIndex(p2Line);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	835 if (mergeLine >= start2 && mergeLine < end2) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	836 mergedLines.set(mergeLine - start2, source2, p2Line);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	837 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	838 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	839 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	840 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	841 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	842 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	843 int lineCount = 0, start = start2;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	844 int lastSeenSource = source1;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	845 for (IntTuple t : mergedLines) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	846 if (t.at(0) == lastSeenSource) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	847 lineCount++;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	848 } else {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	849 if (lineCount > 0) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	850 mergeRanges.add(lastSeenSource, start, lineCount);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	851 start += lineCount;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	852 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	853 lineCount = 1;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	854 lastSeenSource = t.at(0);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	855 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	856 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	857 if (lineCount > 0) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	858 mergeRanges.add(lastSeenSource, start, lineCount);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	859 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	860 return mergeRanges;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	861 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	862
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	863 public int getLineInP2(int mergeLine) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	864 for (RangePairSeq eq : matches) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	865 if (eq.includesTargetLine(mergeLine)) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	866 return eq.reverseMapLine(mergeLine);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	867 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	868 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	869 return -1;
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	870 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	871 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	872
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	873
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	874 private static class AnnotateRev implements RevisionDescriptor {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	875 public ContentBlock origin, target;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	876 public int originCset, targetCset, mergeCset, fileRevIndex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	877 public HgDataFile df;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	878
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	879 public void set(HgDataFile file, int fileRev) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	880 df = file;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	881 fileRevIndex = fileRev;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	882 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	883 public void set(ContentBlock o, ContentBlock t) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	884 origin = o;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	885 target = t;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	886 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	887 public void set(int o, int t, int m) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	888 originCset = o;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	889 targetCset = t;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	890 mergeCset = m;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	891 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	892
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	893 public BlockData origin() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	894 return origin;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	895 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	896
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	897 public BlockData target() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	898 return target;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	899 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	900
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	901 public int originChangesetIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	902 return originCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	903 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	904
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	905 public int targetChangesetIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	906 return targetCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	907 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	908
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	909 public boolean isMerge() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	910 return mergeCset != NO_REVISION;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	911 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	912
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	913 public int mergeChangesetIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	914 return mergeCset;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	915 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	916
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	917 public int fileRevisionIndex() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	918 return fileRevIndex;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	919 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	920 public HgDataFile file() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	921 return df;
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	922 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	923 @Override
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	924 public String toString() {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	925 if (isMerge()) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	926 return String.format("[%d,%d->%d]", originCset, mergeCset, targetCset);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	927 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	928 return String.format("[%d->%d]", originCset, targetCset);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	929 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	930 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	931
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	932 public static void main(String[] args) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	933 EqualBlocksCollector bc = new EqualBlocksCollector();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	934 bc.match(-1, 5, 3);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	935 bc.match(-1, 10, 2);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	936 bc.match(-1, 15, 3);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	937 bc.match(-1, 20, 3);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	938 IntVector r = new IntVector();
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	939 bc.intersectWithTarget(7, 10, r);
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	940 for (int i = 0; i < r.size(); i+=2) {
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	941 System.out.printf("[%d..%d) ", r.get(i), r.get(i) + r.get(i+1));
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	942 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	943 System.out.println();
678 8625cba0a5a8 Towards better blame of merge revisions: refactor merge handling strategy Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 674 diff changeset	944 MergeStrategy1 ms = new MergeStrategy1(bc.matches);
680 58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	945 IntSliceSeq mr = ms.doCombine(0, 16, 508, 514);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	946 for (IntTuple t : mr) {
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	947 System.out.printf("%d:[%d..%d) ", t.at(0), t.at(1), t.at(1) + t.at(2));
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	948 }
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	949 System.out.println();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	950 System.out.println();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	951 DiffRangeMap m1 = new DiffRangeMap(); // p1 -> base
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	952 m1.match(0, 0, 1); // =1..1 -> 1..1
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	953 m1.match(7, 3, 0); // *2..7 -> 2..3
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	954 DiffRangeMap m2 = new DiffRangeMap(); // base -> p2
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	955 m2.match(0, 0, 1); // =1..1 -> 1..1
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	956 m2.match(3, 3, 0); // *2..3 -> 2..3
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	957 RangePairSeq eq1 = new RangePairSeq();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	958 eq1.add(0, 0, 3);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	959 RangePairSeq eq2 = new RangePairSeq();
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	960 eq2.add(0, 4, 3);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	961 MergeStrategy2 ms2 = new MergeStrategy2(Arrays.asList(eq1, eq2), m1, m2);
58a6900f845d Blame: alternative strategy to handle merge revisions: map(diff(p1->base->p2)) to understand merge intentions better Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 678 diff changeset	962 mr = ms2.combineAndMarkRangesWithSource(5, 7, 5, 7, 33, 44);
674 cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	963 for (IntTuple t : mr) {
cce0387c6041 Introduced dedicated IntSliceSeq/IntTuple in place of IntArray with subsequences Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 629 diff changeset	964 System.out.printf("%d:[%d..%d) ", t.at(0), t.at(1), t.at(1) + t.at(2));
569 c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	965 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	966 }
c4fd1037bc6f Support for copy/rename follow/no-follow for annotate Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	967 }

Mercurial > jhg

annotate src/org/tmatesoft/hg/internal/BlameHelper.java @ 680:58a6900f845d