Java DvcsUtil.workingTreeChangeStarted方法代码示例

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包/类
/**
 * {@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包/类
@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);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
public void execute() {
  saveAllDocuments();
  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  Map<GitRepository, GitCommandResult> results = ContainerUtil.newHashMap();
  try {
    for (Map.Entry<GitRepository, VcsFullCommitDetails> entry : myCommits.entrySet()) {
      GitRepository repository = entry.getKey();
      VirtualFile root = repository.getRoot();
      String target = entry.getValue().getId().asString();
      GitLocalChangesWouldBeOverwrittenDetector detector = new GitLocalChangesWouldBeOverwrittenDetector(root, RESET);

      GitCommandResult result = myGit.reset(repository, myMode, target, detector);
      if (!result.success() && detector.wasMessageDetected()) {
        GitCommandResult smartResult = proposeSmartReset(detector, repository, target);
        if (smartResult != null) {
          result = smartResult;
        }
      }
      results.put(repository, result);
      repository.update();
      VfsUtil.markDirtyAndRefresh(true, true, false, root);
      VcsDirtyScopeManager.getInstance(myProject).dirDirtyRecursively(root);
    }
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
  notifyResult(results);
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
/**
 * Checks if update is possible, saves local changes and updates all roots.
 * In case of error shows notification and returns false. If update completes without errors, returns true.
 *
 * Perform update on all roots.
 * 0. Blocks reloading project on external change, saving/syncing on frame deactivation.
 * 1. Checks if update is possible (rebase/merge in progress, no tracked branches...) and provides merge dialog to solve problems.
 * 2. Finds updaters to use (merge or rebase).
 * 3. Preserves local changes if needed (not needed for merge sometimes).
 * 4. Updates via 'git pull' or equivalent.
 * 5. Restores local changes if update completed or failed with error. If update is incomplete, i.e. some unmerged files remain,
 * local changes are not restored.
 *
 */
