# HG changeset patch # User Artem Tikhomirov # Date 1373449999 -7200 # Node ID af5223b86dd378c78c717b737169b1549671fe11 # Parent 5d8798772ccae8f4f8abd7f3ac4a648e2f78c835# Parent a5cf64f2e7e42180c03754b4c32f167d17702f3d Merge branch smartgit-4.6 diff -r a5cf64f2e7e4 -r af5223b86dd3 .hgtags --- a/.hgtags Fri Jul 05 20:42:45 2013 +0200 +++ b/.hgtags Wed Jul 10 11:53:19 2013 +0200 @@ -9,3 +9,4 @@ f41dd9a3b8af1a5f74b533cd9f00b7d77423cc04 v1.1m4 5afc7eedb3dd109f75e5f5a02dd88c9c4e7b7f3b v1.1rc1 54e16ab771ec03d69cb05e38622ebdf9c3302c8c v1.1rc2 +2f33f102a8fa59274a27ebbe1c2903cecac6c5d5 v1.1.0 diff -r a5cf64f2e7e4 -r af5223b86dd3 build.gradle --- a/build.gradle Fri Jul 05 20:42:45 2013 +0200 +++ b/build.gradle Wed Jul 10 11:53:19 2013 +0200 @@ -16,7 +16,7 @@ */ def isRelease = false - version = '1.1.0-SNAPSHOT' + version = '1.2.0-SNAPSHOT' description = 'Pure Java API and Toolkit for Mercurial DVCS' group = 'org.tmatesoft.hg4j' diff -r a5cf64f2e7e4 -r af5223b86dd3 build.xml --- a/build.xml Fri Jul 05 20:42:45 2013 +0200 +++ b/build.xml Wed Jul 10 11:53:19 2013 +0200 @@ -27,7 +27,7 @@ - + @@ -110,6 +110,9 @@ + + + diff -r a5cf64f2e7e4 -r af5223b86dd3 cmdline/org/tmatesoft/hg/console/Main.java --- a/cmdline/org/tmatesoft/hg/console/Main.java Fri Jul 05 20:42:45 2013 +0200 +++ b/cmdline/org/tmatesoft/hg/console/Main.java Wed Jul 10 11:53:19 2013 +0200 @@ -103,7 +103,7 @@ public static void main(String[] args) throws Exception { Main m = new Main(args); - m.checkFileSneakerPerformance(); +// m.checkFileSneakerPerformance(); // m.testRevert(); // m.testCheckout(); // m.tryExtensions(); @@ -119,7 +119,7 @@ // m.testEffectiveFileLog(); // m.testMergeState(); // m.testFileStatus(); -// m.dumpBranches(); + m.dumpBranches(); // m.inflaterLengthException(); // m.dumpIgnored(); // m.dumpDirstate(); diff -r a5cf64f2e7e4 -r af5223b86dd3 cmdline/org/tmatesoft/hg/console/Push.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmdline/org/tmatesoft/hg/console/Push.java Wed Jul 10 11:53:19 2013 +0200 @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2013 TMate Software Ltd + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * For information on how to redistribute this software under + * the terms of a license other than GNU General Public License + * contact TMate Software at support@hg4j.com + */ +package org.tmatesoft.hg.console; + +import java.util.Collections; + +import org.tmatesoft.hg.core.HgPushCommand; +import org.tmatesoft.hg.core.HgRepoFacade; +import org.tmatesoft.hg.repo.HgLookup; +import org.tmatesoft.hg.repo.HgRemoteRepository; + +/** + * + * @author Artem Tikhomirov + * @author TMate Software Ltd. + */ +public class Push { + + public static void main(String[] args) throws Exception { + Options cmdLineOpts = Options.parse(args, Collections.emptySet()); + HgRepoFacade hgRepo = new HgRepoFacade(); + if (!hgRepo.init(cmdLineOpts.findRepository())) { + System.err.printf("Can't find repository in: %s\n", hgRepo.getRepository().getLocation()); + return; + } + // XXX perhaps, HgRepoFacade shall get detectRemote() analog (to get remote server with respect of facade's repo) + HgRemoteRepository hgRemote = new HgLookup().detectRemote(cmdLineOpts.getSingle(""), hgRepo.getRepository()); + if (hgRemote.isInvalid()) { + System.err.printf("Remote repository %s is not valid", hgRemote.getLocation()); + return; + } + HgPushCommand cmd = hgRepo.createPushCommand(); + cmd.destination(hgRemote); + cmd.execute(); + System.out.printf("Added %d changesets\n", cmd.getPushedRevisions().size()); + } +} diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/core/HgOutgoingCommand.java --- a/src/org/tmatesoft/hg/core/HgOutgoingCommand.java Fri Jul 05 20:42:45 2013 +0200 +++ b/src/org/tmatesoft/hg/core/HgOutgoingCommand.java Wed Jul 10 11:53:19 2013 +0200 @@ -21,7 +21,9 @@ import java.util.TreeSet; import org.tmatesoft.hg.internal.Internals; +import org.tmatesoft.hg.internal.PhasesHelper; import org.tmatesoft.hg.internal.RepositoryComparator; +import org.tmatesoft.hg.internal.RevisionSet; import org.tmatesoft.hg.repo.HgChangelog; import org.tmatesoft.hg.repo.HgParentChildMap; import org.tmatesoft.hg.repo.HgRemoteRepository; @@ -103,8 +105,7 @@ public List executeLite() throws HgRemoteConnectionException, HgException, CancelledException { final ProgressSupport ps = getProgressSupport(null); try { - ps.start(10); - return getComparator(new ProgressSupport.Sub(ps, 5), getCancelSupport(null, true)).getLocalOnlyRevisions(); + return getOutgoingRevisions(ps, getCancelSupport(null, true)); } catch (HgRuntimeException ex) { throw new HgLibraryFailureException(ex); } finally { @@ -128,10 +129,16 @@ final ProgressSupport ps = getProgressSupport(handler); final CancelSupport cs = getCancelSupport(handler, true); try { - ps.start(-1); - ChangesetTransformer inspector = new ChangesetTransformer(localRepo, handler, getParentHelper(), ps, cs); + ps.start(200); + ChangesetTransformer inspector = new ChangesetTransformer(localRepo, handler, getParentHelper(), new ProgressSupport.Sub(ps, 100), cs); inspector.limitBranches(branches); - getComparator(new ProgressSupport.Sub(ps, 1), cs).visitLocalOnlyRevisions(inspector); + List out = getOutgoingRevisions(new ProgressSupport.Sub(ps, 100), cs); + int[] outRevIndex = new int[out.size()]; + int i = 0; + for (Nodeid o : out) { + outRevIndex[i++] = localRepo.getChangelog().getRevisionIndex(o); + } + localRepo.getChangelog().range(inspector, outRevIndex); inspector.checkFailure(); } catch (HgRuntimeException ex) { throw new HgLibraryFailureException(ex); @@ -159,4 +166,17 @@ return parentHelper; } + + private List getOutgoingRevisions(ProgressSupport ps, CancelSupport cs) throws HgRemoteConnectionException, HgException, CancelledException { + ps.start(10); + final RepositoryComparator c = getComparator(new ProgressSupport.Sub(ps, 5), cs); + List local = c.getLocalOnlyRevisions(); + ps.worked(3); + PhasesHelper phaseHelper = new PhasesHelper(Internals.getInstance(localRepo)); + if (phaseHelper.isCapableOfPhases() && phaseHelper.withSecretRoots()) { + local = new RevisionSet(local).subtract(phaseHelper.allSecret()).asList(); + } + ps.worked(2); + return local; + } } diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/core/HgPullCommand.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/org/tmatesoft/hg/core/HgPullCommand.java Wed Jul 10 11:53:19 2013 +0200 @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2013 TMate Software Ltd + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * For information on how to redistribute this software under + * the terms of a license other than GNU General Public License + * contact TMate Software at support@hg4j.com + */ +package org.tmatesoft.hg.core; + +import java.util.List; + +import org.tmatesoft.hg.internal.AddRevInspector; +import org.tmatesoft.hg.internal.COWTransaction; +import org.tmatesoft.hg.internal.Internals; +import org.tmatesoft.hg.internal.PhasesHelper; +import org.tmatesoft.hg.internal.RepositoryComparator; +import org.tmatesoft.hg.internal.RevisionSet; +import org.tmatesoft.hg.internal.Transaction; +import org.tmatesoft.hg.repo.HgBundle; +import org.tmatesoft.hg.repo.HgChangelog; +import org.tmatesoft.hg.repo.HgInternals; +import org.tmatesoft.hg.repo.HgParentChildMap; +import org.tmatesoft.hg.repo.HgRemoteRepository; +import org.tmatesoft.hg.repo.HgRepository; +import org.tmatesoft.hg.repo.HgRuntimeException; +import org.tmatesoft.hg.util.CancelledException; +import org.tmatesoft.hg.util.ProgressSupport; + +/** + * + * @author Artem Tikhomirov + * @author TMate Software Ltd. + */ +public class HgPullCommand extends HgAbstractCommand { + + private final HgRepository repo; + private HgRemoteRepository remote; + + public HgPullCommand(HgRepository hgRepo) { + repo = hgRepo; + } + + public HgPullCommand source(HgRemoteRepository hgRemote) { + remote = hgRemote; + return this; + } + + public void execute() throws HgRemoteConnectionException, HgIOException, HgLibraryFailureException, CancelledException { + final ProgressSupport progress = getProgressSupport(null); + try { + progress.start(100); + // TODO refactor same code in HgIncomingCommand #getComparator and #getParentHelper + final HgChangelog clog = repo.getChangelog(); + final HgParentChildMap parentHelper = new HgParentChildMap(clog); + parentHelper.init(); + final RepositoryComparator comparator = new RepositoryComparator(parentHelper, remote); + // get incoming revisions + comparator.compare(new ProgressSupport.Sub(progress, 50), getCancelSupport(null, true)); + final List common = comparator.getCommon(); + // get bundle with changes from remote + HgBundle incoming = remote.getChanges(common); + // + // add revisions to changelog, manifest, files + final Internals implRepo = HgInternals.getImplementationRepo(repo); + final AddRevInspector insp; + Transaction.Factory trFactory = new COWTransaction.Factory(); + Transaction tr = trFactory.create(repo); + try { + incoming.inspectAll(insp = new AddRevInspector(implRepo, tr)); + tr.commit(); + } catch (HgRuntimeException ex) { + tr.rollback(); + throw ex; + } catch (RuntimeException ex) { + tr.rollback(); + throw ex; + } + progress.worked(45); + RevisionSet added = insp.addedChangesets(); + + // get remote phases, update local phases to match that of remote + final PhasesHelper phaseHelper = new PhasesHelper(implRepo, parentHelper); + if (phaseHelper.isCapableOfPhases()) { + RevisionSet rsCommon = new RevisionSet(common); + HgRemoteRepository.Phases remotePhases = remote.getPhases(); + if (remotePhases.isPublishingServer()) { + final RevisionSet knownPublic = rsCommon.union(added); + RevisionSet newDraft = phaseHelper.allDraft().subtract(knownPublic); + RevisionSet newSecret = phaseHelper.allSecret().subtract(knownPublic); + phaseHelper.updateRoots(newDraft.asList(), newSecret.asList()); + } else { + // FIXME refactor reuse from HgPushCommand + } + } + progress.worked(5); + } catch (HgRuntimeException ex) { + throw new HgLibraryFailureException(ex); + } finally { + progress.done(); + } + } +} diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/core/HgPushCommand.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/org/tmatesoft/hg/core/HgPushCommand.java Wed Jul 10 11:53:19 2013 +0200 @@ -0,0 +1,228 @@ +/* + * Copyright (c) 2013 TMate Software Ltd + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * For information on how to redistribute this software under + * the terms of a license other than GNU General Public License + * contact TMate Software at support@hg4j.com + */ +package org.tmatesoft.hg.core; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import org.tmatesoft.hg.internal.BundleGenerator; +import org.tmatesoft.hg.internal.Internals; +import org.tmatesoft.hg.internal.PhasesHelper; +import org.tmatesoft.hg.internal.RepositoryComparator; +import org.tmatesoft.hg.internal.RevisionSet; +import org.tmatesoft.hg.repo.HgBookmarks; +import org.tmatesoft.hg.repo.HgBundle; +import org.tmatesoft.hg.repo.HgChangelog; +import org.tmatesoft.hg.repo.HgInternals; +import org.tmatesoft.hg.repo.HgInvalidStateException; +import org.tmatesoft.hg.repo.HgLookup; +import org.tmatesoft.hg.repo.HgParentChildMap; +import org.tmatesoft.hg.repo.HgPhase; +import org.tmatesoft.hg.repo.HgRemoteRepository; +import org.tmatesoft.hg.repo.HgRepository; +import org.tmatesoft.hg.repo.HgRuntimeException; +import org.tmatesoft.hg.util.CancelledException; +import org.tmatesoft.hg.util.LogFacility.Severity; +import org.tmatesoft.hg.util.Outcome; +import org.tmatesoft.hg.util.Pair; +import org.tmatesoft.hg.util.ProgressSupport; + +/** + * + * @author Artem Tikhomirov + * @author TMate Software Ltd. + */ +public class HgPushCommand extends HgAbstractCommand { + + private final HgRepository repo; + private HgRemoteRepository remoteRepo; + private RevisionSet outgoing; + + public HgPushCommand(HgRepository hgRepo) { + repo = hgRepo; + } + + public HgPushCommand destination(HgRemoteRepository hgRemote) { + remoteRepo = hgRemote; + return this; + } + + public void execute() throws HgRemoteConnectionException, HgIOException, CancelledException, HgLibraryFailureException { + final ProgressSupport progress = getProgressSupport(null); + try { + progress.start(100); + // + // find out missing + // TODO refactor same code in HgOutgoingCommand #getComparator and #getParentHelper + final HgChangelog clog = repo.getChangelog(); + final HgParentChildMap parentHelper = new HgParentChildMap(clog); + parentHelper.init(); + final Internals implRepo = HgInternals.getImplementationRepo(repo); + final PhasesHelper phaseHelper = new PhasesHelper(implRepo, parentHelper); + final RepositoryComparator comparator = new RepositoryComparator(parentHelper, remoteRepo); + comparator.compare(new ProgressSupport.Sub(progress, 50), getCancelSupport(null, true)); + List l = comparator.getLocalOnlyRevisions(); + if (phaseHelper.isCapableOfPhases() && phaseHelper.withSecretRoots()) { + RevisionSet secret = phaseHelper.allSecret(); + outgoing = new RevisionSet(l).subtract(secret); + } else { + outgoing = new RevisionSet(l); + } + // + // prepare bundle + BundleGenerator bg = new BundleGenerator(implRepo); + File bundleFile = bg.create(outgoing.asList()); + progress.worked(20); + HgBundle b = new HgLookup(repo.getSessionContext()).loadBundle(bundleFile); + // + // send changes + remoteRepo.unbundle(b, comparator.getRemoteHeads()); + progress.worked(20); + // + // update phase information + if (phaseHelper.isCapableOfPhases()) { + RevisionSet presentSecret = phaseHelper.allSecret(); + RevisionSet presentDraft = phaseHelper.allDraft(); + RevisionSet secretLeft, draftLeft; + HgRemoteRepository.Phases remotePhases = remoteRepo.getPhases(); + RevisionSet remoteDrafts = knownRemoteDrafts(remotePhases, parentHelper, outgoing, presentSecret); + if (remotePhases.isPublishingServer()) { + // although it's unlikely outgoing would affect secret changesets, + // it doesn't hurt to check secret roots along with draft ones + secretLeft = presentSecret.subtract(outgoing); + draftLeft = presentDraft.subtract(outgoing); + } else { + // shall merge local and remote phase states + // revisions that cease to be secret (gonna become Public), e.g. someone else pushed them + RevisionSet secretGone = presentSecret.intersect(remoteDrafts); + // parents of those remote drafts are public, mark them as public locally, too + RevisionSet remotePublic = presentSecret.ancestors(secretGone, parentHelper); + secretLeft = presentSecret.subtract(secretGone).subtract(remotePublic); + /* + * Revisions grow from left to right (parents to the left, children to the right) + * + * I: Set of local is subset of remote + * + * local draft + * --o---r---o---l---o-- + * remote draft + * + * Remote draft roots shall be updated + * + * + * II: Set of local is superset of remote + * + * local draft + * --o---l---o---r---o-- + * remote draft + * + * Local draft roots shall be updated + */ + RevisionSet sharedDraft = presentDraft.intersect(remoteDrafts); // (I: ~presentDraft; II: ~remoteDraft + // XXX do I really need sharedDrafts here? why not ancestors(remoteDrafts)? + RevisionSet localDraftRemotePublic = presentDraft.ancestors(sharedDraft, parentHelper); // I: 0; II: those treated public on remote + // remoteDrafts are local revisions known as draft@remote + // remoteDraftsLocalPublic - revisions that would cease to be listed as draft on remote + RevisionSet remoteDraftsLocalPublic = remoteDrafts.ancestors(sharedDraft, parentHelper); + RevisionSet remoteDraftsLeft = remoteDrafts.subtract(remoteDraftsLocalPublic); + // forget those deemed public by remote (drafts shared by both remote and local are ok to stay) + RevisionSet combinedDraft = presentDraft.union(remoteDraftsLeft); + draftLeft = combinedDraft.subtract(localDraftRemotePublic); + } + final RevisionSet newDraftRoots = draftLeft.roots(parentHelper); + final RevisionSet newSecretRoots = secretLeft.roots(parentHelper); + phaseHelper.updateRoots(newDraftRoots.asList(), newSecretRoots.asList()); + // + // if there's a remote draft root that points to revision we know is public + RevisionSet remoteDraftsLocalPublic = remoteDrafts.subtract(draftLeft).subtract(secretLeft); + if (!remoteDraftsLocalPublic.isEmpty()) { + // foreach remoteDraftsLocallyPublic.heads() do push Draft->Public + for (Nodeid n : remoteDraftsLocalPublic.heads(parentHelper)) { + try { + Outcome upo = remoteRepo.updatePhase(HgPhase.Draft, HgPhase.Public, n); + if (!upo.isOk()) { + implRepo.getLog().dump(getClass(), Severity.Info, "Failed to update remote phase, reason: %s", upo.getMessage()); + } + } catch (HgRemoteConnectionException ex) { + implRepo.getLog().dump(getClass(), Severity.Error, ex, String.format("Failed to update phase of %s", n.shortNotation())); + } + } + } + } + progress.worked(5); + // + // update bookmark information + HgBookmarks localBookmarks = repo.getBookmarks(); + if (!localBookmarks.getAllBookmarks().isEmpty()) { + for (Pair bm : remoteRepo.getBookmarks()) { + Nodeid localRevision = localBookmarks.getRevision(bm.first()); + if (localRevision == null || !parentHelper.knownNode(bm.second())) { + continue; + } + // we know both localRevision and revision of remote bookmark, + // need to make sure we don't push older revision than it's at the server + if (parentHelper.isChild(bm.second(), localRevision)) { + remoteRepo.updateBookmark(bm.first(), bm.second(), localRevision); + } + } + } + // XXX WTF is obsolete in namespaces key?? + progress.worked(5); + } catch (IOException ex) { + throw new HgIOException(ex.getMessage(), null); // XXX not a nice idea to throw IOException from BundleGenerator#create + } catch (HgRepositoryNotFoundException ex) { + final HgInvalidStateException e = new HgInvalidStateException("Failed to load a just-created bundle"); + e.initCause(ex); + throw new HgLibraryFailureException(e); + } catch (HgRuntimeException ex) { + throw new HgLibraryFailureException(ex); + } finally { + progress.done(); + } + } + + public Collection getPushedRevisions() { + return outgoing == null ? Collections.emptyList() : outgoing.asList(); + } + + private RevisionSet knownRemoteDrafts(HgRemoteRepository.Phases remotePhases, HgParentChildMap parentHelper, RevisionSet outgoing, RevisionSet localSecret) { + ArrayList knownRemoteDraftRoots = new ArrayList(); + for (Nodeid rdr : remotePhases.draftRoots()) { + if (parentHelper.knownNode(rdr)) { + knownRemoteDraftRoots.add(rdr); + } + } + // knownRemoteDraftRoots + childrenOf(knownRemoteDraftRoots) is everything remote may treat as Draft + RevisionSet remoteDrafts = new RevisionSet(knownRemoteDraftRoots); + RevisionSet localChildren = remoteDrafts.children(parentHelper); + // we didn't send any local secret revision + localChildren = localChildren.subtract(localSecret); + // draft roots are among remote drafts + remoteDrafts = remoteDrafts.union(localChildren); + // 1) outgoing.children gives all local revisions accessible from outgoing. + // 2) outgoing.roots.children is equivalent with smaller intermediate set, the way we build + // childrenOf doesn't really benefits from that. + RevisionSet localChildrenNotSent = outgoing.children(parentHelper).subtract(outgoing); + // remote shall know only what we've sent, subtract revisions we didn't actually sent + remoteDrafts = remoteDrafts.subtract(localChildrenNotSent); + return remoteDrafts; + } +} diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/core/HgRepoFacade.java --- a/src/org/tmatesoft/hg/core/HgRepoFacade.java Fri Jul 05 20:42:45 2013 +0200 +++ b/src/org/tmatesoft/hg/core/HgRepoFacade.java Wed Jul 10 11:53:19 2013 +0200 @@ -165,4 +165,12 @@ public HgDiffCommand createDiffCommand() { return new HgDiffCommand(repo); } + + public HgPushCommand createPushCommand() { + return new HgPushCommand(repo); + } + + public HgPullCommand createPullCommand() { + return new HgPullCommand(repo); + } } diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/internal/AddRevInspector.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/org/tmatesoft/hg/internal/AddRevInspector.java Wed Jul 10 11:53:19 2013 +0200 @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2013 TMate Software Ltd + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * For information on how to redistribute this software under + * the terms of a license other than GNU General Public License + * contact TMate Software at support@hg4j.com + */ +package org.tmatesoft.hg.internal; + +import java.util.HashMap; +import java.util.Set; + +import org.tmatesoft.hg.core.HgIOException; +import org.tmatesoft.hg.core.Nodeid; +import org.tmatesoft.hg.repo.HgBundle; +import org.tmatesoft.hg.repo.HgBundle.GroupElement; +import org.tmatesoft.hg.repo.HgDataFile; +import org.tmatesoft.hg.repo.HgInvalidControlFileException; +import org.tmatesoft.hg.repo.HgRepository; +import org.tmatesoft.hg.repo.HgRuntimeException; +import org.tmatesoft.hg.util.Pair; + +/** + * @author Artem Tikhomirov + * @author TMate Software Ltd. + */ +public final class AddRevInspector implements HgBundle.Inspector { + private final Internals repo; + private final Transaction tr; + private Set added; + private RevlogStreamWriter revlog; + private RevMap clogRevs; + private RevMap revlogRevs; + + public AddRevInspector(Internals implRepo, Transaction transaction) { + repo = implRepo; + tr = transaction; + } + + public void changelogStart() throws HgRuntimeException { + // TODO Auto-generated method stub + RevlogStream rs = repo.getImplAccess().getChangelogStream(); + revlog = new RevlogStreamWriter(repo, rs, tr); + revlogRevs = clogRevs = new RevMap(rs); + } + + public void changelogEnd() throws HgRuntimeException { + revlog = null; + revlogRevs = null; + added = clogRevs.added(); + } + + public void manifestStart() throws HgRuntimeException { + RevlogStream rs = repo.getImplAccess().getManifestStream(); + revlog = new RevlogStreamWriter(repo, rs, tr); + revlogRevs = new RevMap(rs); + } + + public void manifestEnd() throws HgRuntimeException { + revlog = null; + revlogRevs = null; + } + + public void fileStart(String name) throws HgRuntimeException { + HgDataFile df = repo.getRepo().getFileNode(name); + RevlogStream rs = repo.getImplAccess().getStream(df); + revlog = new RevlogStreamWriter(repo, rs, tr); + revlogRevs = new RevMap(rs); + // FIXME collect new files and update fncache + } + + public void fileEnd(String name) throws HgRuntimeException { + revlog = null; + revlogRevs = null; + } + + public boolean element(GroupElement ge) throws HgRuntimeException { + assert clogRevs != null; + assert revlogRevs != null; + try { + Pair newRev = revlog.addPatchRevision(ge, clogRevs, revlogRevs); + revlogRevs.update(newRev.first(), newRev.second()); + return true; + } catch (HgIOException ex) { + throw new HgInvalidControlFileException(ex, true); + } + } + + public RevisionSet addedChangesets() { + return new RevisionSet(added); + } + + private static class RevMap implements RevlogStreamWriter.RevisionToIndexMap { + + private final RevlogStream revlog; + private HashMap added = new HashMap(); + + public RevMap(RevlogStream revlogStream) { + revlog = revlogStream; + } + + public int revisionIndex(Nodeid revision) { + Integer a = added.get(revision); + if (a != null) { + return a; + } + int f = revlog.findRevisionIndex(revision); + return f == HgRepository.BAD_REVISION ? HgRepository.NO_REVISION : f; + } + + public void update(Integer revIndex, Nodeid rev) { + added.put(rev, revIndex); + } + + Set added() { + return added.keySet(); + } + } +} \ No newline at end of file diff -r a5cf64f2e7e4 -r af5223b86dd3 src/org/tmatesoft/hg/internal/ArrayHelper.java --- a/src/org/tmatesoft/hg/internal/ArrayHelper.java Fri Jul 05 20:42:45 2013 +0200 +++ b/src/org/tmatesoft/hg/internal/ArrayHelper.java Wed Jul 10 11:53:19 2013 +0200 @@ -16,40 +16,106 @@ */ package org.tmatesoft.hg.internal; +import java.util.Arrays; + /** * Internal alternative to Arrays.sort to build reversed index along with sorting + * and to perform lookup (binary search) without sorted array, using reversed index. * * @author Artem Tikhomirov * @author TMate Software Ltd. */ -public class ArrayHelper { - private int[] reverse; +public final class ArrayHelper> { + private int[] reverse; // aka sorted2natural + private final T[] data; + private T[] sorted; + + public ArrayHelper(T[] _data) { + assert _data != null; + data = _data; + } - @SuppressWarnings("unchecked") - public void sort(Comparable[] a) { -// Object[] aux = (Object[]) a.clone(); - reverse = new int[a.length]; - sort1((Comparable