Java ContainerUtil.intersection方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
private Set<Integer> getMatchingHeads(@NotNull VcsLogRefs refs, @NotNull Set<VirtualFile> roots, @NotNull VcsLogFilterCollection filters) {
  VcsLogBranchFilter branchFilter = filters.getBranchFilter();
  VcsLogRootFilter rootFilter = filters.getRootFilter();
  VcsLogStructureFilter structureFilter = filters.getStructureFilter();

  if (branchFilter == null && rootFilter == null && structureFilter == null) return null;

  Set<Integer> filteredByBranch = null;

  if (branchFilter != null) {
    filteredByBranch = getMatchingHeads(refs, branchFilter);
  }

  Set<Integer> filteredByFile = getMatchingHeads(refs, VcsLogUtil
    .getAllVisibleRoots(roots, rootFilter, structureFilter));

  if (filteredByBranch == null) return filteredByFile;
  if (filteredByFile == null) return filteredByBranch;

  return new HashSet<Integer>(ContainerUtil.intersection(filteredByBranch, filteredByFile));
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static Set<VirtualFile> getAllVisibleRoots(@NotNull Collection<VirtualFile> roots,
                                                  @Nullable VcsLogRootFilter rootFilter,
                                                  @Nullable VcsLogStructureFilter structureFilter) {
  if (rootFilter == null && structureFilter == null) return new HashSet<VirtualFile>(roots);

  Collection<VirtualFile> fromRootFilter;
  if (rootFilter != null) {
    fromRootFilter = rootFilter.getRoots();
  }
  else {
    fromRootFilter = roots;
  }

  Collection<VirtualFile> fromStructureFilter;
  if (structureFilter != null) {
    Pair<Set<VirtualFile>, MultiMap<VirtualFile, VirtualFile>> rootsAndFiles =
      collectRoots(structureFilter.getFiles(), new HashSet<VirtualFile>(roots));
    fromStructureFilter = ContainerUtil.union(rootsAndFiles.first, rootsAndFiles.second.keySet());
  }
  else {
    fromStructureFilter = roots;
  }

  return new HashSet<VirtualFile>(ContainerUtil.intersection(fromRootFilter, fromStructureFilter));
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
/**
 * Only common hg heavy branches
 */
@NotNull
public static List<String> getCommonBranches(@NotNull Collection<HgRepository> repositories) {
  Collection<String> commonBranches = null;
  for (HgRepository repository : repositories) {
    Collection<String> names = repository.getOpenedBranches();
    if (commonBranches == null) {
      commonBranches = names;
    }
    else {
      commonBranches = ContainerUtil.intersection(commonBranches, names);
    }
  }
  if (commonBranches != null) {
    ArrayList<String> common = new ArrayList<String>(commonBranches);
    Collections.sort(common);
    return common;
  }
  else {
    return Collections.emptyList();
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static List<String> getCommonBookmarks(@NotNull Collection<HgRepository> repositories) {
  Collection<String> commonBookmarkNames = null;
  for (HgRepository repository : repositories) {
    Collection<HgNameWithHashInfo> bookmarksInfo = repository.getBookmarks();
    Collection<String> names = HgUtil.getSortedNamesWithoutHashes(bookmarksInfo);
    if (commonBookmarkNames == null) {
      commonBookmarkNames = names;
    }
    else {
      commonBookmarkNames = ContainerUtil.intersection(commonBookmarkNames, names);
    }
  }
  if (commonBookmarkNames != null) {
    ArrayList<String> common = new ArrayList<String>(commonBookmarkNames);
    Collections.sort(common);
    return common;
  }
  else {
    return Collections.emptyList();
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
/**
 * Returns local branches which track the given remote branch. Usually there is 0 or 1 such branches.
 */
@NotNull
public Collection<String> getTrackingBranches(@NotNull String remoteBranch) {
  Collection<String> trackingBranches = null;
  for (GitRepository repository : myRepositories) {
    Collection<String> tb = getTrackingBranches(repository, remoteBranch);
    if (trackingBranches == null) {
      trackingBranches = tb;
    }
    else {
      trackingBranches = ContainerUtil.intersection(trackingBranches, tb);
    }
  }
  return trackingBranches == null ? Collections.<String>emptyList() : trackingBranches;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private List<String> getMergedToBranches(String branchName) {
  List<String> mergedToBranches = null;
  for (GitRepository repository : getRemainingRepositories()) {
    List<String> branches = getMergedToBranches(repository, branchName);
    if (mergedToBranches == null) {
      mergedToBranches = branches;
    } 
    else {
      mergedToBranches = new ArrayList<String>(ContainerUtil.intersection(mergedToBranches, branches));
    }
  }
  return mergedToBranches != null ? mergedToBranches : new ArrayList<String>();
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static Collection<String> getCommonBranches(Collection<GitRepository> repositories,
                                                   boolean local) {
  Collection<String> commonBranches = null;
  for (GitRepository repository : repositories) {
    GitBranchesCollection branchesCollection = repository.getBranches();

    Collection<String> names = local
                               ? convertBranchesToNames(branchesCollection.getLocalBranches())
                               : getBranchNamesWithoutRemoteHead(branchesCollection.getRemoteBranches());
    if (commonBranches == null) {
      commonBranches = names;
    }
    else {
      commonBranches = ContainerUtil.intersection(commonBranches, names);
    }
  }

  if (commonBranches != null) {
    ArrayList<String> common = new ArrayList<String>(commonBranches);
    Collections.sort(common);
    return common;
  }
  else {
    return Collections.emptyList();
  }
}