diff options
Diffstat (limited to 'platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java')
| -rw-r--r-- | platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java | 354 |
1 files changed, 166 insertions, 188 deletions
diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java index c7ab5e324b3d..09de51c722bf 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/VcsLogRefresherImpl.java @@ -27,6 +27,7 @@ import com.intellij.openapi.vcs.VcsException; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.Consumer; import com.intellij.util.Function; +import com.intellij.util.NotNullFunction; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.ui.UIUtil; import com.intellij.vcs.log.*; @@ -62,7 +63,8 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { @NotNull final VcsUserRegistryImpl userRegistry, @NotNull Map<Hash, VcsCommitMetadata> topCommitsDetailsCache, @NotNull final Consumer<DataPack> dataPackUpdateHandler, - @NotNull Consumer<Exception> exceptionHandler, int recentCommitsCount) { + @NotNull Consumer<Exception> exceptionHandler, + int recentCommitsCount) { myProject = project; myHashMap = hashMap; myProviders = providers; @@ -95,16 +97,11 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { @Override public DataPack readFirstBlock() { try { - Map<VirtualFile, Collection<VcsRef>> refs = loadRefsFromVcs(myProviders); - Set<VirtualFile> roots = myProviders.keySet(); - Map<VirtualFile, VcsLogProvider.Requirements> requirements = prepareSimpleRequirements(roots, myRecentCommitCount); - Map<VirtualFile, List<? extends GraphCommit<Integer>>> commits = loadRecentCommitsFromVcs(myProviders, requirements, - myUserRegistry, myTopCommitsDetailsCache, - myHashMap); - List<? extends GraphCommit<Integer>> compoundLog = compound(commits.values()); - DataPack dataPack = DataPack.build(compoundLog, new RefsModel(refs, myHashMap.asIndexGetter()), - myHashMap.asIndexGetter(), myHashMap.asHashGetter(), myProviders, false); - mySingleTaskController.request(RefreshRequest.RELOAD_ALL); // build/rebuild the full log in bg + LogInfo data = loadRecentData(new CommitCountRequirements(myRecentCommitCount).asMap(myProviders.keySet())); + Collection<List<GraphCommit<Integer>>> commits = data.getCommits(); + Map<VirtualFile, Set<VcsRef>> refs = data.getRefs(); + DataPack dataPack = DataPack.build(multiRepoJoin(commits), refs, myProviders, myHashMap, false); + mySingleTaskController.request(RefreshRequest.RELOAD_ALL); // build/rebuild the full log in background return dataPack; } catch (VcsException e) { @@ -113,109 +110,77 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { } } - @Override - public void refresh(@NotNull Collection<VirtualFile> rootsToRefresh) { - if (!rootsToRefresh.isEmpty()) { - mySingleTaskController.request(new RefreshRequest(rootsToRefresh)); - } - } - @NotNull - private static Map<VirtualFile, VcsLogProvider.Requirements> prepareSimpleRequirements(@NotNull Collection<VirtualFile> roots, - final int commitCount) { - final VcsLogProvider.Requirements requirements = new VcsLogProvider.Requirements() { - @Override - public int getCommitCount() { - return commitCount; - } - }; - return ContainerUtil.map2Map(roots, new Function<VirtualFile, Pair<VirtualFile, VcsLogProvider.Requirements>>() { - @Override - public Pair<VirtualFile, VcsLogProvider.Requirements> fun(VirtualFile file) { - return Pair.create(file, requirements); - } - }); - } - - @NotNull - private static Map<VirtualFile, Collection<VcsRef>> loadRefsFromVcs(@NotNull Map<VirtualFile, VcsLogProvider> providers) - throws VcsException { - final StopWatch sw = StopWatch.start("loading refs"); - final Map<VirtualFile, Collection<VcsRef>> refs = ContainerUtil.newHashMap(); + private LogInfo loadRecentData(@NotNull final Map<VirtualFile, VcsLogProvider.Requirements> requirements) throws VcsException { + final StopWatch sw = StopWatch.start("loading commits"); + final LogInfo logInfo = new LogInfo(); new ProviderIterator() { @Override - void each(@NotNull VirtualFile root, @NotNull VcsLogProvider provider) throws VcsException { - refs.put(root, provider.readAllRefs(root)); + public void each(@NotNull VirtualFile root, @NotNull VcsLogProvider provider) throws VcsException { + VcsLogProvider.DetailedLogData data = provider.readFirstBlock(root, requirements.get(root)); + storeUsersAndDetails(data.getCommits()); + logInfo.put(root, compactCommits(data.getCommits())); + logInfo.put(root, data.getRefs()); sw.rootCompleted(root); } - }.iterate(providers); + }.iterate(getProvidersForRoots(requirements.keySet())); + myUserRegistry.flush(); sw.report(); - return refs; + return logInfo; } @NotNull - private static Map<VirtualFile, List<? extends GraphCommit<Integer>>> loadRecentCommitsFromVcs( - @NotNull Map<VirtualFile, VcsLogProvider> providers, - @NotNull final Map<VirtualFile, VcsLogProvider.Requirements> requirements, - @NotNull final VcsUserRegistryImpl userRegistry, - @NotNull final Map<Hash, VcsCommitMetadata> topCommitsDetailsCache, - @NotNull final VcsLogHashMap hashMap) throws VcsException - { - final StopWatch sw = StopWatch.start("loading commits"); - final Map<VirtualFile, List<? extends GraphCommit<Integer>>> commits = ContainerUtil.newHashMap(); - new ProviderIterator() { - @Override - public void each(@NotNull VirtualFile root, @NotNull VcsLogProvider provider) throws VcsException { - List<? extends VcsCommitMetadata> metadatas = provider.readFirstBlock(root, requirements.get(root)); - storeUsersAndDetails(metadatas, userRegistry, topCommitsDetailsCache); - commits.put(root, compactCommits(metadatas, hashMap)); - sw.rootCompleted(root); - } - }.iterate(providers); - userRegistry.flush(); - sw.report(); - return commits; + private Map<VirtualFile, VcsLogProvider> getProvidersForRoots(@NotNull Set<VirtualFile> roots) { + return ContainerUtil.map2Map(roots, + new Function<VirtualFile, Pair<VirtualFile, VcsLogProvider>>() { + @Override + public Pair<VirtualFile, VcsLogProvider> fun(VirtualFile root) { + return Pair.create(root, myProviders.get(root)); + } + }); + } + + @Override + public void refresh(@NotNull Collection<VirtualFile> rootsToRefresh) { + if (!rootsToRefresh.isEmpty()) { + mySingleTaskController.request(new RefreshRequest(rootsToRefresh)); + } } - /** - * Compounds logs from different repositories into a single multi-repository log. - */ @NotNull - private static List<? extends GraphCommit<Integer>> compound(@NotNull Collection<List<? extends GraphCommit<Integer>>> commits) { + private static <T extends GraphCommit<Integer>> List<T> multiRepoJoin(@NotNull Collection<List<T>> commits) { StopWatch sw = StopWatch.start("multi-repo join"); - List<? extends GraphCommit<Integer>> joined = new VcsLogMultiRepoJoiner<Integer>().join(commits); + List<T> joined = new VcsLogMultiRepoJoiner<Integer, T>().join(commits); sw.report(); return joined; } @NotNull - private static List<GraphCommit<Integer>> compactCommits(@NotNull List<? extends TimedVcsCommit> commits, - @NotNull final VcsLogHashMap hashMap) { + private List<GraphCommit<Integer>> compactCommits(@NotNull List<? extends TimedVcsCommit> commits) { StopWatch sw = StopWatch.start("compacting commits"); List<GraphCommit<Integer>> map = ContainerUtil.map(commits, new Function<TimedVcsCommit, GraphCommit<Integer>>() { @NotNull @Override public GraphCommit<Integer> fun(@NotNull TimedVcsCommit commit) { - return compactCommit(commit, hashMap); + return compactCommit(commit); } }); - hashMap.flush(); + myHashMap.flush(); sw.report(); return map; } @NotNull - private static GraphCommitImpl<Integer> compactCommit(@NotNull TimedVcsCommit commit, @NotNull VcsLogHashMap hashMap) { - return new GraphCommitImpl<Integer>(hashMap.getCommitIndex(commit.getId()), - ContainerUtil.map(commit.getParents(), hashMap.asIndexGetter()), commit.getTimestamp()); + private GraphCommitImpl<Integer> compactCommit(@NotNull TimedVcsCommit commit) { + return new GraphCommitImpl<Integer>(myHashMap.getCommitIndex(commit.getId()), + ContainerUtil.map(commit.getParents(), myHashMap.asIndexGetter()), commit.getTimestamp()); } - private static void storeUsersAndDetails(@NotNull List<? extends VcsCommitMetadata> metadatas, @NotNull VcsUserRegistryImpl userRegistry, - @NotNull Map<Hash, VcsCommitMetadata> topCommitsDetailsCache) { + private void storeUsersAndDetails(@NotNull Collection<? extends VcsCommitMetadata> metadatas) { for (VcsCommitMetadata detail : metadatas) { - userRegistry.addUser(detail.getAuthor()); - userRegistry.addUser(detail.getCommitter()); - topCommitsDetailsCache.put(detail.getId(), detail); + myUserRegistry.addUser(detail.getAuthor()); + myUserRegistry.addUser(detail.getCommitter()); + myTopCommitsDetailsCache.put(detail.getId(), detail); } } @@ -223,17 +188,7 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { @NotNull private DataPack myCurrentDataPack; - // collects loaded info from different roots, which refresh was requested consecutively within a single task - private final Map<VirtualFile, LogAndRefs> myLoadedInfos = ContainerUtil.newHashMap(); - - private class LogAndRefs { - List<? extends GraphCommit<Integer>> log; - Collection<VcsRef> refs; - LogAndRefs(Collection<VcsRef> refs, List<? extends GraphCommit<Integer>> commits) { - this.refs = refs; - this.log = commits; - } - } + @NotNull private final LogInfo myLoadedInfo = new LogInfo(); MyRefreshTask(@NotNull DataPack currentDataPack) { super(VcsLogRefresherImpl.this.myProject, "Refreshing history...", false); @@ -271,30 +226,28 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { private DataPack doRefresh(@NotNull Collection<VirtualFile> roots) { StopWatch sw = StopWatch.start("refresh"); PermanentGraph<Integer> permanentGraph = myCurrentDataPack.isFull() ? myCurrentDataPack.getPermanentGraph() : null; - Map<VirtualFile, Collection<VcsRef>> currentRefs = myCurrentDataPack.getRefsModel().getAllRefsByRoot(); + Map<VirtualFile, Set<VcsRef>> currentRefs = myCurrentDataPack.getRefsModel().getAllRefsByRoot(); try { if (permanentGraph != null) { int commitCount = myRecentCommitCount; for (int attempt = 0; attempt <= 1; attempt++) { loadLogAndRefs(roots, currentRefs, commitCount); - List<? extends GraphCommit<Integer>> compoundLog = compoundLoadedLogs(myLoadedInfos.values()); - Map<VirtualFile, Collection<VcsRef>> allNewRefs = getAllNewRefs(myLoadedInfos, currentRefs); + List<? extends GraphCommit<Integer>> compoundLog = multiRepoJoin(myLoadedInfo.getCommits()); + Map<VirtualFile, Set<VcsRef>> allNewRefs = getAllNewRefs(myLoadedInfo, currentRefs); List<GraphCommit<Integer>> joinedFullLog = join(compoundLog, permanentGraph.getAllCommits(), currentRefs, allNewRefs); if (joinedFullLog == null) { commitCount *= 5; } else { - return DataPack.build(joinedFullLog, new RefsModel(allNewRefs, myHashMap.asIndexGetter()), - myHashMap.asIndexGetter(), myHashMap.asHashGetter(), myProviders, true); + return DataPack.build(joinedFullLog, allNewRefs, myProviders, myHashMap, true); } } // couldn't join => need to reload everything; if 5000 commits is still not enough, it's worth reporting: LOG.error("Couldn't join " + commitCount + " recent commits to the log (" + permanentGraph.getAllCommits().size() + " commits)", - new Attachment("recent_commits", toLogString(myLoadedInfos))); + new Attachment("recent_commits", myLoadedInfo.toLogString(myHashMap.asIndexGetter()))); } - Pair<PermanentGraph<Integer>, Map<VirtualFile, Collection<VcsRef>>> fullLogAndRefs = loadFullLog(); - return DataPack.build(fullLogAndRefs.first, myProviders, new RefsModel(fullLogAndRefs.second, myHashMap.asIndexGetter()), true); + return loadFullLog(); } catch (Exception e) { myExceptionHandler.consume(e); @@ -305,95 +258,45 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { } } - private String toLogString(Map<VirtualFile, LogAndRefs> infos) { - StringBuilder sb = new StringBuilder(); - for (Map.Entry<VirtualFile, LogAndRefs> entry : infos.entrySet()) { - sb.append(entry.getKey().getName()); - sb.append(" LOG:\n"); - sb.append(StringUtil.join(entry.getValue().log, new Function<GraphCommit<Integer>, String>() { - @Override - public String fun(GraphCommit<Integer> commit) { - return commit.getId() + "<-" + StringUtil.join(commit.getParents(), ","); - } - }, "\n")); - sb.append("\nREFS:\n"); - sb.append(StringUtil.join(entry.getValue().refs, new Function<VcsRef, String>() { - @Override - public String fun(VcsRef ref) { - return ref.getName() + "(" + myHashMap.getCommitIndex(ref.getCommitHash()) + ")"; - } - }, ",")); - } - return sb.toString(); - } - @NotNull - private List<? extends GraphCommit<Integer>> compoundLoadedLogs(@NotNull Collection<LogAndRefs> logsAndRefs) { - return compound(ContainerUtil.map(logsAndRefs, new Function<LogAndRefs, List<? extends GraphCommit<Integer>>>() { - @Override - public List<? extends GraphCommit<Integer>> fun(LogAndRefs refs) { - return refs.log; - } - })); - } - - @NotNull - private Map<VirtualFile, Collection<VcsRef>> getAllNewRefs(@NotNull Map<VirtualFile, LogAndRefs> newInfo, - @NotNull Map<VirtualFile, Collection<VcsRef>> previousRefs) { - Map<VirtualFile, Collection<VcsRef>> result = ContainerUtil.newHashMap(); + private Map<VirtualFile, Set<VcsRef>> getAllNewRefs(@NotNull LogInfo newInfo, + @NotNull Map<VirtualFile, Set<VcsRef>> previousRefs) { + Map<VirtualFile, Set<VcsRef>> result = ContainerUtil.newHashMap(); for (VirtualFile root : previousRefs.keySet()) { - result.put(root, newInfo.containsKey(root) ? newInfo.get(root).refs : previousRefs.get(root)); + Set<VcsRef> newInfoRefs = newInfo.getRefs(root); + result.put(root, newInfoRefs != null ? newInfoRefs : previousRefs.get(root)); } return result; } - private void loadLogAndRefs(@NotNull Collection<VirtualFile> roots, @NotNull Map<VirtualFile, Collection<VcsRef>> prevRefs, + private void loadLogAndRefs(@NotNull Collection<VirtualFile> roots, + @NotNull Map<VirtualFile, Set<VcsRef>> prevRefs, int commitCount) throws VcsException { - Map<VirtualFile, VcsLogProvider> providers = getProviders(roots); - Map<VirtualFile, Collection<VcsRef>> refs = loadRefsFromVcs(providers); - Map<VirtualFile, VcsLogProvider.Requirements> requirements = prepareRequirements(roots, commitCount, prevRefs, refs); - Map<VirtualFile, List<? extends GraphCommit<Integer>>> commits = loadRecentCommitsFromVcs(providers, requirements, - myUserRegistry, myTopCommitsDetailsCache, - myHashMap); + LogInfo logInfo = loadRecentData(prepareRequirements(roots, commitCount, prevRefs)); for (VirtualFile root : roots) { - myLoadedInfos.put(root, new LogAndRefs(refs.get(root), commits.get(root))); + myLoadedInfo.put(root, logInfo.getCommits(root)); + myLoadedInfo.put(root, logInfo.getRefs(root)); } } @NotNull private Map<VirtualFile, VcsLogProvider.Requirements> prepareRequirements(@NotNull Collection<VirtualFile> roots, int commitCount, - @NotNull Map<VirtualFile, Collection<VcsRef>> prevRefs, - @NotNull Map<VirtualFile, Collection<VcsRef>> newRefs) { + @NotNull Map<VirtualFile, Set<VcsRef>> prevRefs) { Map<VirtualFile, VcsLogProvider.Requirements> requirements = ContainerUtil.newHashMap(); for (VirtualFile root : roots) { - requirements.put(root, new RequirementsImpl(commitCount, true, getRefsForRoot(prevRefs, root), getRefsForRoot(newRefs, root))); + requirements.put(root, new RequirementsImpl(commitCount, true, ContainerUtil.notNullize(prevRefs.get(root)))); } return requirements; } - @NotNull - private Set<VcsRef> getRefsForRoot(@NotNull Map<VirtualFile, Collection<VcsRef>> map, @NotNull VirtualFile root) { - Collection<VcsRef> refs = map.get(root); - return refs == null ? Collections.<VcsRef>emptySet() : new HashSet<VcsRef>(refs); - } - - @NotNull - private Map<VirtualFile, VcsLogProvider> getProviders(@NotNull Collection<VirtualFile> roots) { - Map<VirtualFile, VcsLogProvider> providers = ContainerUtil.newHashMap(); - for (VirtualFile root : roots) { - providers.put(root, myProviders.get(root)); - } - return providers; - } - @Nullable - private List<GraphCommit<Integer>> join(@NotNull List<? extends GraphCommit<Integer>> recentCommits, @NotNull List<GraphCommit<Integer>> fullLog, - @NotNull Map<VirtualFile, Collection<VcsRef>> previousRefs, - @NotNull Map<VirtualFile, Collection<VcsRef>> newRefs) { + private List<GraphCommit<Integer>> join(@NotNull List<? extends GraphCommit<Integer>> recentCommits, + @NotNull List<GraphCommit<Integer>> fullLog, + @NotNull Map<VirtualFile, Set<VcsRef>> previousRefs, + @NotNull Map<VirtualFile, Set<VcsRef>> newRefs) { StopWatch sw = StopWatch.start("joining new commits"); Function<VcsRef, Integer> ref2Int = new Function<VcsRef, Integer>() { - @NotNull @Override public Integer fun(@NotNull VcsRef ref) { return myHashMap.getCommitIndex(ref.getCommitHash()); @@ -418,50 +321,44 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { } @NotNull - private Pair<PermanentGraph<Integer>, Map<VirtualFile, Collection<VcsRef>>> loadFullLog() throws VcsException { + private DataPack loadFullLog() throws VcsException { StopWatch sw = StopWatch.start("full log reload"); - Collection<List<? extends GraphCommit<Integer>>> commits = readFullLogFromVcs(); - List<? extends GraphCommit<Integer>> graphCommits = compound(commits); - Map<VirtualFile, Collection<VcsRef>> refMap = loadRefsFromVcs(myProviders); - PermanentGraph<Integer> permanentGraph = DataPack.buildPermanentGraph(graphCommits, new RefsModel(refMap, myHashMap.asIndexGetter()), - myHashMap.asIndexGetter(), - myHashMap.asHashGetter(), myProviders); + LogInfo logInfo = readFullLogFromVcs(); + List<? extends GraphCommit<Integer>> graphCommits = multiRepoJoin(logInfo.getCommits()); + DataPack dataPack = DataPack.build(graphCommits, logInfo.getRefs(), myProviders, myHashMap, true); sw.report(); - return Pair.create(permanentGraph, refMap); + return dataPack; } @NotNull - private Collection<List<? extends GraphCommit<Integer>>> readFullLogFromVcs() throws VcsException { + private LogInfo readFullLogFromVcs() throws VcsException { final StopWatch sw = StopWatch.start("read full log from VCS"); - final Collection<List<? extends GraphCommit<Integer>>> logs = ContainerUtil.newArrayList(); + final LogInfo logInfo = new LogInfo(); new ProviderIterator() { @Override void each(@NotNull VirtualFile root, @NotNull VcsLogProvider provider) throws VcsException { final List<GraphCommit<Integer>> graphCommits = ContainerUtil.newArrayList(); - provider.readAllHashes(root, new Consumer<VcsUser>() { - @Override - public void consume(@NotNull VcsUser user) { - myUserRegistry.addUser(user); - } - }, new Consumer<TimedVcsCommit>() { + VcsLogProvider.LogData data = provider.readAllHashes(root, new Consumer<TimedVcsCommit>() { @Override - public void consume(TimedVcsCommit commit) { - graphCommits.add(compactCommit(commit, myHashMap)); + public void consume(@NotNull TimedVcsCommit commit) { + graphCommits.add(compactCommit(commit)); } }); - logs.add(graphCommits); + logInfo.put(root, graphCommits); + logInfo.put(root, data.getRefs()); + myUserRegistry.addUsers(data.getUsers()); sw.rootCompleted(root); } }.iterate(myProviders); myUserRegistry.flush(); sw.report(); - return logs; + return logInfo; } } private static class RefreshRequest { - private static RefreshRequest RELOAD_ALL = new RefreshRequest(Collections.<VirtualFile>emptyList()); - @NotNull private final Collection<VirtualFile> rootsToRefresh; + private static final RefreshRequest RELOAD_ALL = new RefreshRequest(Collections.<VirtualFile>emptyList()); + private final Collection<VirtualFile> rootsToRefresh; RefreshRequest(@NotNull Collection<VirtualFile> rootsToRefresh) { this.rootsToRefresh = rootsToRefresh; @@ -477,4 +374,85 @@ public class VcsLogRefresherImpl implements VcsLogRefresher { } } } + + private static class CommitCountRequirements implements VcsLogProvider.Requirements { + private final int myCommitCount; + + public CommitCountRequirements(int commitCount) { + myCommitCount = commitCount; + } + + @Override + public int getCommitCount() { + return myCommitCount; + } + + @NotNull + Map<VirtualFile, VcsLogProvider.Requirements> asMap(@NotNull Collection<VirtualFile> roots) { + return ContainerUtil.map2Map(roots, new Function<VirtualFile, Pair<VirtualFile, VcsLogProvider.Requirements>>() { + @Override + public Pair<VirtualFile, VcsLogProvider.Requirements> fun(VirtualFile root) { + return Pair.<VirtualFile, VcsLogProvider.Requirements>create(root, CommitCountRequirements.this); + } + }); + } + } + + private static class LogInfo { + private final Map<VirtualFile, Set<VcsRef>> myRefs = ContainerUtil.newHashMap(); + private final Map<VirtualFile, List<GraphCommit<Integer>>> myCommits = ContainerUtil.newHashMap(); + + void put(@NotNull VirtualFile root, @NotNull List<GraphCommit<Integer>> commits) { + myCommits.put(root, commits); + } + + void put(@NotNull VirtualFile root, @NotNull Set<VcsRef> refs) { + myRefs.put(root, refs); + } + + @NotNull + Collection<List<GraphCommit<Integer>>> getCommits() { + return myCommits.values(); + } + + List<GraphCommit<Integer>> getCommits(@NotNull VirtualFile root) { + return myCommits.get(root); + } + + @NotNull + Map<VirtualFile, Set<VcsRef>> getRefs() { + return myRefs; + } + + public Set<VcsRef> getRefs(@NotNull VirtualFile root) { + return myRefs.get(root); + } + + @SuppressWarnings("StringConcatenationInsideStringBufferAppend") + @NotNull + public String toLogString(@NotNull final NotNullFunction<Hash, Integer> indexGetter) { + StringBuilder sb = new StringBuilder(); + sb.append(" LOG:\n"); + for (Map.Entry<VirtualFile, List<GraphCommit<Integer>>> entry : myCommits.entrySet()) { + sb.append(entry.getKey().getName() + "\n"); + sb.append(StringUtil.join(entry.getValue(), new Function<GraphCommit<Integer>, String>() { + @Override + public String fun(@NotNull GraphCommit<Integer> commit) { + return commit.getId() + "<-" + StringUtil.join(commit.getParents(), ","); + } + }, "\n")); + } + sb.append("\nREFS:\n"); + for (Map.Entry<VirtualFile, Set<VcsRef>> entry : myRefs.entrySet()) { + sb.append(entry.getKey().getName() + "\n"); + sb.append(StringUtil.join(entry.getValue(), new Function<VcsRef, String>() { + @Override + public String fun(@NotNull VcsRef ref) { + return ref.getName() + "(" + indexGetter.fun(ref.getCommitHash()) + ")"; + } + }, ",")); + } + return sb.toString(); + } + } } |