jhg: src/org/tmatesoft/hg/core/HgLogCommand.java comparison

comparison src/org/tmatesoft/hg/core/HgLogCommand.java @ 692:e970b333f284

Refactor HgLogCommand to utilize correct file.isCopy(int)

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Sat, 03 Aug 2013 17:11:33 +0200
parents	98ff1fb49abe
children

comparison

equal deleted inserted replaced

-:72fc7774b87e
+:e970b333f284
 import java.util.TreeSet;
 import org.tmatesoft.hg.internal.AdapterPlug;
 import org.tmatesoft.hg.internal.BatchRangeHelper;
 import org.tmatesoft.hg.internal.CsetParamKeeper;
+import org.tmatesoft.hg.internal.FileRenameHistory;
+import org.tmatesoft.hg.internal.FileRenameHistory.Chunk;
 import org.tmatesoft.hg.internal.IntMap;
 import org.tmatesoft.hg.internal.IntVector;
 import org.tmatesoft.hg.internal.Internals;
 import org.tmatesoft.hg.internal.Lifecycle;
 import org.tmatesoft.hg.internal.LifecycleProxy;
 		final ProgressSupport progressHelper = getProgressSupport(handler);
 		try {
 			if (repo.getChangelog().getRevisionCount() == 0) {
 				return;
 			}
+			final int firstCset = startRev;
 			final int lastCset = endRev == TIP ? repo.getChangelog().getLastRevision() : endRev;
 			// XXX pretty much like HgInternals.checkRevlogRange
 			if (lastCset < 0 || lastCset > repo.getChangelog().getLastRevision()) {
 				throw new HgBadArgumentException(String.format("Bad value %d for end revision", lastCset), null);
 			}
-			if (startRev < 0 || startRev > lastCset) {
+			if (firstCset < 0 || firstCset > lastCset) {
-				throw new HgBadArgumentException(String.format("Bad value %d for start revision for range [%1$d..%d]", startRev, lastCset), null);
+				throw new HgBadArgumentException(String.format("Bad value %d for start revision for range [%1$d..%d]", firstCset, lastCset), null);
 			}
 			final int BATCH_SIZE = 100;
 			count = 0;
 			HgParentChildMap<HgChangelog> pw = getParentHelper(file == null); // leave it uninitialized unless we iterate whole repo
 			// ChangesetTransfrom creates a blank PathPool, and #file(String, boolean) above
 			csetTransform = new ChangesetTransformer(repo, handler, pw, progressHelper, getCancelSupport(handler, true));
 			// FilteringInspector is responsible to check command arguments: users, branches, limit, etc.
 			// prior to passing cset to next Inspector, which is either (a) collector to reverse cset order, then invokes
 			// transformer from (b), below, with alternative cset order or (b) transformer to hi-level csets.
 			FilteringInspector filterInsp = new FilteringInspector();
-			filterInsp.changesets(startRev, lastCset);
+			filterInsp.changesets(firstCset, lastCset);
 			if (file == null) {
-				progressHelper.start(lastCset - startRev + 1);
+				progressHelper.start(lastCset - firstCset + 1);
 				if (iterateDirection == HgIterateDirection.OldToNew) {
 					filterInsp.delegateTo(csetTransform);
-					repo.getChangelog().range(startRev, lastCset, filterInsp);
+					repo.getChangelog().range(firstCset, lastCset, filterInsp);
 					csetTransform.checkFailure();
 				} else {
 					assert iterateDirection == HgIterateDirection.NewToOld;
-					BatchRangeHelper brh = new BatchRangeHelper(startRev, lastCset, BATCH_SIZE, true);
+					BatchRangeHelper brh = new BatchRangeHelper(firstCset, lastCset, BATCH_SIZE, true);
-					BatchChangesetInspector batchInspector = new BatchChangesetInspector(Math.min(lastCset-startRev+1, BATCH_SIZE));
+					BatchChangesetInspector batchInspector = new BatchChangesetInspector(Math.min(lastCset-firstCset+1, BATCH_SIZE));
 					filterInsp.delegateTo(batchInspector);
+					// XXX this batching code is bit verbose, refactor
 					while (brh.hasNext()) {
 						brh.next();
 						repo.getChangelog().range(brh.start(), brh.end(), filterInsp);
 						for (BatchChangesetInspector.BatchRecord br : batchInspector.iterate(true)) {
 							csetTransform.next(br.csetIndex, br.csetRevision, br.cset);
 				}
 			} else {
 				filterInsp.delegateTo(csetTransform);
 				final HgFileRenameHandlerMixin withCopyHandler = Adaptable.Factory.getAdapter(handler, HgFileRenameHandlerMixin.class, null);
 				FileRenameQueueBuilder frqBuilder = new FileRenameQueueBuilder();
-				List<Pair<HgDataFile, Nodeid>> fileRenames = frqBuilder.buildFileRenamesQueue();
+				List<QueueElement> fileRenames = frqBuilder.buildFileRenamesQueue(firstCset, lastCset);
 				progressHelper.start(fileRenames.size());
 				for (int nameIndex = 0, fileRenamesSize = fileRenames.size(); nameIndex < fileRenamesSize; nameIndex++) {
-					Pair<HgDataFile, Nodeid> curRename = fileRenames.get(nameIndex);
+					QueueElement curRename = fileRenames.get(nameIndex);
-					HgDataFile fileNode = curRename.first();
+					HgDataFile fileNode = curRename.file();
 					if (followAncestry) {
 						TreeBuildInspector treeBuilder = new TreeBuildInspector(followAncestry);
 						@SuppressWarnings("unused")
-						List<HistoryNode> fileAncestry = treeBuilder.go(fileNode, curRename.second());
+						List<HistoryNode> fileAncestry = treeBuilder.go(curRename);
-						int[] commitRevisions = narrowChangesetRange(treeBuilder.getCommitRevisions(), startRev, lastCset);
+						int[] commitRevisions = narrowChangesetRange(treeBuilder.getCommitRevisions(), firstCset, lastCset);
 						if (iterateDirection == HgIterateDirection.OldToNew) {
 							repo.getChangelog().range(filterInsp, commitRevisions);
 							csetTransform.checkFailure();
 						} else {
 							assert iterateDirection == HgIterateDirection.NewToOld;
 								repo.getChangelog().range(csetWithFileChange, csetWithFileChange, filterInsp);
 							}
 						}
 					} else {
 						// report complete file history (XXX may narrow range with [startRev, endRev], but need to go from file rev to link rev)
-						int fileStartRev = 0; //fileNode.getChangesetRevisionIndex(0) >= startRev
+						int fileStartRev = curRename.fileFrom();
-						int fileEndRev = fileNode.getLastRevision();
+						int fileEndRev = curRename.file().getLastRevision(); //curRename.fileTo();
 						if (iterateDirection == HgIterateDirection.OldToNew) {
 							fileNode.history(fileStartRev, fileEndRev, filterInsp);
 							csetTransform.checkFailure();
 						} else {
 							assert iterateDirection == HgIterateDirection.NewToOld;
 								batchInspector.reset();
 							}
 						}
 					}
 					if (withCopyHandler != null && nameIndex + 1 < fileRenamesSize) {
-						Pair<HgDataFile, Nodeid> nextRename = fileRenames.get(nameIndex+1);
+						QueueElement nextRename = fileRenames.get(nameIndex+1);
 						HgFileRevision src, dst;
 						// A -> B
 						if (iterateDirection == HgIterateDirection.OldToNew) {
 							// curRename: A, nextRename: B
-							src = new HgFileRevision(fileNode, curRename.second(), null);
+							src = curRename.last();
-							dst = new HgFileRevision(nextRename.first(), nextRename.first().getRevision(0), src.getPath());
+							dst = nextRename.first(src);
 						} else {
 							assert iterateDirection == HgIterateDirection.NewToOld;
 							// curRename: B, nextRename: A
-							src = new HgFileRevision(nextRename.first(), nextRename.second(), null);
+							src = nextRename.last();
-							dst = new HgFileRevision(fileNode, fileNode.getRevision(0), src.getPath());
+							dst = curRename.first(src);
 						}
 						withCopyHandler.copy(src, dst);
 					}
 					progressHelper.worked(1);
 				} // for renames
 			throw new ConcurrentModificationException();
 		}
 		if (file == null) {
 			throw new IllegalArgumentException("History tree is supported for files only (at least now), please specify file");
 		}
+		final int firstCset = startRev;
+		final int lastCset = endRev == TIP ? repo.getChangelog().getLastRevision() : endRev;
+		// XXX pretty much like HgInternals.checkRevlogRange
+		if (lastCset < 0 || lastCset > repo.getChangelog().getLastRevision()) {
+			throw new HgBadArgumentException(String.format("Bad value %d for end revision", lastCset), null);
+		}
+		if (firstCset < 0 || startRev > lastCset) {
+			throw new HgBadArgumentException(String.format("Bad value %d for start revision for range [%1$d..%d]", startRev, lastCset), null);
+		}
 		final ProgressSupport progressHelper = getProgressSupport(handler);
 		final CancelSupport cancelHelper = getCancelSupport(handler, true);
 		final HgFileRenameHandlerMixin renameHandler = Adaptable.Factory.getAdapter(handler, HgFileRenameHandlerMixin.class, null);
 		try {
 			};
 			// renamed files in the queue are placed with respect to #iterateDirection
 			// i.e. if we iterate from new to old, recent filenames come first
 			FileRenameQueueBuilder frqBuilder = new FileRenameQueueBuilder();
-			List<Pair<HgDataFile, Nodeid>> fileRenamesQueue = frqBuilder.buildFileRenamesQueue();
+			List<QueueElement> fileRenamesQueue = frqBuilder.buildFileRenamesQueue(firstCset, lastCset);
 			// XXX perhaps, makes sense to look at selected file's revision when followAncestry is true
 			// to ensure file we attempt to trace is in the WC's parent. Native hg aborts if not.
 			progressHelper.start(4 * fileRenamesQueue.size());
 			for (int namesIndex = 0, renamesQueueSize = fileRenamesQueue.size(); namesIndex < renamesQueueSize; namesIndex++) {
-				final Pair<HgDataFile, Nodeid> renameInfo = fileRenamesQueue.get(namesIndex);
+				final QueueElement renameInfo = fileRenamesQueue.get(namesIndex);
 				dispatcher.prepare(progressHelper, renameInfo);
 				cancelHelper.checkCancelled();
 				if (namesIndex > 0) {
 					dispatcher.connectWithLastJunctionPoint(renameInfo, fileRenamesQueue.get(namesIndex - 1));
 				}
 			frqBuilder.reportRenameIfNotInQueue(fileRenamesQueue, renameHandler);
 		} catch (HgRuntimeException ex) {
 			throw new HgLibraryFailureException(ex);
 		}
 		progressHelper.done();
+	}
+	private static class QueueElement {
+		private final HgDataFile df;
+		private final Nodeid lastRev;
+		private final int firstRevIndex, lastRevIndex;
+		QueueElement(HgDataFile file, Nodeid fileLastRev) {
+			df = file;
+			lastRev = fileLastRev;
+			firstRevIndex = 0;
+			lastRevIndex = lastRev == null ? df.getLastRevision() : df.getRevisionIndex(lastRev);
+		}
+		QueueElement(HgDataFile file, int firstFileRev, int lastFileRev) {
+			df = file;
+			firstRevIndex = firstFileRev;
+			lastRevIndex = lastFileRev;
+			lastRev = null;
+		}
+		HgDataFile file() {
+			return df;
+		}
+		int fileFrom() {
+			return firstRevIndex;
+		}
+		int fileTo() {
+			return lastRevIndex;
+		}
+		// never null
+		Nodeid lastFileRev() {
+			return lastRev == null ? df.getRevision(fileTo()) : lastRev;
+		}
+		HgFileRevision last() {
+			return new HgFileRevision(df, lastFileRev(), null);
+		}
+		HgFileRevision first(HgFileRevision from) {
+			return new HgFileRevision(df, df.getRevision(0), from.getPath());
+		}
 	}
 	/**
 	 * Utility to build sequence of file renames
 	 */
 		 * and possibly reuse this functionality
 		 *
 		 * @return list of file renames, ordered with respect to {@link #iterateDirection}
 		 * @throws HgRuntimeException
 		 */
-		public List<Pair<HgDataFile, Nodeid>> buildFileRenamesQueue() throws HgPathNotFoundException, HgRuntimeException {
+		public List<QueueElement> buildFileRenamesQueue(int csetStart, int csetEnd) throws HgPathNotFoundException, HgRuntimeException {
-			LinkedList<Pair<HgDataFile, Nodeid>> rv = new LinkedList<Pair<HgDataFile, Nodeid>>();
+			LinkedList<QueueElement> rv = new LinkedList<QueueElement>();
 			Nodeid startRev = null;
 			HgDataFile fileNode = repo.getFileNode(file);
 			if (!fileNode.exists()) {
 				throw new HgPathNotFoundException(String.format("File %s not found in the repository", file), file);
 			}
 					int wdParentRevIndex = repo.getChangelog().getRevisionIndex(wdParentChangeset);
 					startRev = repo.getManifest().getFileRevision(wdParentRevIndex, fileNode.getPath());
 				}
 				// else fall-through, assume null (eventually, lastRevision()) is ok here
 			}
-			Pair<HgDataFile, Nodeid> p = new Pair<HgDataFile, Nodeid>(fileNode, startRev);
+			QueueElement p = new QueueElement(fileNode, startRev);
-			rv.add(p);
 			if (!followRenames) {
+				rv.add(p);
 				return rv;
 			}
-			while (hasOrigin(p)) {
+			FileRenameHistory frh = new FileRenameHistory(csetStart, csetEnd);
-				p = origin(p);
+			frh.build(fileNode, p.fileTo());
-				if (iterateDirection == HgIterateDirection.OldToNew) {
+			for (Chunk c : frh.iterate(iterateDirection)) {
-					rv.addFirst(p);
+				rv.add(new QueueElement(c.file(), c.firstFileRev(), c.lastFileRev()));
-				} else {
+			}
-					assert iterateDirection == HgIterateDirection.NewToOld;
-					rv.addLast(p);
-				}
-			};
 			return rv;
-		}
-		public boolean hasOrigin(Pair<HgDataFile, Nodeid> p) throws HgRuntimeException {
-			return p.first().isCopy();
-		}
-		public Pair<HgDataFile, Nodeid> origin(Pair<HgDataFile, Nodeid> p) throws HgRuntimeException {
-			HgDataFile fileNode = p.first();
-			assert fileNode.isCopy();
-			Path fp = fileNode.getCopySourceName();
-			Nodeid copyRev = fileNode.getCopySourceRevision();
-			fileNode = repo.getFileNode(fp);
-			return new Pair<HgDataFile, Nodeid>(fileNode, copyRev);
 		}
 		/**
 		 * Shall report renames based solely on HgFileRenameHandlerMixin presence,
 		 * even if queue didn't get rename information due to followRenames == false
 		 *
 		 * @param queue value from {@link #buildFileRenamesQueue()}
 		 * @param renameHandler may be <code>null</code>
 		 */
-		public void reportRenameIfNotInQueue(List<Pair<HgDataFile, Nodeid>> queue, HgFileRenameHandlerMixin renameHandler) throws HgCallbackTargetException, HgRuntimeException {
+		public void reportRenameIfNotInQueue(List<QueueElement> queue, HgFileRenameHandlerMixin renameHandler) throws HgCallbackTargetException, HgRuntimeException {
 			if (renameHandler != null && !followRenames) {
 				// If followRenames is true, all the historical names were in the queue and are processed already.
 				// Hence, shall process origin explicitly only when renameHandler is present but followRenames is not requested.
 				assert queue.size() == 1; // see the way queue is constructed above
-				Pair<HgDataFile, Nodeid> curRename = queue.get(0);
+				QueueElement curRename = queue.get(0);
-				if (hasOrigin(curRename)) {
+				if (curRename.file().isCopy(curRename.fileFrom())) {
-					Pair<HgDataFile, Nodeid> origin = origin(curRename);
+					final HgFileRevision src = curRename.file().getCopySource(curRename.fileFrom());
-					HgFileRevision src, dst;
+					HgFileRevision dst = curRename.first(src);
-					src = new HgFileRevision(origin.first(), origin.second(), null);
-					dst = new HgFileRevision(curRename.first(), curRename.first().getRevision(0), src.getPath());
 					renameHandler.copy(src, dst);
 				}
 			}
 		}
 	}
+	/**
+	 * Builds list of {@link HistoryNode HistoryNodes} to visit for a given chunk of file rename history
+	 */
 	private static class TreeBuildInspector implements HgChangelog.ParentInspector, HgChangelog.RevisionInspector {
 		private final boolean followAncestry;
 		private HistoryNode[] completeHistory;
 		private int[] commitRevisions;
 			resultHistory = Collections.singletonList(rv);
 			return rv;
 		}
 		/**
+		 * FIXME pretty much the same as FileRevisionHistoryChunk
+		 *
 		 * Builds history of file changes (in natural order, from oldest to newest) up to (and including) file revision specified.
 		 * If {@link TreeBuildInspector} follows ancestry, only elements that are on the line of ancestry of the revision at
 		 * lastRevisionIndex would be included.
 		 *
 		 * @return list of history elements, from oldest to newest. In case {@link #followAncestry} is <code>true</code>, the list
 		 * is modifiable (to further augment with last/first elements of renamed file histories)
 		 */
-		List<HistoryNode> go(HgDataFile fileNode, Nodeid fileLastRevisionToVisit) throws HgRuntimeException {
+		List<HistoryNode> go(QueueElement qe) throws HgRuntimeException {
 			resultHistory = null;
-			int fileLastRevIndexToVisit = fileLastRevisionToVisit == null ? fileNode.getLastRevision() : fileNode.getRevisionIndex(fileLastRevisionToVisit);
+			HgDataFile fileNode = qe.file();
+			// TODO int fileLastRevIndexToVisit = qe.fileTo
+			int fileLastRevIndexToVisit = followAncestry ? fileNode.getRevisionIndex(qe.lastFileRev()) : fileNode.getLastRevision();
 			completeHistory = new HistoryNode[fileLastRevIndexToVisit+1];
 			commitRevisions = new int[completeHistory.length];
-			fileNode.indexWalk(0, fileLastRevIndexToVisit, this);
+			fileNode.indexWalk(qe.fileFrom(), fileLastRevIndexToVisit, this);
 			if (!followAncestry) {
-				// in case when ancestor not followed, it's safe to return unmodifiable list
+				resultHistory = new ArrayList<HistoryNode>(fileLastRevIndexToVisit - qe.fileFrom() + 1);
-				resultHistory = Arrays.asList(completeHistory);
+				// items in completeHistory with index < qe.fileFrom are empty
+				for (int i = qe.fileFrom(); i <= fileLastRevIndexToVisit; i++) {
+					resultHistory.add(completeHistory[i]);
+				}
 				completeHistory = null;
-				// keep commitRevisions initialized, no need to recalculate them
+				commitRevisions = null;
-				// as they correspond 1:1 to resultHistory
 				return resultHistory;
 			}
 			/*
 			 * Changesets, newest at the top:
 			 * o              <-- cset from working dir parent (as in dirstate), file not changed (file revision recorded points to that from A)
 					return o1.changeset - o2.changeset;
 				}
 			});
 			completeHistory = null;
 			commitRevisions = null;
-			// collected values are no longer valid - shall
-			// strip off elements for missing HistoryNodes, but it's easier just to re-create the array
-			// from resultHistory later, once (and if) needed
 			return resultHistory = strippedHistoryList;
 		}
 		/**
 		 * handy access to all HistoryNode[i].changeset values
 			}
 			return commitRevisions;
 		}
 	};
+	/**
+	 * Sends {@link ElementImpl} for each {@link HistoryNode}, and keeps track of junction points - revisions with renames
+	 */
 	private abstract class HandlerDispatcher {
 		private final int CACHE_CSET_IN_ADVANCE_THRESHOLD = 100; /* XXX is it really worth it? */
 		// builds tree of nodes according to parents in file's revlog
 		private final TreeBuildInspector treeBuildInspector = new TreeBuildInspector(followAncestry);
 		private List<HistoryNode> changeHistory;
 		private HistoryNode junctionNode;
 		// initialized when there's HgFileRenameHandlerMixin
 		private HgFileRevision copiedFrom, copiedTo;
 		// parentProgress shall be initialized with 4 XXX refactor all this stuff with parentProgress
-		public void prepare(ProgressSupport parentProgress, Pair<HgDataFile, Nodeid> renameInfo) throws HgRuntimeException {
+		public void prepare(ProgressSupport parentProgress, QueueElement renameInfo) throws HgRuntimeException {
-			// if we don't followAncestry, take complete history
+			changeHistory = treeBuildInspector.go(renameInfo);
-			// XXX treeBuildInspector knows followAncestry, perhaps the logic
-			// whether to take specific revision or the last one shall be there?
-			changeHistory = treeBuildInspector.go(renameInfo.first(), followAncestry ? renameInfo.second() : null);
 			assert changeHistory.size() > 0;
 			parentProgress.worked(1);
 			int historyNodeCount = changeHistory.size();
 			if (ei == null) {
 				// when follow is true, changeHistory.size() of the first revision might be quite short
 			} else {
 				progress = new ProgressSupport.Sub(parentProgress, 3);
 			}
 			progress.start(historyNodeCount);
 			// switch to present chunk's file node
-			switchTo(renameInfo.first());
+			switchTo(renameInfo.file());
 		}
-		public void updateJunctionPoint(Pair<HgDataFile, Nodeid> curRename, Pair<HgDataFile, Nodeid> nextRename, boolean needCopyFromTo) throws HgRuntimeException {
+		public void updateJunctionPoint(QueueElement curRename, QueueElement nextRename, boolean needCopyFromTo) throws HgRuntimeException {
 			copiedFrom = copiedTo = null;
 			//
 			// A (old) renamed to B(new).  A(0..k..n) -> B(0..m). If followAncestry, k == n
 			// curRename.second() points to A(k)
 			if (iterateDirection == HgIterateDirection.OldToNew) {
 				// looking at A chunk (curRename), nextRename points to B
-				HistoryNode junctionSrc = findJunctionPointInCurrentChunk(curRename.second()); // A(k)
+				HistoryNode junctionSrc = findJunctionPointInCurrentChunk(curRename.lastFileRev()); // A(k)
-				HistoryNode junctionDestMock = treeBuildInspector.one(nextRename.first(), 0); // B(0)
+				HistoryNode junctionDestMock = treeBuildInspector.one(nextRename.file(), 0); // B(0)
 				// junstionDestMock is mock object, once we iterate next rename, there'd be different HistoryNode
 				// for B's first revision. This means we read it twice, but this seems to be reasonable
 				// price for simplicity of the code (and opportunity to follow renames while not following ancestry)
 				junctionSrc.bindChild(junctionDestMock);
 				// Save mock A(k) 1) not to keep whole A history in memory 2) Don't need it's parent and children once get to B
 				// moreover, children of original A(k) (junctionSrc) would list mock B(0) which is undesired once we iterate over real B
 				junctionNode = new HistoryNode(junctionSrc.changeset, junctionSrc.fileRevision, null, null);
 				if (needCopyFromTo) {
-					copiedFrom = new HgFileRevision(curRename.first(), junctionNode.fileRevision, null); // "A", A(k)
+					copiedFrom = new HgFileRevision(curRename.file(), junctionNode.fileRevision, null); // "A", A(k)
-					copiedTo = new HgFileRevision(nextRename.first(), junctionDestMock.fileRevision, copiedFrom.getPath()); // "B", B(0)
+					copiedTo = new HgFileRevision(nextRename.file(), junctionDestMock.fileRevision, copiedFrom.getPath()); // "B", B(0)
 				}
 			} else {
 				assert iterateDirection == HgIterateDirection.NewToOld;
 				// looking at B chunk (curRename), nextRename points at A
 				HistoryNode junctionDest = changeHistory.get(0); // B(0)
 				// prepare mock A(k)
-				HistoryNode junctionSrcMock = treeBuildInspector.one(nextRename.first(), nextRename.second()); // A(k)
+				HistoryNode junctionSrcMock = treeBuildInspector.one(nextRename.file(), nextRename.lastFileRev()); // A(k)
 				// B(0) to list A(k) as its parent
 				// NOTE, A(k) would be different when we reach A chunk on the next iteration,
 				// but we do not care as long as TreeElement needs only parent/child changesets
 				// and not other TreeElements; so that it's enough to have mock parent node (just
 				// for the sake of parent cset revisions). We have to, indeed, update real A(k),
 				// once we get to iteration over A, with B(0) (junctionDest) as one more child.
 				junctionSrcMock.bindChild(junctionDest);
 				// Save mock B(0), for reasons see above for opposite direction
 				junctionNode = new HistoryNode(junctionDest.changeset, junctionDest.fileRevision, null, null);
 				if (needCopyFromTo) {
-					copiedFrom = new HgFileRevision(nextRename.first(), junctionSrcMock.fileRevision, null); // "A", A(k)
+					copiedFrom = new HgFileRevision(nextRename.file(), junctionSrcMock.fileRevision, null); // "A", A(k)
-					copiedTo = new HgFileRevision(curRename.first(), junctionNode.fileRevision, copiedFrom.getPath()); // "B", B(0)
+					copiedTo = new HgFileRevision(curRename.file(), junctionNode.fileRevision, copiedFrom.getPath()); // "B", B(0)
 				}
 			}
 		}
 		public void reportRenames(HgFileRenameHandlerMixin renameHandler) throws HgCallbackTargetException, HgRuntimeException {
 		}
 		/**
 		 * Replace mock src/dest HistoryNode connected to junctionNode with a real one
 		 */
-		public void connectWithLastJunctionPoint(Pair<HgDataFile, Nodeid> curRename, Pair<HgDataFile, Nodeid> prevRename) {
+		public void connectWithLastJunctionPoint(QueueElement curRename, QueueElement prevRename) {
 			assert junctionNode != null;
 			// A renamed to B. A(0..k..n) -> B(0..m). If followAncestry: k == n
 			if (iterateDirection == HgIterateDirection.OldToNew) {
 				// forward, from old to new:
 				// changeHistory points to B
 				assert iterateDirection == HgIterateDirection.NewToOld;
 				// changeHistory points to A
 				// Already reported B(m), B(m-1)...B(0), B(0) is in junctionNode
 				// Shall connect histories A(k).bind(B(0))
 				// if followAncestry: A(k) is latest in changeHistory (k == n)
-				HistoryNode junctionSrc = findJunctionPointInCurrentChunk(curRename.second()); // A(k)
+				HistoryNode junctionSrc = findJunctionPointInCurrentChunk(curRename.lastFileRev()); // A(k)
 				junctionSrc.bindChild(junctionNode);
 			}
 		}
 		private HistoryNode findJunctionPointInCurrentChunk(Nodeid fileRevision) {

Mercurial > jhg

comparison src/org/tmatesoft/hg/core/HgLogCommand.java @ 692:e970b333f284