@NotNull
public GitUpdateResult update(final UpdateMethod updateMethod) {
  LOG.info("update started|" + updateMethod);
  String oldText = myProgressIndicator.getText();
  myProgressIndicator.setText("Updating...");

  for (GitRepository repository : myRepositories) {
    repository.update();
  }

  // check if update is possible
  if (checkRebaseInProgress() || isMergeInProgress() || areUnmergedFiles() || !checkTrackedBranchesConfigured()) {
    return GitUpdateResult.NOT_READY;
  }

  if (!fetchAndNotify()) {
    return GitUpdateResult.NOT_READY;
  }

  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  GitUpdateResult result;
  try {
    result = updateImpl(updateMethod);
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
  myProgressIndicator.setText(oldText);
  return result;
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
public GitUpdateResult rebase(@NotNull VirtualFile root,
                              @NotNull List<String> parameters,
                              @Nullable final Runnable onCancel,
                              @Nullable GitLineHandlerListener lineListener) {
  final GitLineHandler rebaseHandler = createHandler(root);
  rebaseHandler.setStdoutSuppressed(false);
  rebaseHandler.addParameters(parameters);
  if (lineListener != null) {
    rebaseHandler.addLineListener(lineListener);
  }

  final GitRebaseProblemDetector rebaseConflictDetector = new GitRebaseProblemDetector();
  rebaseHandler.addLineListener(rebaseConflictDetector);
  GitUntrackedFilesOverwrittenByOperationDetector untrackedFilesDetector = new GitUntrackedFilesOverwrittenByOperationDetector(root);
  GitLocalChangesWouldBeOverwrittenDetector localChangesDetector = new GitLocalChangesWouldBeOverwrittenDetector(root, CHECKOUT);
  rebaseHandler.addLineListener(untrackedFilesDetector);
  rebaseHandler.addLineListener(localChangesDetector);
  rebaseHandler.addLineListener(GitStandardProgressAnalyzer.createListener(myProgressIndicator));

  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  try {
    String oldText = myProgressIndicator.getText();
    myProgressIndicator.setText("Rebasing...");
    GitCommandResult result = myGit.runCommand(rebaseHandler);
    myProgressIndicator.setText(oldText);
    return result.success() ?
           GitUpdateResult.SUCCESS :
           handleRebaseFailure(rebaseHandler, root, rebaseConflictDetector, untrackedFilesDetector, localChangesDetector);
  }
  catch (ProcessCanceledException pce) {
    if (onCancel != null) {
      onCancel.run();
    }
    return GitUpdateResult.CANCEL;
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
/**
 * Runs 'git rebase --continue' on several roots consequently.
 * @return true if rebase successfully finished.
 */
public boolean continueRebase(@NotNull Collection<VirtualFile> rebasingRoots) {
  AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
  try {
    boolean success = true;
    for (VirtualFile root : rebasingRoots) {
      success &= continueRebase(root);
    }
    return success;
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(myProject, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
public void rollbackMissingFileDeletion(List<FilePath> files,
                                        List<VcsException> exceptions, RollbackProgressListener listener) {
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    revert(files);
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
@Nullable
public HgCommandResult execute() {
  List<String> arguments = new LinkedList<String>();
  if (clean) {
    arguments.add("--clean");
  }

  if (!StringUtil.isEmptyOrSpaces(revision)) {
    arguments.add("--rev");
    arguments.add(revision);
  }

  final HgPromptCommandExecutor executor = new HgPromptCommandExecutor(project);
  executor.setShowOutput(true);
  HgCommandResult result;
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    result =
      executor.executeInCurrentThread(repo, "update", arguments);
    if (!clean && hasUncommittedChangesConflict(result)) {
      final String message = "<html>Your uncommitted changes couldn't be merged into the requested changeset.<br>" +
                             "Would you like to perform force update and discard them?";
      if (showDiscardChangesConfirmation(project, message) == Messages.OK) {
        arguments.add("-C");
        result = executor.executeInCurrentThread(repo, "update", arguments);
      }
    }
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }

  VfsUtil.markDirtyAndRefresh(true, true, false, repo);
  return result;
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
@Nullable
private HgCommandResult performRebase(@NotNull String... args) {
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    HgCommandResult result =
      new HgCommandExecutor(project)
        .executeInCurrentThread(repo.getRoot(), "rebase", ContainerUtil.list(args));
    repo.update();
    return result;
  }
  finally {
    DvcsUtil.workingTreeChangeFinished(project, token);
  }
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
private void updateRepositories(@NotNull Project project, @NotNull List<GitRepository> repositories) {
    //get an access token for changing the repositories
    final AccessToken accessToken = DvcsUtil.workingTreeChangeStarted(project);

    final AtomicInteger countDown = new AtomicInteger(repositories.size());

    //get the settings to find out the selected options
    GitExtenderSettingsHandler settingsHandler = new GitExtenderSettingsHandler();
    final GitExtenderSettings settings = settingsHandler.loadSettings();
    repositories.forEach(repo ->
            new BackgroundableRepoUpdateTask(repo,
                    VcsImplUtil.getShortVcsRootName(repo.getProject(), repo.getRoot()),
                    settings, countDown, accessToken)
                    .queue());
}
 

import com.intellij.dvcs.DvcsUtil; //导入方法依赖的package包/类
private boolean stash() {
  if (!syncResult.hasLocalRepository()) {
    LOG.error("unexpected null local repro in call to stash");
    return false;
  }

  final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
  if (changeListManager.isFreezedWithNotification("Can not stash changes now")) {
    return false;
  }

  final GitLineHandler handler =
      new GitLineHandler(project, sourceRepository.getRoot(), GitCommand.STASH);
  handler.addParameters("save");
  handler.addParameters("--keep-index");
  String date =
      DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(new Date());
  stashMessage = "Cloud Debugger saved changes from branch " + originalBranchName + " at " + date;
  handler.addParameters(stashMessage);
  AccessToken token = DvcsUtil.workingTreeChangeStarted(project);
  try {
    GitHandlerUtil.doSynchronously(
        handler, GitBundle.getString("stashing.title"), handler.printableCommandLine());
  } finally {
    token.finish();
  }
  return true;
}