import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
private <R extends Repository, S extends PushSource, T extends PushTarget> List<PushSupport<R, S, T>> getAffectedSupports() {
  Collection<Repository> repositories = myGlobalRepositoryManager.getRepositories();
  Collection<AbstractVcs> vcss = ContainerUtil.map2Set(repositories, new Function<Repository, AbstractVcs>() {
    @Override
    public AbstractVcs fun(@NotNull Repository repository) {
      return repository.getVcs();
    }
  });
  return ContainerUtil.map(vcss, new Function<AbstractVcs, PushSupport<R, S, T>>() {
    @Override
    public PushSupport<R, S, T> fun(AbstractVcs vcs) {
      //noinspection unchecked
      return DvcsUtil.getPushSupport(vcs);
    }
  });
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
private static void rebaseCurrentBranch(@NotNull final Project project,
                                        @NotNull final GitRepository gitRepository,
                                        @NotNull final ProgressIndicator indicator) {
  final Git git = ServiceManager.getService(project, Git.class);
  final GitPlatformFacade facade = ServiceManager.getService(project, GitPlatformFacade.class);
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    List<VirtualFile> rootsToSave = Collections.singletonList(gitRepository.getRoot());
    GitPreservingProcess process = new GitPreservingProcess(project, facade, git, rootsToSave, "Rebasing", "upstream/master",
                                                            GitVcsSettings.UpdateChangesPolicy.STASH, indicator,
      new Runnable() {
        @Override
        public void run() {
          doRebaseCurrentBranch(project, gitRepository.getRoot(), indicator);
        }
      });
    process.execute();
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@Nullable
public String getDefaultMessageFor(FilePath[] filesToCheckin) {
  LinkedHashSet<String> messages = ContainerUtil.newLinkedHashSet();
  for (VirtualFile root : GitUtil.gitRoots(Arrays.asList(filesToCheckin))) {
    VirtualFile mergeMsg = root.findFileByRelativePath(GitRepositoryFiles.GIT_MERGE_MSG);
    VirtualFile squashMsg = root.findFileByRelativePath(GitRepositoryFiles.GIT_SQUASH_MSG);
    try {
      if (mergeMsg == null && squashMsg == null) {
        continue;
      }
      String encoding = GitConfigUtil.getCommitEncoding(myProject, root);
      if (mergeMsg != null) {
        messages.add(loadMessage(mergeMsg, encoding));
      }
      else {
        messages.add(loadMessage(squashMsg, encoding));
      }
    }
    catch (IOException e) {
      if (log.isDebugEnabled()) {
        log.debug("Unable to load merge message", e);
      }
    }
  }
  return DvcsUtil.joinMessagesOrNull(messages);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
GitRepositoryUpdater(@NotNull GitRepository repository) {
  myRepository = repository;
  VirtualFile gitDir = repository.getGitDir();
  myWatchRequest = LocalFileSystem.getInstance().addRootToWatch(gitDir.getPath(), true);

  myRepositoryFiles = GitRepositoryFiles.getInstance(gitDir);
  DvcsUtil.visitVcsDirVfs(gitDir, GitRepositoryFiles.getSubDirRelativePaths());
  myHeadsDir = VcsUtil.getVirtualFile(myRepositoryFiles.getRefsHeadsPath());
  myRemotesDir = VcsUtil.getVirtualFile(myRepositoryFiles.getRefsRemotesPath());
  myTagsDir = VcsUtil.getVirtualFile(myRepositoryFiles.getRefsTagsPath());

  Project project = repository.getProject();
  myUpdateQueue = new QueueProcessor<Object>(new DvcsUtil.Updater(repository), project.getDisposed());
  if (!project.isDisposed()) {
    myMessageBusConnection = project.getMessageBus().connect();
    myMessageBusConnection.subscribe(VirtualFileManager.VFS_CHANGES, this);
  }
  else {
    myMessageBusConnection = null;
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
private Map<String, String> readPackedBranches() {
  if (!myPackedRefsFile.exists()) {
    return Collections.emptyMap();
  }
  try {
    String content = DvcsUtil.tryLoadFile(myPackedRefsFile);
    return ContainerUtil.map2MapNotNull(LineTokenizer.tokenize(content, false), new Function<String, Pair<String, String>>() {
      @Override
      public Pair<String, String> fun(String line) {
        return parsePackedRefsLine(line);
      }
    });
  }
  catch (RepoStateException e) {
    return Collections.emptyMap();
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
private HeadInfo readHead() {
  String headContent;
  try {
    headContent = DvcsUtil.tryLoadFile(myHeadFile);
  }
  catch (RepoStateException e) {
    LOG.error(e);
    return new HeadInfo(false, null);
  }

  Hash hash = parseHash(headContent);
  if (hash != null) {
    return new HeadInfo(false, headContent);
  }
  String target = getTarget(headContent);
  if (target != null) {
    return new HeadInfo(true, target);
  }
  LOG.error(new RepoStateException("Invalid format of the .git/HEAD file: [" + headContent + "]")); // including "refs/tags/v1"
  return new HeadInfo(false, null);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
private String makeAdditionalInfoByRoot(@NotNull Map<VirtualFile, String> additionalInfo) {
  if (additionalInfo.isEmpty()) {
    return "";
  }
  StringBuilder info = new StringBuilder();
  if (myRepositoryManager.moreThanOneRoot()) {
    for (Map.Entry<VirtualFile, String> entry : additionalInfo.entrySet()) {
      info.append(entry.getValue()).append(" in ").append(DvcsUtil.getShortRepositoryName(myProject, entry.getKey())).append("<br/>");
    }
  }
  else {
    info.append(additionalInfo.values().iterator().next());
  }
  return info.toString();
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected void perform(@NotNull final Project project,
                       @NotNull final List<VirtualFile> gitRoots,
                       @NotNull final VirtualFile defaultRoot,
                       final Set<VirtualFile> affectedRoots,
                       final List<VcsException> exceptions) throws VcsException {
  final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
  if (changeListManager.isFreezedWithNotification("Can not stash changes now")) return;
  GitStashDialog d = new GitStashDialog(project, gitRoots, defaultRoot);
  if (!d.showAndGet()) {
    return;
  }
  VirtualFile root = d.getGitRoot();
  affectedRoots.add(root);
  final GitLineHandler h = d.handler();
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    GitHandlerUtil.doSynchronously(h, GitBundle.getString("stashing.title"), h.printableCommandLine());
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
  ServiceManager.getService(project, GitPlatformFacade.class).hardRefresh(root);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected void perform(@NotNull Project project,
                       @NotNull List<VirtualFile> gitRoots,
                       @NotNull VirtualFile defaultRoot,
                       Set<VirtualFile> affectedRoots,
                       List<VcsException> exceptions) throws VcsException {
  GitResetDialog d = new GitResetDialog(project, gitRoots, defaultRoot);
  if (!d.showAndGet()) {
    return;
  }
  GitLineHandler h = d.handler();
  affectedRoots.add(d.getGitRoot());
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    GitHandlerUtil.doSynchronously(h, GitBundle.getString("resetting.title"), h.printableCommandLine());
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
  GitRepositoryManager manager = GitUtil.getRepositoryManager(project);
  manager.updateRepository(d.getGitRoot());
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
public void cherryPick(@NotNull List<VcsFullCommitDetails> commits) {
  Map<GitRepository, List<VcsFullCommitDetails>> commitsInRoots =
    DvcsUtil.<GitRepository>groupCommitsByRoots(myPlatformFacade.getRepositoryManager(myProject), commits);
  List<GitCommitWrapper> successfulCommits = ContainerUtil.newArrayList();
  List<GitCommitWrapper> alreadyPicked = ContainerUtil.newArrayList();
  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  try {
    for (Map.Entry<GitRepository, List<VcsFullCommitDetails>> entry : commitsInRoots.entrySet()) {
      GitRepository repository = entry.getKey();
      boolean result = cherryPick(repository, entry.getValue(), successfulCommits, alreadyPicked);
      repository.update();
      if (!result) {
        return;
      }
    }
    notifyResult(successfulCommits, alreadyPicked);
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@Override
protected void setCurrentBranchInfo() {
  String currentBranchText = "Current branch";
  if (myRepositoryManager.moreThanOneRoot()) {
    if (myMultiRootBranchConfig.diverged()) {
      currentBranchText += " in " + DvcsUtil.getShortRepositoryName(myCurrentRepository) + ": " +
                           GitBranchUtil.getDisplayableBranchText(myCurrentRepository);
    }
    else {
      currentBranchText += ": " + myMultiRootBranchConfig.getCurrentBranch();
    }
  }
  else {
    currentBranchText += ": " + GitBranchUtil.getDisplayableBranchText(myCurrentRepository);
  }
  myPopup.setAdText(currentBranchText, SwingConstants.CENTER);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
public GitCompareBranchesDialog(@NotNull Project project,
                                @NotNull String branchName,
                                @NotNull String currentBranchName,
                                @NotNull GitCommitCompareInfo compareInfo,
                                @NotNull GitRepository initialRepo,
                                boolean dialog) {
  myProject = project;

  String rootString;
  if (compareInfo.getRepositories().size() == 1 && GitUtil.getRepositoryManager(myProject).moreThanOneRoot()) {
    rootString = " in root " + DvcsUtil.getShortRepositoryName(initialRepo);
  }
  else {
    rootString = "";
  }
  myTitle = String.format("Comparing %s with %s%s", currentBranchName, branchName, rootString);
  myMode = dialog ? Mode.MODAL : Mode.FRAME;

  JPanel diffPanel = new GitCompareBranchesDiffPanel(myProject, branchName, currentBranchName, compareInfo);
  myLogPanel = new GitCompareBranchesLogPanel(myProject, branchName, currentBranchName, compareInfo, initialRepo);

  myTabbedPane = new TabbedPaneImpl(SwingConstants.TOP);
  myTabbedPane.addTab("Log", VcsLogIcons.Branch, myLogPanel);
  myTabbedPane.addTab("Diff", AllIcons.Actions.Diff, diffPanel);
  myTabbedPane.setKeyboardNavigation(TabbedPaneImpl.DEFAULT_PREV_NEXT_SHORTCUTS);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
private String mentionSkippedCommits() {
  if (mySkippedCommits.isEmpty()) return "";
  String message = "<br/>";
  if (mySkippedCommits.values().size() == 1) {
    message += "The following commit was skipped during rebase:<br/>";
  }
  else {
    message += "The following commits were skipped during rebase:<br/>";
  }
  message += StringUtil.join(mySkippedCommits.values(), new Function<GitRebaseUtils.CommitInfo, String>() {
    @Override
    public String fun(@NotNull GitRebaseUtils.CommitInfo commitInfo) {
      String commitMessage = StringUtil.shortenPathWithEllipsis(commitInfo.subject, 72, true);
      String hash = commitInfo.revision.asString();
      String shortHash = DvcsUtil.getShortHash(commitInfo.revision.asString());
      return String.format("<a href='%s'>%s</a> %s", hash, shortHash, commitMessage);
    }
  }, "<br/>");
  return message;
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
public HgRepositoryReader(@NotNull HgVcs vcs, @NotNull File hgDir) {
  myHgDir = hgDir;
  DvcsUtil.assertFileExists(myHgDir, ".hg directory not found in " + myHgDir);
  myVcs = vcs;
  HgVersion version = myVcs.getVersion();
  myStatusInBranchFile = version.hasBranch2();
  myCacheDir = new File(myHgDir, "cache");
  myBranchHeadsFile = identifyBranchHeadFile(version, myCacheDir);
  myCurrentBranch = new File(myHgDir, "branch");
  myBookmarksFile = new File(myHgDir, "bookmarks");
  myCurrentBookmark = new File(myHgDir, "bookmarks.current");
  myLocalTagsFile = new File(myHgDir, "localtags");
  myTagsFile = new File(myHgDir.getParentFile(), ".hgtags");
  mySubrepoFile = new File(myHgDir.getParentFile(), ".hgsubstate");
  myDirStateFile = new File(myHgDir, "dirstate");
  myMqInternalDir = new File(myHgDir, "patches");
  myVcsObjectsFactory = ServiceManager.getService(vcs.getProject(), VcsLogObjectsFactory.class);
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
/**
 * Finds tip revision value.
 *
 * @return The tip revision hash, or <b>{@code null}</b> if tip revision is unknown - it is the initial repository state.
 */
@Nullable
public String readCurrentTipRevision() {
  if (!isBranchInfoAvailable()) return null;
  String[] branchesWithHeads;
  try {
    branchesWithHeads = DvcsUtil.tryLoadFile(myBranchHeadsFile).split("\n");
  }
  catch (RepoStateException e) {
    LOG.error(e);
    return null;
  }
  String head = branchesWithHeads[0];
  Matcher matcher = HASH_NAME.matcher(head);
  if (matcher.matches()) {
    return (matcher.group(1));
  }
  return null;
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@NotNull
public Map<String, Set<Hash>> readBranches() {
  Map<String, Set<Hash>> branchesWithHashes = new HashMap<String, Set<Hash>>();
  // Set<String> branchNames = new HashSet<String>();
  if (isBranchInfoAvailable()) {
    Pattern activeBranchPattern = myStatusInBranchFile ? HASH_STATUS_NAME : HASH_NAME;
    String[] branchesWithHeads = DvcsUtil.tryLoadFileOrReturn(myBranchHeadsFile, "").split("\n");
    // first one - is a head revision: head hash + head number;
    for (int i = 1; i < branchesWithHeads.length; ++i) {
      Matcher matcher = activeBranchPattern.matcher(branchesWithHeads[i]);
      if (matcher.matches()) {
        String name = matcher.group(2);
        if (branchesWithHashes.containsKey(name)) {
          branchesWithHashes.get(name).add(myVcsObjectsFactory.createHash(matcher.group(1)));
        }
        else {
          Set<Hash> hashes = new HashSet<Hash>();
          hashes.add(myVcsObjectsFactory.createHash(matcher.group(1)));
          branchesWithHashes.put(name, hashes);
        }
      }
    }
  }
  return branchesWithHashes;
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
HgRepositoryUpdater(@NotNull final HgRepository repository) {
  VirtualFile hgDir = repository.getHgDir();
  myWatchRequest = LocalFileSystem.getInstance().addRootToWatch(hgDir.getPath(), true);
  myRepositoryFiles = HgRepositoryFiles.getInstance(hgDir);
  DvcsUtil.visitVcsDirVfs(hgDir, HgRepositoryFiles.getSubDirRelativePaths());

  myBranchHeadsDir = VcsUtil.getVirtualFile(myRepositoryFiles.getBranchHeadsDirPath());
  myMqDir = VcsUtil.getVirtualFile(myRepositoryFiles.getMQDirPath());

  Project project = repository.getProject();
  myUpdateQueue = new QueueProcessor<Object>(new DvcsUtil.Updater(repository), project.getDisposed());
  myUpdateConfigQueue = new QueueProcessor<Object>(new Consumer<Object>() {
    @Override
    public void consume(Object dummy) {
      repository.updateConfig();
    }
  }, project.getDisposed());
  if (!project.isDisposed()) {
    myMessageBusConnection = project.getMessageBus().connect();
    myMessageBusConnection.subscribe(VirtualFileManager.VFS_CHANGES, this);
  }
  else {
    myMessageBusConnection = null;
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@Override
public void cherryPick(@NotNull final List<VcsFullCommitDetails> commits) {
  Map<HgRepository, List<VcsFullCommitDetails>> commitsInRoots = DvcsUtil.groupCommitsByRoots(
    HgUtil.getRepositoryManager(myProject), commits);
  for (Map.Entry<HgRepository, List<VcsFullCommitDetails>> entry : commitsInRoots.entrySet()) {
    processGrafting(entry.getKey(), ContainerUtil.map(entry.getValue(),
                                                      new Function<VcsFullCommitDetails, String>() {
                                                        @Override
                                                        public String fun(
                                                          VcsFullCommitDetails commitDetails) {
                                                          return commitDetails.getId()
                                                            .asString();
                                                        }
                                                      }));
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@Nullable
private HgCommandResult execute() {
  HgPromptCommandExecutor commandExecutor = new HgPromptCommandExecutor(project);
  commandExecutor.setShowOutput(true);
  List<String> arguments = new LinkedList<String>();
  if (!StringUtil.isEmptyOrSpaces(revision)) {
    arguments.add("--rev");
    arguments.add(revision);
  }
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    HgCommandResult result = commandExecutor.executeInCurrentThread(repo.getRoot(), "merge", arguments);
    repo.update();
    return result;
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入依赖的package包/类
@Nullable
private HgCommandResult graft(@NotNull List<String> params) {
  List<String> args = new ArrayList<String>();
  args.add("--log");
  args.addAll(params);
  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  try {
    HgCommandResult result =
      new HgCommandExecutor(myProject)
        .executeInCurrentThread(myRepository.getRoot(), "graft", args);
    myRepository.update();
    return result;
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
}