@Override @NotNull public LogData readAllHashes( @NotNull VirtualFile root, @NotNull final Consumer<TimedVcsCommit> commitConsumer) throws VcsException { if (!isRepositoryReady(root)) { return LogDataImpl.empty(); } List<String> parameters = new ArrayList<String>(GitHistoryUtils.LOG_ALL); parameters.add("--sparse"); final GitBekParentFixer parentFixer = GitBekParentFixer.prepare(root, this); Set<VcsUser> userRegistry = ContainerUtil.newHashSet(); Set<VcsRef> refs = ContainerUtil.newHashSet(); GitHistoryUtils.readCommits( myProject, root, parameters, new CollectConsumer<VcsUser>(userRegistry), new CollectConsumer<VcsRef>(refs), new Consumer<TimedVcsCommit>() { @Override public void consume(TimedVcsCommit commit) { commitConsumer.consume(parentFixer.fixCommit(commit)); } }); return new LogDataImpl(refs, userRegistry); }
public void moveMembersToBase() throws IncorrectOperationException { myMovedMembers = ContainerUtil.newHashSet(); myMembersAfterMove = ContainerUtil.newHashSet(); // build aux sets for (MemberInfo info : myMembersToMove) { myMovedMembers.add(info.getMember()); } final PsiSubstitutor substitutor = upDownSuperClassSubstitutor(); for (MemberInfo info : myMembersToMove) { PullUpHelper<MemberInfo> processor = getProcessor(info); LOG.assertTrue(processor != null, info.getMember()); if (!(info.getMember() instanceof PsiClass) || info.getOverrides() == null) { processor.setCorrectVisibility(info); processor.encodeContextInfo(info); } processor.move(info, substitutor); } for (PsiMember member : myMembersAfterMove) { PullUpHelper<MemberInfo> processor = getProcessor(member); LOG.assertTrue(processor != null, member); processor.postProcessMember(member); final JavaRefactoringListenerManager listenerManager = JavaRefactoringListenerManager.getInstance(myProject); ((JavaRefactoringListenerManagerImpl) listenerManager).fireMemberMoved(mySourceClass, member); } }
public void annotate( @NotNull final VirtualFile contentRoot, @NotNull final CoverageSuitesBundle suite, final @NotNull CoverageDataManager dataManager, @NotNull final ProjectData data, final Project project, final Annotator annotator) { if (!contentRoot.isValid()) { return; } // TODO: check name filter!!!!! final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex(); @SuppressWarnings("unchecked") final Set<String> files = data.getClasses().keySet(); final Map<String, String> normalizedFiles2Files = ContainerUtil.newHashMap(); for (final String file : files) { normalizedFiles2Files.put(normalizeFilePath(file), file); } collectFolderCoverage( contentRoot, dataManager, annotator, data, suite.isTrackTestFolders(), index, suite.getCoverageEngine(), ContainerUtil.newHashSet(), Collections.unmodifiableMap(normalizedFiles2Files)); }
@Nullable Font getFontAbleToDisplay(LookupElementPresentation p) { String sampleString = p.getItemText() + p.getTailText() + p.getTypeText(); // assume a single font can display all lookup item chars Set<Font> fonts = ContainerUtil.newHashSet(); for (int i = 0; i < sampleString.length(); i++) { fonts.add( EditorUtil.fontForChar(sampleString.charAt(i), Font.PLAIN, myLookup.getEditor()) .getFont()); } eachFont: for (Font font : fonts) { if (font.equals(myNormalFont)) continue; for (int i = 0; i < sampleString.length(); i++) { if (!font.canDisplay(sampleString.charAt(i))) { continue eachFont; } } return font; } return null; }
@Nullable private PsiAnnotation findNullabilityAnnotation( @NotNull PsiModifierListOwner owner, boolean checkBases, boolean nullable) { Set<String> qNames = ContainerUtil.newHashSet(nullable ? getNullables() : getNotNulls()); PsiAnnotation annotation = checkBases && (owner instanceof PsiClass || owner instanceof PsiMethod) ? AnnotationUtil.findAnnotationInHierarchy(owner, qNames) : AnnotationUtil.findAnnotation(owner, qNames); if (annotation != null) { return annotation; } if (owner instanceof PsiParameter && !TypeConversionUtil.isPrimitiveAndNotNull(((PsiParameter) owner).getType())) { // even if javax.annotation.Nullable is not configured, it should still take precedence over // ByDefault annotations if (AnnotationUtil.isAnnotated( owner, nullable ? Arrays.asList(DEFAULT_NOT_NULLS) : Arrays.asList(DEFAULT_NULLABLES), checkBases, false)) { return null; } return findContainerAnnotation( owner, nullable ? "javax.annotation.ParametersAreNullableByDefault" : "javax.annotation.ParametersAreNonnullByDefault"); } return null; }
private Set<String> getDuplicateProjectNames(Set<String> openedPaths, Set<String> recentPaths) { Set<String> names = ContainerUtil.newHashSet(); Set<String> duplicates = ContainerUtil.newHashSet(); for (String path : openedPaths) { if (!names.add(getProjectName(path))) { duplicates.add(path); } } for (String path : recentPaths) { if (!names.add(getProjectName(path))) { duplicates.add(path); } } return duplicates; }
@NotNull @Override public GroovyResolveResult[] getCandidates() { if (!hasCandidates()) return GroovyResolveResult.EMPTY_ARRAY; final GroovyResolveResult[] results = ResolveUtil.filterSameSignatureCandidates(getCandidatesInternal()); List<GroovyResolveResult> list = new ArrayList<GroovyResolveResult>(results.length); myPropertyNames.removeAll(myPreferredFieldNames); Set<String> usedFields = ContainerUtil.newHashSet(); for (GroovyResolveResult result : results) { final PsiElement element = result.getElement(); if (element instanceof PsiField) { final String name = ((PsiField) element).getName(); if (myPropertyNames.contains(name) || myLocalVars.contains(name) || usedFields.contains(name)) { continue; } else { usedFields.add(name); } } list.add(result); } return list.toArray(new GroovyResolveResult[list.size()]); }
@NotNull private static Collection<VirtualFile> gatherIncludeRoots( Collection<VirtualFile> goPathSourcesRoots, Set<VirtualFile> excludeRoots) { Collection<VirtualFile> includeRoots = ContainerUtil.newHashSet(); for (VirtualFile goPathSourcesDirectory : goPathSourcesRoots) { ProgressIndicatorProvider.checkCanceled(); boolean excludedRootIsAncestor = false; for (VirtualFile excludeRoot : excludeRoots) { ProgressIndicatorProvider.checkCanceled(); if (VfsUtilCore.isAncestor(excludeRoot, goPathSourcesDirectory, false)) { excludedRootIsAncestor = true; break; } } if (excludedRootIsAncestor) { continue; } for (VirtualFile file : goPathSourcesDirectory.getChildren()) { ProgressIndicatorProvider.checkCanceled(); if (file.isDirectory() && !excludeRoots.contains(file)) { includeRoots.add(file); } } } return includeRoots; }
@NotNull @Override protected Collection<String> getTextValues(@Nullable VcsLogUserFilter filter) { if (filter == null) { return Collections.emptySet(); } return ContainerUtil.newHashSet(((VcsLogUserFilterImpl) filter).getUserNamesForPresentation()); }
private static void hideActionFromMainMenu( @NotNull final DefaultMutableTreeNode root, @NotNull final CustomActionsSchema schema, DefaultMutableTreeNode mainMenu) { final HashSet<String> menuItems = ContainerUtil.newHashSet("Tools", "VCS", "Refactor", "Window", "Run"); hideActions(schema, root, mainMenu, menuItems); }
@NotNull private static <T> Set<T> remove(@NotNull Set<T> original, @NotNull Set<T>... toRemove) { Set<T> result = ContainerUtil.newHashSet(original); for (Set<T> set : toRemove) { result.removeAll(set); } return result; }
public void setDefaultTemplate(String name) { Set<String> fullNames = ContainerUtil.newHashSet(toEqualsName(name), toHashCodeName(name)); for (TemplateResource resource : getAllTemplates()) { if (fullNames.contains(resource.getFileName())) { setDefaultTemplate(resource); break; } } }
@NotNull private Set<VirtualFile> safeGetAndClear(@NotNull Set<VirtualFile> unsafeRefs) { Set<VirtualFile> safeRefs = ContainerUtil.newHashSet(); synchronized (REFRESH_LOCK) { safeRefs.addAll(unsafeRefs); unsafeRefs.clear(); } return safeRefs; }
protected PantsBuildTarget( @NotNull String pantsExecutable, @NotNull Set<String> addresses, @NotNull Set<TargetAddressInfo> targetAddressInfoSet) { super(PantsBuildTargetType.INSTANCE); myPantsExecutable = pantsExecutable; myTargetAddresses = addresses; myTargetAddressInfoSet = targetAddressInfoSet; myAffectedModules = ContainerUtil.newHashSet(); }
private static void suggestGeneratedMethods(CompletionResultSet result, PsiElement position) { PsiClass parent = CompletionUtil.getOriginalElement( ObjectUtils.assertNotNull(PsiTreeUtil.getParentOfType(position, PsiClass.class))); if (parent != null) { Set<MethodSignature> addedSignatures = ContainerUtil.newHashSet(); addGetterSetterElements(result, parent, addedSignatures); addSuperSignatureElements(parent, true, result, addedSignatures); addSuperSignatureElements(parent, false, result, addedSignatures); } }
private static Set<String> collectPathsMetadata(Class<?> testCaseClass) { return ContainerUtil.newHashSet( ContainerUtil.map( collectMethodsMetadata(testCaseClass), new Function<String, String>() { @Override public String fun(String pathData) { return FileUtil.nameToCompare(pathData); } })); }
@NotNull public static Set<VcsRef> readAllRefs( @NotNull VirtualFile root, @NotNull VcsLogObjectsFactory objectsFactory) { String[] refs = StringUtil.splitByLines( git("log --branches --tags --no-walk --format=%H%d --decorate=full")); Set<VcsRef> result = ContainerUtil.newHashSet(); for (String ref : refs) { result.addAll(new RefParser(objectsFactory).parseCommitRefs(ref, root)); } return result; }
public AndroidPostfixTemplateProvider() { templates = ContainerUtil.<PostfixTemplate>newHashSet( new ToastTemplate(), new LogTemplate(), new LogDTemplate()); templates.add(new DynamicTemplate("ll", "Log.d($TAG$, $expr$)$END$ " + "// ll")); templates.add(new DynamicTemplate("l", "Log.d($TAG$, $expr$)$END$ // " + "1")); templates.add(new DynamicTemplate("l2", "Log.d(TAG, expr); // l2")); templates.add(new DynamicTemplate("l3", "Log.d(TAG, expr); // l3")); templates.add(new DynamicTemplate("l4", "Log.d(TAG, expr); // l4")); templates.add(new DynamicTemplate("l5", "Log.d(TAG, expr); // l5")); }
private static boolean varsAreEqual(List<VariableInfo> toAdd, VariableInfo[] outputVars) { if (toAdd.size() != outputVars.length) return false; Set<String> names = ContainerUtil.newHashSet(); for (VariableInfo info : toAdd) { names.add(info.getName()); } for (VariableInfo var : outputVars) { if (!names.contains(var.getName())) return false; } return true; }
public void updateContextHints(@NotNull DiffRequest request, @NotNull DiffContext context) { if (!isEnabled()) return; Set<String> updated = ContainerUtil.newHashSet(); for (BinaryEditorHolder holder : myHolders) { TransferableFileEditorState state = getEditorState(holder.getEditor()); if (state != null) { boolean processed = !updated.add(state.getEditorId()); if (!processed) writeContextData(context, state); } } }
@Override public void run() { Project project = myModule.getProject(); if (GoSdkService.getInstance(project).isGoModule(myModule)) { synchronized (myLastHandledGoPathSourcesRoots) { Collection<VirtualFile> goPathSourcesRoots = GoSdkUtil.getGoPathSources(project, myModule); Set<VirtualFile> excludeRoots = ContainerUtil.newHashSet(ProjectRootManager.getInstance(project).getContentRoots()); ProgressIndicatorProvider.checkCanceled(); if (!myLastHandledGoPathSourcesRoots.equals(goPathSourcesRoots) || !myLastHandledExclusions.equals(excludeRoots)) { Collection<VirtualFile> includeRoots = gatherIncludeRoots(goPathSourcesRoots, excludeRoots); ApplicationManager.getApplication() .invokeLater( () -> { if (!myModule.isDisposed() && GoSdkService.getInstance(project).isGoModule(myModule)) { attachLibraries(includeRoots, excludeRoots); } }); myLastHandledGoPathSourcesRoots.clear(); myLastHandledGoPathSourcesRoots.addAll(goPathSourcesRoots); myLastHandledExclusions.clear(); myLastHandledExclusions.addAll(excludeRoots); List<String> paths = ContainerUtil.map(goPathSourcesRoots, VirtualFile::getPath); myWatchedRequests.clear(); myWatchedRequests.addAll(LocalFileSystem.getInstance().addRootsToWatch(paths, true)); } } } else { synchronized (myLastHandledGoPathSourcesRoots) { LocalFileSystem.getInstance().removeWatchedRoots(myWatchedRequests); myLastHandledGoPathSourcesRoots.clear(); myLastHandledExclusions.clear(); ApplicationManager.getApplication() .invokeLater( () -> { if (!myModule.isDisposed() && GoSdkService.getInstance(project).isGoModule(myModule)) { removeLibraryIfNeeded(); } }); } } }
@NotNull @Override public Condition<CommitId> getContainedInBranchCondition( @NotNull final Collection<CommitId> heads) { List<Integer> headIds = ContainerUtil.map( heads, new Function<CommitId, Integer>() { @Override public Integer fun(CommitId head) { return myPermanentCommitsInfo.getNodeId(head); } }); if (!heads.isEmpty() && ContainerUtil.getFirstItem(heads) instanceof Integer) { final TIntHashSet branchNodes = new TIntHashSet(); myReachableNodes.walk( headIds, new Consumer<Integer>() { @Override public void consume(Integer node) { branchNodes.add((Integer) myPermanentCommitsInfo.getCommitId(node)); } }); return new Condition<CommitId>() { @Override public boolean value(CommitId commitId) { return branchNodes.contains((Integer) commitId); } }; } else { final Set<CommitId> branchNodes = ContainerUtil.newHashSet(); myReachableNodes.walk( headIds, new Consumer<Integer>() { @Override public void consume(Integer node) { branchNodes.add(myPermanentCommitsInfo.getCommitId(node)); } }); return new Condition<CommitId>() { @Override public boolean value(CommitId commitId) { return branchNodes.contains(commitId); } }; } }
private static void registerExtensionPointsAndExtensions( ExtensionsArea area, List<IdeaPluginDescriptorImpl> loadedPlugins) { for (IdeaPluginDescriptorImpl descriptor : loadedPlugins) { descriptor.registerExtensionPoints(area); } Set<String> epNames = ContainerUtil.newHashSet(); for (ExtensionPoint point : area.getExtensionPoints()) { epNames.add(point.getName()); } for (IdeaPluginDescriptorImpl descriptor : loadedPlugins) { for (String epName : epNames) { descriptor.registerExtensions(area, epName); } } }
@Override public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { SelectionModel selectionModel = editor.getSelectionModel(); if (!selectionModel.hasSelection()) { selectionModel.selectLineAtCaret(); } ZenCodingTemplate emmetCustomTemplate = CustomLiveTemplate.EP_NAME.findExtension(ZenCodingTemplate.class); if (emmetCustomTemplate != null) { new WrapWithCustomTemplateAction( emmetCustomTemplate, editor, file, ContainerUtil.newHashSet()) .actionPerformed(null); } else if (!ApplicationManager.getApplication().isUnitTestMode()) { HintManager.getInstance() .showErrorHint(editor, "Cannot invoke Surround with Emmet in the current context"); } }
@NotNull private static GroovyResolveResult[] collapseReflectedMethods(GroovyResolveResult[] candidates) { Set<GrMethod> visited = ContainerUtil.newHashSet(); List<GroovyResolveResult> collapsed = ContainerUtil.newArrayList(); for (GroovyResolveResult result : candidates) { PsiElement element = result.getElement(); if (element instanceof GrReflectedMethod) { GrMethod baseMethod = ((GrReflectedMethod) element).getBaseMethod(); if (visited.add(baseMethod)) { collapsed.add( PsiImplUtil.reflectedToBase(result, baseMethod, (GrReflectedMethod) element)); } } else { collapsed.add(result); } } return collapsed.toArray(new GroovyResolveResult[collapsed.size()]); }
@Nullable private VirtualFile findLibraryRootInfo(@NotNull List<VirtualFile> hierarchy, boolean source) { Set<Library> librariesToIgnore = ContainerUtil.newHashSet(); for (VirtualFile root : hierarchy) { librariesToIgnore.addAll(excludedFromLibraries.get(root)); if (source && libraryOrSdkSources.contains(root) && (!sourceOfLibraries.containsKey(root) || !librariesToIgnore.containsAll(sourceOfLibraries.get(root)))) { return root; } else if (!source && libraryOrSdkClasses.contains(root) && (!classOfLibraries.containsKey(root) || !librariesToIgnore.containsAll(classOfLibraries.get(root)))) { return root; } } return null; }
@NotNull private static Set<String> resolveModuleDeps( @NotNull ModifiableRootModel rootModel, @NotNull ImportedOtpApp importedOtpApp, @Nullable Sdk projectSdk, @NotNull Set<String> allImportedAppNames) { HashSet<String> unresolvedAppNames = ContainerUtil.newHashSet(); for (String depAppName : importedOtpApp.getDeps()) { if (allImportedAppNames.contains(depAppName)) { rootModel.addInvalidModuleEntry(depAppName); } else if (projectSdk != null && isSdkOtpApp(depAppName, projectSdk)) { // SDK is already a dependency } else { rootModel.addInvalidModuleEntry(depAppName); unresolvedAppNames.add(depAppName); } } return unresolvedAppNames; }
@NotNull private static Set<String> sortMatching( @NotNull PrefixMatcher matcher, @NotNull Collection<String> names, @NotNull GoFile file) { ProgressManager.checkCanceled(); String prefix = matcher.getPrefix(); if (prefix.isEmpty()) return ContainerUtil.newLinkedHashSet(names); Set<String> packagesWithAliases = ContainerUtil.newHashSet(); for (Map.Entry<String, Collection<GoImportSpec>> entry : file.getImportMap().entrySet()) { for (GoImportSpec spec : entry.getValue()) { String alias = spec.getAlias(); if (spec.isDot() || alias != null) { packagesWithAliases.add(entry.getKey()); break; } } } List<String> sorted = ContainerUtil.newArrayList(); for (String name : names) { if (matcher.prefixMatches(name) || packagesWithAliases.contains(substringBefore(name, '.'))) { sorted.add(name); } } ProgressManager.checkCanceled(); Collections.sort(sorted, String.CASE_INSENSITIVE_ORDER); ProgressManager.checkCanceled(); LinkedHashSet<String> result = new LinkedHashSet<String>(); for (String name : sorted) { if (matcher.isStartMatch(name)) { result.add(name); } } ProgressManager.checkCanceled(); result.addAll(sorted); return result; }
private static Set<String> calcDevPatternClassNames(@NotNull final Project project) { final List<String> roots = ContainerUtil.createLockFreeCopyOnWriteList(); JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); PsiClass beanClass = psiFacade.findClass(PatternClassBean.class.getName(), GlobalSearchScope.allScope(project)); if (beanClass != null) { GlobalSearchScope scope = GlobalSearchScope.getScopeRestrictedByFileTypes( GlobalSearchScope.allScope(project), StdFileTypes.XML); final TextOccurenceProcessor occurenceProcessor = new TextOccurenceProcessor() { @Override public boolean execute(@NotNull PsiElement element, int offsetInElement) { XmlTag tag = PsiTreeUtil.getParentOfType(element, XmlTag.class); String className = tag == null ? null : tag.getAttributeValue("className"); if (StringUtil.isNotEmpty(className) && tag.getLocalName().endsWith("patternClass")) { roots.add(className); } return true; } }; final StringSearcher searcher = new StringSearcher("patternClass", true, true); CacheManager.SERVICE .getInstance(beanClass.getProject()) .processFilesWithWord( new Processor<PsiFile>() { @Override public boolean process(PsiFile psiFile) { LowLevelSearchUtil.processElementsContainingWordInElement( occurenceProcessor, psiFile, searcher, true, new EmptyProgressIndicator()); return true; } }, searcher.getPattern(), UsageSearchContext.IN_FOREIGN_LANGUAGES, scope, searcher.isCaseSensitive()); } return ContainerUtil.newHashSet(roots); }
@NotNull @Override public Object[] getElementsByName( String name, boolean checkBoxState, String pattern, @NotNull ProgressIndicator canceled) { List<T> classes = myTreeClassChooserDialog.getClassesByName( name, checkBoxState, pattern, 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); }