Java Repository类代码示例

import com.intellij.dvcs.repo.Repository; //导入依赖的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.repo.Repository; //导入依赖的package包/类
private void startLoadingCommits() {
  Map<RepositoryNode, MyRepoModel> priorityLoading = ContainerUtil.newLinkedHashMap();
  Map<RepositoryNode, MyRepoModel> others = ContainerUtil.newLinkedHashMap();
  RepositoryNode nodeForCurrentEditor = findNodeByRepo(myCurrentlyOpenedRepository);
  for (Map.Entry<RepositoryNode, MyRepoModel<?, ?, ?>> entry : myView2Model.entrySet()) {
    MyRepoModel model = entry.getValue();
    Repository repository = model.getRepository();
    RepositoryNode repoNode = entry.getKey();
    if (preselectByUser(repository)) {
      priorityLoading.put(repoNode, model);
    }
    else if (model.getSupport().shouldRequestIncomingChangesForNotCheckedRepositories() && !repoNode.equals(nodeForCurrentEditor)) {
      others.put(repoNode, model);
    }
  }
  if (nodeForCurrentEditor != null) {
    //add repo for currently opened editor to the end of priority queue
    priorityLoading.put(nodeForCurrentEditor, myView2Model.get(nodeForCurrentEditor));
  }
  loadCommitsFromMap(priorityLoading);
  loadCommitsFromMap(others);
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@NotNull
public static <R extends Repository> Map<R, List<VcsFullCommitDetails>> groupCommitsByRoots(@NotNull RepositoryManager<R> repoManager,
                                                                                            @NotNull List<? extends VcsFullCommitDetails> commits) {
  Map<R, List<VcsFullCommitDetails>> groupedCommits = ContainerUtil.newHashMap();
  for (VcsFullCommitDetails commit : commits) {
    R repository = repoManager.getRepositoryForRoot(commit.getRoot());
    if (repository == null) {
      LOGGER.info("No repository found for commit " + commit);
      continue;
    }
    List<VcsFullCommitDetails> commitsInRoot = groupedCommits.get(repository);
    if (commitsInRoot == null) {
      commitsInRoot = ContainerUtil.newArrayList();
      groupedCommits.put(repository, commitsInRoot);
    }
    commitsInRoot.add(commit);
  }
  return groupedCommits;
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@NotNull
private VcsRepositoryCreator createMockRepositoryCreator() {
  return new VcsRepositoryCreator() {
    @NotNull
    @Override
    public VcsKey getVcsKey() {
      return myVcs.getKeyInstanceMethod();
    }

    @Nullable
    @Override
    public Repository createRepositoryIfValid(@NotNull VirtualFile root) {
      READY_TO_READ.countDown();
      try {
        //wait until reading thread gets existing info
        if (!CONTINUE_MODIFY.await(1, TimeUnit.SECONDS)) return null;
      }
      catch (InterruptedException e) {
        return null;
      }
      return new MockRepositoryImpl(myProject, root, myProject);
    }
  };
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@NotNull
@Override
protected Repository initRepository(@NotNull String name) {
  String tempDirectory = FileUtil.getTempDirectory();
  String root = tempDirectory + "/" + name;
  assertTrue(new File(root).mkdirs());
  HgPlatformTest.initRepo(root);
  touch("a.txt");
  hg("add a.txt");
  hg("commit -m another");
  hg("up -r 0");
  ProjectLevelVcsManagerImpl vcsManager = (ProjectLevelVcsManagerImpl)ProjectLevelVcsManager.getInstance(myProject);
  vcsManager.setDirectoryMapping(root, HgVcs.VCS_NAME);
  VirtualFile file = LocalFileSystem.getInstance().findFileByIoFile(new File(root));
  HgRepository repository = HgUtil.getRepositoryManager(myProject).getRepositoryForRoot(file);
  assertNotNull("Couldn't find repository for root " + root, repository);
  return repository;
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
public void testCleanupRemovedBranch() throws InterruptedException {
  Repository repository = initRepository("foo");
  LocalTask defaultTask = myTaskManager.getActiveTask();
  assertNotNull(defaultTask);
  assertEquals(0, defaultTask.getBranches().size());
  LocalTaskImpl foo = myTaskManager.createLocalTask("foo");
  LocalTask localTask = myTaskManager.activateTask(foo, false);
  myTaskManager.createBranch(localTask, defaultTask, myTaskManager.suggestBranchName(localTask));
  assertEquals(2, localTask.getBranches().size());
  assertEquals(1, defaultTask.getBranches().size());

  // let's add non-existing branch
  BranchInfo info = new BranchInfo();
  info.name = "non-existing";
  info.repository = defaultTask.getBranches().get(0).repository;
  defaultTask.addBranch(info);
  assertEquals("foo", repository.getCurrentBranchName());
  myTaskManager.activateTask(defaultTask, false);
  assertEquals(getDefaultBranchName(), repository.getCurrentBranchName());
  // do not re-create "non-existing"
  assertEquals(2, getNumberOfBranches(repository));
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
public HgRepoInfo(@NotNull String currentBranch,
                  @Nullable String currentRevision,
                  @Nullable String currentTipRevision,
                  @NotNull Repository.State state,
                  @NotNull Map<String, Set<Hash>> branches,
                  @NotNull Collection<HgNameWithHashInfo> bookmarks,
                  @Nullable String currentBookmark,
                  @NotNull Collection<HgNameWithHashInfo> tags,
                  @NotNull Collection<HgNameWithHashInfo> localTags, @NotNull Collection<HgNameWithHashInfo> subrepos,
                  @NotNull List<HgNameWithHashInfo> mqApplied, @NotNull List<String> mqNames) {
  myCurrentBranch = currentBranch;
  myCurrentRevision = currentRevision;
  myTipRevision = currentTipRevision;
  myState = state;
  myBranches = branches;
  myBookmarks = new LinkedHashSet<HgNameWithHashInfo>(bookmarks);
  myCurrentBookmark = currentBookmark;
  myTags = new LinkedHashSet<HgNameWithHashInfo>(tags);
  myLocalTags = new LinkedHashSet<HgNameWithHashInfo>(localTags);
  mySubrepos = new HashSet<HgNameWithHashInfo>(subrepos);
  myMQApplied = mqApplied;
  myMqNames = mqNames;
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
private void commitChunkFiles(@NotNull List<String> chunk, boolean amendCommit, boolean withSubrepos, boolean closeBranch)
  throws VcsException {
  List<String> parameters = new LinkedList<String>();
  parameters.add("--logfile");
  parameters.add(saveCommitMessage().getAbsolutePath());
  // note: for now mercurial could not perform amend commit with -S option
  if (withSubrepos) {
    parameters.add("-S");
    parameters.addAll(mySubrepos);
  }
  else if (amendCommit) {
    parameters.add("--amend");
  }
  if (closeBranch) {
    if (chunk.isEmpty() && myRepository.getState() != Repository.State.MERGING) {
      //if there are changed files but nothing selected -> need to exclude all; if merge commit then nothing excluded
      parameters.add("-X");
      parameters.add("\"**\"");
    }
    parameters.add("--close-branch");
  }
  parameters.addAll(chunk);
  HgCommandExecutor executor = new HgCommandExecutor(myProject);
  ensureSuccess(executor.executeInCurrentThread(myRepository.getRoot(), "commit", parameters));
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@NotNull
private Collection<Hash> filterUnnamedHeads() {
  Collection<Hash> branchWithHashes = myRepository.getBranches().get(myCurrentBranchName);
  String currentHead = myRepository.getCurrentRevision();
  if (branchWithHashes == null || currentHead == null || myRepository.getState() != Repository.State.NORMAL) {
    // repository is fresh or branch is fresh or complex state
    return Collections.emptySet();
  }
  else {
    Collection<Hash> bookmarkHashes = ContainerUtil.map(myRepository.getBookmarks(), new Function<HgNameWithHashInfo, Hash>() {
      @Override
      public Hash fun(HgNameWithHashInfo info) {
        return info.getHash();
      }
    });
    branchWithHashes.removeAll(bookmarkHashes);
    branchWithHashes.remove(HashImpl.build(currentHead));
  }
  return branchWithHashes;
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@Nonnull
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(@Nonnull 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.repo.Repository; //导入依赖的package包/类
private void startLoadingCommits() {
  Map<RepositoryNode, MyRepoModel> priorityLoading = ContainerUtil.newLinkedHashMap();
  Map<RepositoryNode, MyRepoModel> others = ContainerUtil.newLinkedHashMap();
  RepositoryNode nodeForCurrentEditor = findNodeByRepo(myCurrentlyOpenedRepository);
  for (Map.Entry<RepositoryNode, MyRepoModel<?, ?, ?>> entry : myView2Model.entrySet()) {
    MyRepoModel model = entry.getValue();
    Repository repository = model.getRepository();
    RepositoryNode repoNode = entry.getKey();
    if (preselectByUser(repository)) {
      priorityLoading.put(repoNode, model);
    }
    else if (model.getSupport().shouldRequestIncomingChangesForNotCheckedRepositories() && !repoNode.equals(nodeForCurrentEditor)) {
      others.put(repoNode, model);
    }
    if (shouldPreSelect(model)) {
      model.setChecked(true);
    }
  }
  if (nodeForCurrentEditor != null) {
    //add repo for currently opened editor to the end of priority queue
    priorityLoading.put(nodeForCurrentEditor, myView2Model.get(nodeForCurrentEditor));
  }
  loadCommitsFromMap(priorityLoading);
  loadCommitsFromMap(others);
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@Nonnull
public static <R extends Repository> Map<R, List<VcsFullCommitDetails>> groupCommitsByRoots(@Nonnull RepositoryManager<R> repoManager,
                                                                                            @Nonnull List<? extends VcsFullCommitDetails> commits) {
  Map<R, List<VcsFullCommitDetails>> groupedCommits = ContainerUtil.newHashMap();
  for (VcsFullCommitDetails commit : commits) {
    R repository = repoManager.getRepositoryForRoot(commit.getRoot());
    if (repository == null) {
      LOGGER.info("No repository found for commit " + commit);
      continue;
    }
    List<VcsFullCommitDetails> commitsInRoot = groupedCommits.get(repository);
    if (commitsInRoot == null) {
      commitsInRoot = ContainerUtil.newArrayList();
      groupedCommits.put(repository, commitsInRoot);
    }
    commitsInRoot.add(commit);
  }
  return groupedCommits;
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
public PushController(@NotNull Project project,
                      @NotNull VcsPushDialog dialog,
                      @NotNull List<? extends Repository> preselectedRepositories, @Nullable Repository currentRepo) {
  myProject = project;
  myPushSettings = ServiceManager.getService(project, PushSettings.class);
  myGlobalRepositoryManager = VcsRepositoryManager.getInstance(project);
  myExcludedRepositoryRoots = ContainerUtil.newHashSet(myPushSettings.getExcludedRepoRoots());
  myPreselectedRepositories = preselectedRepositories;
  myCurrentlyOpenedRepository = currentRepo;
  myPushSupports = getAffectedSupports();
  mySingleRepoProject = isSingleRepoProject();
  myDialog = dialog;
  CheckedTreeNode rootNode = new CheckedTreeNode(null);
  createTreeModel(rootNode);
  myPushLog = new PushLog(myProject, rootNode, isSyncStrategiesAllowed());
  myPushLog.getTree().addPropertyChangeListener(PushLogTreeUtil.EDIT_MODE_PROP, new PropertyChangeListener() {
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
      // when user starts edit we need to force disable ok actions, because tree.isEditing() still false;
      // after editing completed okActions will be enabled automatically by dialog validation
      Boolean isEditMode = (Boolean)evt.getNewValue();
      if (isEditMode) {
        myDialog.disableOkActions();
      }
    }
  });
  startLoadingCommits();
  Disposer.register(dialog.getDisposable(), this);
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
private boolean isSyncStrategiesAllowed() {
  return !mySingleRepoProject &&
         ContainerUtil.and(getAffectedSupports(), new Condition<PushSupport<Repository, PushSource, PushTarget>>() {
           @Override
           public boolean value(PushSupport<Repository, PushSource, PushTarget> support) {
             return support.mayChangeTargetsSync();
           }
         });
}
 

import com.intellij.dvcs.repo.Repository; //导入依赖的package包/类
@Nullable
private <R extends Repository, S extends PushSource, T extends PushTarget> PushSupport<R, S, T> getPushSupportByRepository(@NotNull final R repository) {
  //noinspection unchecked
  return (PushSupport<R, S, T>)ContainerUtil.find(
    myPushSupports,
    new Condition<PushSupport<? extends Repository, ? extends PushSource, ? extends PushTarget>>() {
      @Override
      public boolean value(PushSupport<? extends Repository, ? extends PushSource, ? extends PushTarget> support) {
        return support.getVcs().equals(repository.getVcs());
      }
    });
}