Java Code Examples for com.intellij.util.containers.ContainerUtil#newHashSet()

private static EditorTextField createEditorField(final Project project, final int defaultLines) {
  final EditorTextFieldProvider service = ServiceManager.getService(project, EditorTextFieldProvider.class);
  final EditorTextField editorField;

  final Set<EditorCustomization> editorFeatures = ContainerUtil.newHashSet();
  final SpellCheckerCustomization spellChecker = SpellCheckerCustomization.getInstance();
  if(spellChecker.isEnabled())  {
    editorFeatures.add(spellChecker.getCustomization(true));
  }

  if (defaultLines == 1) {
    editorFeatures.add(HorizontalScrollBarEditorCustomization.DISABLED);
    editorFeatures.add(OneLineEditorCustomization.ENABLED);
  } else {
    editorFeatures.add(SoftWrapsEditorCustomization.ENABLED);
  }
  editorField = service.getEditorField(PlainTextLanguage.INSTANCE, project, editorFeatures);
  final int height = editorField.getFontMetrics(editorField.getFont()).getHeight();
  editorField.getComponent().setMinimumSize(new Dimension(100, (int)(height * 1.3)));
  return editorField;
}
 

@Nonnull
private Set<VirtualFile> getUnversionedDescendantsRecursively(@Nonnull List<VirtualFile> items, @Nonnull final Condition<FileStatus> condition) {
  final Set<VirtualFile> result = ContainerUtil.newHashSet();
  Processor<VirtualFile> addToResultProcessor = file -> {
    if (condition.value(getStatus(file))) {
      result.add(file);
    }
    return true;
  };

  for (VirtualFile item : items) {
    VcsRootIterator.iterateVfUnderVcsRoot(myProject, item, addToResultProcessor);
  }

  return result;
}
 

private void checkTurkishAndEnglishLocales(@Nonnull VcsUser user,
                                           @Nonnull Collection<VcsUser> synonymUsers,
                                           @Nonnull MultiMap<VcsUser, String> commits,
                                           @Nonnull List<VcsCommitMetadata> metadata, @Nonnull StringBuilder builder)
        throws VcsException {
  Set<String> expectedCommits = ContainerUtil.newHashSet(commits.get(user));
  for (VcsUser synonym : synonymUsers) {
    expectedCommits.addAll(commits.get(synonym));
  }

  Locale oldLocale = Locale.getDefault();
  Locale.setDefault(new Locale("tr"));
  StringBuilder turkishBuilder = new StringBuilder();
  checkFilterForUser(user, commits.keySet(), expectedCommits, metadata, turkishBuilder);

  Locale.setDefault(Locale.ENGLISH);
  StringBuilder defaultBuilder = new StringBuilder();
  checkFilterForUser(user, commits.keySet(), expectedCommits, metadata, defaultBuilder);
  Locale.setDefault(oldLocale);

  if (!turkishBuilder.toString().isEmpty()) builder.append("Turkish Locale:\n").append(turkishBuilder);
  if (!defaultBuilder.toString().isEmpty()) builder.append("English Locale:\n").append(defaultBuilder);
}
 

@Nonnull
public static Set<Integer> intersect(@Nonnull TIntHashSet... sets) {
  TIntHashSet result = null;

  Arrays.sort(sets, (set1, set2) -> {
    if (set1 == null) return -1;
    if (set2 == null) return 1;
    return set1.size() - set2.size();
  });
  for (TIntHashSet set : sets) {
    result = intersect(result, set);
  }

  if (result == null) return ContainerUtil.newHashSet();
  return createJavaSet(result);
}
 

@Nonnull
@Override
public Object[] getElementsByName(String name, FindSymbolParameters parameters, @Nonnull ProgressIndicator canceled) {
  String patternName = parameters.getLocalPatternName();
  List<T> classes = myTreeClassChooserDialog.getClassesByName(name, parameters.isSearchInLibraries(), patternName, myTreeClassChooserDialog.getScope());
  if (classes.size() == 0) return ArrayUtil.EMPTY_OBJECT_ARRAY;
  if (classes.size() == 1) {
    return isAccepted(classes.get(0)) ? ArrayUtil.toObjectArray(classes) : ArrayUtil.EMPTY_OBJECT_ARRAY;
  }
  Set<String> qNames = ContainerUtil.newHashSet();
  List<T> list = new ArrayList<T>(classes.size());
  for (T aClass : classes) {
    if (qNames.add(getFullName(aClass)) && isAccepted(aClass)) {
      list.add(aClass);
    }
  }
  return ArrayUtil.toObjectArray(list);
}
 

@Nonnull
static DataPack build(@Nonnull List<? extends GraphCommit<Integer>> commits,
                      @Nonnull Map<VirtualFile, CompressedRefs> refs,
                      @Nonnull Map<VirtualFile, VcsLogProvider> providers,
                      @Nonnull final VcsLogStorage hashMap,
                      boolean full) {
  RefsModel refsModel;
  PermanentGraph<Integer> permanentGraph;
  if (commits.isEmpty()) {
    refsModel = new RefsModel(refs, ContainerUtil.<Integer>newHashSet(), hashMap, providers);
    permanentGraph = EmptyPermanentGraph.getInstance();
  }
  else {
    refsModel = new RefsModel(refs, getHeads(commits), hashMap, providers);
    Function<Integer, Hash> hashGetter = createHashGetter(hashMap);
    GraphColorManagerImpl colorManager = new GraphColorManagerImpl(refsModel, hashGetter, getRefManagerMap(providers));
    Set<Integer> branches = getBranchCommitHashIndexes(refsModel.getBranches(), hashMap);

    StopWatch sw = StopWatch.start("building graph");
    permanentGraph = PermanentGraphImpl.newInstance(commits, colorManager, branches);
    sw.report();
  }

  return new DataPack(refsModel, permanentGraph, providers, full);
}
 

@Nullable
public static String getSingleFilteredBranch(@Nonnull VcsLogBranchFilter filter, @Nonnull VcsLogRefs refs) {
  String branchName = null;
  Set<VirtualFile> checkedRoots = ContainerUtil.newHashSet();
  for (VcsRef branch : refs.getBranches()) {
    if (!filter.matches(branch.getName())) continue;

    if (branchName == null) {
      branchName = branch.getName();
    }
    else if (!branch.getName().equals(branchName)) {
      return null;
    }

    if (checkedRoots.contains(branch.getRoot())) return null;
    checkedRoots.add(branch.getRoot());
  }

  return branchName;
}
 

@Nonnull
public Collection<VcsUser> getUsers(@Nonnull VirtualFile root) {
  Set<VcsUser> result = ContainerUtil.newHashSet();
  for (String user : myUsers) {
    result.addAll(getUsers(root, user));
  }
  return result;
}
 

public Set<Integer> getAllNodes() {
  Set<Integer> nodes = ContainerUtil.newHashSet();
  nodes.add(myParent);
  nodes.add(myLeftChild);
  nodes.add(myRightChild);
  nodes.addAll(getTailsAndBody());
  return nodes;
}
 

private static void check(@Nonnull TokenSet set, @Nonnull IElementType... elements) {
  final Set<IElementType> expected = ContainerUtil.newHashSet(elements);
  for (IElementType t : Arrays.asList(T1, T2, T3, T4, T5, T6)) {
    if (expected.contains(t)) {
      assertTrue("missed: " + t, set.contains(t));
    }
    else {
      assertFalse("unexpected: " + t, set.contains(t));
    }
  }
}
 

public PushController(@Nonnull Project project,
                      @Nonnull VcsPushDialog dialog,
                      @Nonnull List<? extends Repository> preselectedRepositories, @javax.annotation.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);
}
 

@Nonnull
private Set<VirtualFile> getUnversionedParents(@Nonnull Collection<VirtualFile> items, @Nonnull Condition<FileStatus> condition) {
  HashSet<VirtualFile> result = ContainerUtil.newHashSet();

  for (VirtualFile item : items) {
    VirtualFile parent = item.getParent();

    while (parent != null && condition.value(getStatus(parent))) {
      result.add(parent);
      parent = parent.getParent();
    }
  }

  return result;
}
 

public TIntHashSet getCommitsForPaths(@Nonnull Collection<FilePath> paths) throws IOException, StorageException {
  Set<Integer> allPathIds = ContainerUtil.newHashSet();
  for (FilePath path : paths) {
    allPathIds.add(myPathsIndexer.myPathsEnumerator.enumerate(path.getPath()));
  }

  TIntHashSet result = new TIntHashSet();
  Set<Integer> renames = allPathIds;
  while (!renames.isEmpty()) {
    renames = addCommitsAndGetRenames(renames, allPathIds, result);
    allPathIds.addAll(renames);
  }

  return result;
}
 

/**
 * Stores information about dismissed notification about editing ignored file.
 *
 * @param project current project
 * @param file    current file
 */
public static void setDismissedIgnoredEditingNotification(@NotNull Project project, @NotNull VirtualFile file) {
    final PropertiesComponent props = properties(project);
    String[] values = props.getValues(DISMISSED_IGNORED_EDITING_NOTIFICATION);

    final HashSet<String> set = ContainerUtil.newHashSet(values != null ? values : new String[0]);
    set.add(file.getCanonicalPath());

    props.setValues(DISMISSED_IGNORED_EDITING_NOTIFICATION, set.toArray(new String[0]));
}
 

public Collection<GraphEdge> getRemovedEdges() {
  Set<GraphEdge> result = ContainerUtil.newHashSet();
  Set<GraphEdge> hidden = myHiddenEdges.getEdges();
  result.addAll(ContainerUtil.filter(hidden, new Condition<GraphEdge>() {
    @Override
    public boolean value(GraphEdge graphEdge) {
      return graphEdge.getType() != GraphEdgeType.DOTTED;
    }
  }));
  result.addAll(ContainerUtil.intersection(hidden, myLinearGraph.myDottedEdges.getEdges()));
  result.removeAll(myLinearGraph.myHiddenEdges.getEdges());
  return result;
}
 

private static boolean hasReversibleFiles(@Nonnull AnActionEvent e) {
  ChangeListManager manager = ChangeListManager.getInstance(e.getRequiredData(CommonDataKeys.PROJECT));
  Set<VirtualFile> modifiedWithoutEditing = ContainerUtil.newHashSet(manager.getModifiedWithoutEditing());

  return notNullize(e.getData(VcsDataKeys.VIRTUAL_FILE_STREAM)).anyMatch(
          file -> manager.haveChangesUnder(file) != ThreeState.NO || manager.isFileAffected(file) || modifiedWithoutEditing.contains(file));
}
 

public ScopesChooser(final List<Descriptor> defaultDescriptors,
                     final InspectionProfileImpl inspectionProfile,
                     final Project project,
                     final String[] excludedScopeNames) {
  myDefaultDescriptors = defaultDescriptors;
  myInspectionProfile = inspectionProfile;
  myProject = project;
  myExcludedScopeNames = excludedScopeNames == null ? Collections.<String>emptySet() : ContainerUtil.newHashSet(excludedScopeNames);
  setPopupTitle(TITLE);
  getTemplatePresentation().setText("In All Scopes");
}
 

private static LiveTemplateLookupElement createTemplateElement(final TemplateImpl template) {
  return new LiveTemplateLookupElementImpl(template, false) {
    @Override
    public Set<String> getAllLookupStrings() {
      String description = template.getDescription();
      if (description == null) {
        return super.getAllLookupStrings();
      }
      return ContainerUtil.newHashSet(getLookupString(), description);
    }
  };
}
 

@Nonnull
public static Collection<VirtualFile> refreshFiles(@Nonnull Collection<File> files) {
  Collection<VirtualFile> filesToRefresh = ContainerUtil.newHashSet();
  for (File file : files) {
    VirtualFile vf = findFirstValidVirtualParent(file);
    if (vf != null) {
      filesToRefresh.add(vf);
    }
  }
  VfsUtil.markDirtyAndRefresh(false, false, false, ArrayUtil.toObjectArray(filesToRefresh, VirtualFile.class));
  return filesToRefresh;
}
 

public NonClasspathDirectoriesScope(@Nonnull Collection<VirtualFile> roots) {
  myRoots = ContainerUtil.newHashSet(roots);
}