private static <E extends ArrangementEntry> void sortByName(@NotNull List<E> entries) { if (entries.size() < 2) { return; } final TObjectIntHashMap<E> weights = new TObjectIntHashMap<E>(); int i = 0; for (E e : entries) { weights.put(e, ++i); } ContainerUtil.sort( entries, new Comparator<E>() { @Override public int compare(E e1, E e2) { String name1 = e1 instanceof NameAwareArrangementEntry ? ((NameAwareArrangementEntry) e1).getName() : null; String name2 = e2 instanceof NameAwareArrangementEntry ? ((NameAwareArrangementEntry) e2).getName() : null; if (name1 != null && name2 != null) { return name1.compareTo(name2); } else if (name1 == null && name2 == null) { return weights.get(e1) - weights.get(e2); } else if (name2 == null) { return -1; } else { return 1; } } }); }
@NotNull private List<AnnotationData> doCollect( @NotNull PsiModifierListOwner listOwner, boolean onlyWritable) { final List<PsiFile> files = findExternalAnnotationsFiles(listOwner); if (files == null) { return NO_DATA; } SmartList<AnnotationData> result = new SmartList<AnnotationData>(); String externalName = getExternalName(listOwner, false); if (externalName == null) return NO_DATA; for (PsiFile file : files) { if (!file.isValid()) continue; if (onlyWritable && !file.isWritable()) continue; MostlySingularMultiMap<String, AnnotationData> fileData = getDataFromFile(file); ContainerUtil.addAll(result, fileData.get(externalName)); } if (result.isEmpty()) { return NO_DATA; } result.trimToSize(); return result; }
private static boolean matchFramework( ProjectCategory projectCategory, FrameworkSupportInModuleProvider framework) { FrameworkRole[] roles = framework.getRoles(); if (roles.length == 0) return true; List<FrameworkRole> acceptable = Arrays.asList(projectCategory.getAcceptableFrameworkRoles()); return ContainerUtil.intersects(Arrays.asList(roles), acceptable); }
public Collection<ProjectTemplate> getAvailableTemplates() { if (myCurrentCard != FRAMEWORKS_CARD) { return Collections.emptyList(); } else { Collection<ProjectTemplate> templates = myTemplatesMap.get(getSelectedGroup()); List<FrameworkSupportNode> nodes = myFrameworksPanel.getSelectedNodes(); if (nodes.isEmpty()) return templates; final List<String> selectedFrameworks = ContainerUtil.map(nodes, NODE_STRING_FUNCTION); return ContainerUtil.filter( templates, new Condition<ProjectTemplate>() { @Override public boolean value(ProjectTemplate template) { if (!(template instanceof ArchivedProjectTemplate)) return true; List<String> frameworks = ((ArchivedProjectTemplate) template).getFrameworks(); return frameworks.containsAll(selectedFrameworks); } }); } }
/** * Method to request a container resource from yarn * * @param expectedContainerId Identifier of the container that will be run when a container * resource is allocated for this request * @param preferredHost Name of the host that you prefer to run the container on */ public final void requestContainer(int expectedContainerId, String preferredHost) { SamzaContainerRequest request = new SamzaContainerRequest( containerMaxMemoryMb, containerMaxCpuCore, DEFAULT_PRIORITY, expectedContainerId, preferredHost); containerRequestState.updateRequestState(request); containerUtil.incrementContainerRequests(); }
private static AnnotationData findByFQN( @NotNull List<AnnotationData> map, @NotNull final String annotationFQN) { return ContainerUtil.find( map, new Condition<AnnotationData>() { @Override public boolean value(AnnotationData data) { return data.annotationClassFqName.equals(annotationFQN); } }); }
public static void runHighlightingTypeMigration( final Project project, final Editor editor, final TypeMigrationRules rules, final PsiElement[] roots, final Function<PsiElement, PsiType> migrationTypeFunction, final boolean optimizeImports) { final Set<PsiFile> containingFiles = ContainerUtil.map2Set(roots, element -> element.getContainingFile()); final TypeMigrationProcessor processor = new TypeMigrationProcessor(project, roots, migrationTypeFunction, rules) { @Override public void performRefactoring(@NotNull final UsageInfo[] usages) { super.performRefactoring(usages); if (editor != null) { ApplicationManager.getApplication() .invokeLater( () -> { final List<PsiElement> result = new ArrayList<>(); for (UsageInfo usage : usages) { final PsiElement element = usage.getElement(); if (element == null || !containingFiles.contains(element.getContainingFile())) continue; if (element instanceof PsiMethod) { result.add(((PsiMethod) element).getReturnTypeElement()); } else if (element instanceof PsiVariable) { result.add(((PsiVariable) element).getTypeElement()); } else { result.add(element); } } RefactoringUtil.highlightAllOccurrences( project, PsiUtilCore.toPsiElementArray(result), editor); }); } if (optimizeImports) { final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(myProject); final Set<PsiFile> affectedFiles = new THashSet<>(); for (UsageInfo usage : usages) { final PsiFile usageFile = usage.getFile(); if (usageFile != null) { affectedFiles.add(usageFile); } } for (PsiFile file : affectedFiles) { javaCodeStyleManager.optimizeImports(file); javaCodeStyleManager.shortenClassReferences(file); } } } }; processor.run(); }
/** * Updates the request state and runs the container on the specified host. Assumes a container is * available on the preferred host, so the caller must verify that before invoking this method. * * @param request the {@link SamzaContainerRequest} which is being handled. * @param preferredHost the preferred host on which the container should be run or {@link * ContainerRequestState#ANY_HOST} if there is no host preference. */ protected void runContainer(SamzaContainerRequest request, String preferredHost) { // Get the available container Container container = peekAllocatedContainer(preferredHost); if (container == null) throw new SamzaException("Expected container was unavailable on host " + preferredHost); // Update state containerRequestState.updateStateAfterAssignment(request, preferredHost, container); int expectedContainerId = request.expectedContainerId; // Cancel request and run container log.info( "Found available containers on {}. Assigning request for container_id {} with " + "timestamp {} to container {}", new Object[] { preferredHost, String.valueOf(expectedContainerId), request.getRequestTimestamp(), container.getId() }); try { if (preferredHost.equals(ANY_HOST)) { containerUtil.runContainer(expectedContainerId, container); } else { containerUtil.runMatchedContainer(expectedContainerId, container); } } catch (SamzaContainerLaunchException e) { log.warn( String.format( "Got exception while starting container %s. Requesting a new container on any host", container), e); containerRequestState.releaseUnstartableContainer(container); requestContainer(expectedContainerId, ContainerAllocator.ANY_HOST); } }
@Override @Nullable public PsiAnnotation[] findExternalAnnotations(@NotNull final PsiModifierListOwner listOwner) { final List<AnnotationData> result = collectExternalAnnotations(listOwner); return result.isEmpty() ? null : ContainerUtil.map2Array( result, PsiAnnotation.EMPTY_ARRAY, new Function<AnnotationData, PsiAnnotation>() { @Override public PsiAnnotation fun(AnnotationData data) { return data.getAnnotation(BaseExternalAnnotationsManager.this); } }); }
Object interpret() { Object context = containerUtil_.lookupComponent(componentName_); for (String statement : statements_) { String methodName = methodName(statement); String[] parameters = parameters(statement); Method method = findMethod(context.getClass(), methodName, parameters.length); Object[] parsedParameters = parseParameters(method, parameters); context = invokeMethod(method, context, parsedParameters); } return context; }
public boolean offerIfAbsent(@NotNull T thing) { return offerIfAbsent(thing, ContainerUtil.<T>canonicalStrategy()); }
// new TemplatesGroup selected public void projectTypeChanged() { TemplatesGroup group = getSelectedGroup(); if (group == null || group == myLastSelectedGroup) return; myLastSelectedGroup = group; PropertiesComponent.getInstance().setValue(PROJECT_WIZARD_GROUP, group.getId()); ModuleBuilder groupModuleBuilder = group.getModuleBuilder(); mySettingsStep = null; myHeaderPanel.removeAll(); if (groupModuleBuilder != null && groupModuleBuilder.getModuleType() != null) { mySettingsStep = groupModuleBuilder.modifyProjectTypeStep(this); } if (groupModuleBuilder == null || groupModuleBuilder.isTemplateBased()) { showTemplates(group); } else if (!showCustomOptions(groupModuleBuilder)) { List<FrameworkSupportInModuleProvider> providers = FrameworkSupportUtil.getProviders(groupModuleBuilder); final ProjectCategory category = group.getProjectCategory(); if (category != null) { List<FrameworkSupportInModuleProvider> filtered = ContainerUtil.filter( providers, new Condition<FrameworkSupportInModuleProvider>() { @Override public boolean value(FrameworkSupportInModuleProvider provider) { return matchFramework(category, provider); } }); // add associated Map<String, FrameworkSupportInModuleProvider> map = ContainerUtil.newMapFromValues(providers.iterator(), PROVIDER_STRING_CONVERTOR); Set<FrameworkSupportInModuleProvider> set = new HashSet<FrameworkSupportInModuleProvider>(filtered); for (FrameworkSupportInModuleProvider provider : filtered) { for (FrameworkSupportInModuleProvider.FrameworkDependency depId : provider.getDependenciesFrameworkIds()) { FrameworkSupportInModuleProvider dependency = map.get(depId.getFrameworkId()); set.add(dependency); } } myFrameworksPanel.setProviders( new ArrayList<FrameworkSupportInModuleProvider>(set), new HashSet<String>(Arrays.asList(category.getAssociatedFrameworkIds())), new HashSet<String>(Arrays.asList(category.getPreselectedFrameworkIds()))); } else { myFrameworksPanel.setProviders(providers); } getSelectedBuilder().addModuleConfigurationUpdater(myConfigurationUpdater); showCard(FRAMEWORKS_CARD); } myHeaderPanel.setVisible(myHeaderPanel.getComponentCount() > 0); // align header labels List<JLabel> labels = UIUtil.findComponentsOfType(myHeaderPanel, JLabel.class); int width = 0; for (JLabel label : labels) { int width1 = label.getPreferredSize().width; width = Math.max(width, width1); } for (JLabel label : labels) { label.setPreferredSize(new Dimension(width, label.getPreferredSize().height)); } myHeaderPanel.revalidate(); myHeaderPanel.repaint(); updateSelection(); }
private List<TemplatesGroup> fillTemplatesMap(WizardContext context) { List<ModuleBuilder> builders = ModuleBuilder.getAllBuilders(); if (context.isCreatingNewProject()) { builders.add(new EmptyModuleBuilder()); } Map<String, TemplatesGroup> groupMap = new HashMap<String, TemplatesGroup>(); for (ModuleBuilder builder : builders) { BuilderBasedTemplate template = new BuilderBasedTemplate(builder); if (builder.isTemplate()) { TemplatesGroup group = groupMap.get(builder.getGroupName()); if (group == null) { group = new TemplatesGroup(builder); } myTemplatesMap.putValue(group, template); } else { TemplatesGroup group = new TemplatesGroup(builder); groupMap.put(group.getName(), group); myTemplatesMap.put(group, new ArrayList<ProjectTemplate>()); } } MultiMap<TemplatesGroup, ProjectTemplate> map = CreateFromTemplateMode.getTemplatesMap(context); myTemplatesMap.putAllValues(map); for (ProjectCategory category : ProjectCategory.EXTENSION_POINT_NAME.getExtensions()) { TemplatesGroup group = new TemplatesGroup(category); myTemplatesMap.remove(group); myTemplatesMap.put(group, new ArrayList<ProjectTemplate>()); } if (context.isCreatingNewProject()) { MultiMap<String, ProjectTemplate> localTemplates = loadLocalTemplates(); for (TemplatesGroup group : myTemplatesMap.keySet()) { myTemplatesMap.putValues(group, localTemplates.get(group.getId())); } } // remove Static Web group in IDEA Community if no specific templates found (IDEA-120593) if (PlatformUtils.isIdeaCommunity()) { for (TemplatesGroup group : myTemplatesMap.keySet()) { if (WebModuleTypeBase.WEB_MODULE.equals(group.getId()) && myTemplatesMap.get(group).isEmpty()) { myTemplatesMap.remove(group); break; } } } List<TemplatesGroup> groups = new ArrayList<TemplatesGroup>(myTemplatesMap.keySet()); // sorting by module type popularity final MultiMap<ModuleType, TemplatesGroup> moduleTypes = new MultiMap<ModuleType, TemplatesGroup>(); for (TemplatesGroup group : groups) { ModuleType type = getModuleType(group); moduleTypes.putValue(type, group); } Collections.sort( groups, new Comparator<TemplatesGroup>() { @Override public int compare(TemplatesGroup o1, TemplatesGroup o2) { int i = o2.getWeight() - o1.getWeight(); if (i != 0) return i; int i1 = moduleTypes.get(getModuleType(o2)).size() - moduleTypes.get(getModuleType(o1)).size(); if (i1 != 0) return i1; return o1.compareTo(o2); } }); Set<String> groupNames = ContainerUtil.map2Set( groups, new Function<TemplatesGroup, String>() { @Override public String fun(TemplatesGroup group) { return group.getParentGroup(); } }); // move subgroups MultiMap<String, TemplatesGroup> subGroups = new MultiMap<String, TemplatesGroup>(); for (ListIterator<TemplatesGroup> iterator = groups.listIterator(); iterator.hasNext(); ) { TemplatesGroup group = iterator.next(); String parentGroup = group.getParentGroup(); if (parentGroup != null && groupNames.contains(parentGroup) && !group.getName().equals(parentGroup) && groupMap.containsKey(parentGroup)) { subGroups.putValue(parentGroup, group); iterator.remove(); } } for (ListIterator<TemplatesGroup> iterator = groups.listIterator(); iterator.hasNext(); ) { TemplatesGroup group = iterator.next(); for (TemplatesGroup subGroup : subGroups.get(group.getName())) { iterator.add(subGroup); } } return groups; }
public ProjectTypeStep( WizardContext context, NewProjectWizard wizard, ModulesProvider modulesProvider) { myContext = context; myWizard = wizard; myTemplatesMap = new ConcurrentMultiMap<TemplatesGroup, ProjectTemplate>(); final List<TemplatesGroup> groups = fillTemplatesMap(context); myProjectTypeList.setModel(new CollectionListModel<TemplatesGroup>(groups)); myProjectTypeList.setSelectionModel(new SingleSelectionModel()); myProjectTypeList.addListSelectionListener( new ListSelectionListener() { @Override public void valueChanged(ListSelectionEvent e) { updateSelection(); } }); myProjectTypeList.setCellRenderer( new GroupedItemsListRenderer( new ListItemDescriptorAdapter<TemplatesGroup>() { @Nullable @Override public String getTextFor(TemplatesGroup value) { return value.getName(); } @Nullable @Override public String getTooltipFor(TemplatesGroup value) { return value.getDescription(); } @Nullable @Override public Icon getIconFor(TemplatesGroup value) { return value.getIcon(); } @Override public boolean hasSeparatorAboveOf(TemplatesGroup value) { int index = groups.indexOf(value); if (index < 1) return false; TemplatesGroup upper = groups.get(index - 1); if (upper.getParentGroup() == null && value.getParentGroup() == null) return true; return !Comparing.equal(upper.getParentGroup(), value.getParentGroup()) && !Comparing.equal(upper.getName(), value.getParentGroup()); } }) { @Override protected JComponent createItemComponent() { JComponent component = super.createItemComponent(); myTextLabel.setBorder(IdeBorderFactory.createEmptyBorder(3)); return component; } }); new ListSpeedSearch(myProjectTypeList) { @Override protected String getElementText(Object element) { return ((TemplatesGroup) element).getName(); } }; myModulesProvider = modulesProvider; Project project = context.getProject(); final LibrariesContainer container = LibrariesContainerFactory.createContainer(context, modulesProvider); FrameworkSupportModelBase model = new FrameworkSupportModelBase(project, null, container) { @NotNull @Override public String getBaseDirectoryForLibrariesPath() { ModuleBuilder builder = getSelectedBuilder(); return StringUtil.notNullize(builder.getContentEntryPath()); } @Override public ModuleBuilder getModuleBuilder() { return getSelectedBuilder(); } }; myFrameworksPanel = new AddSupportForFrameworksPanel( Collections.<FrameworkSupportInModuleProvider>emptyList(), model, true, myHeaderPanel); Disposer.register(this, myFrameworksPanel); myFrameworksPanelPlaceholder.add(myFrameworksPanel.getMainPanel()); myConfigurationUpdater = new ModuleBuilder.ModuleConfigurationUpdater() { @Override public void update(@NotNull Module module, @NotNull ModifiableRootModel rootModel) { if (isFrameworksMode()) { myFrameworksPanel.addSupport(module, rootModel); } } }; myProjectTypeList .getSelectionModel() .addListSelectionListener( new ListSelectionListener() { @Override public void valueChanged(ListSelectionEvent e) { projectTypeChanged(); } }); myTemplatesList.addListSelectionListener( new ListSelectionListener() { @Override public void valueChanged(ListSelectionEvent e) { updateSelection(); } }); for (TemplatesGroup templatesGroup : myTemplatesMap.keySet()) { ModuleBuilder builder = templatesGroup.getModuleBuilder(); if (builder != null) { myWizard.getSequence().addStepsForBuilder(builder, context, modulesProvider); } for (ProjectTemplate template : myTemplatesMap.get(templatesGroup)) { myWizard .getSequence() .addStepsForBuilder(myBuilders.get(template), context, modulesProvider); } } final String groupId = PropertiesComponent.getInstance().getValue(PROJECT_WIZARD_GROUP); if (groupId != null) { TemplatesGroup group = ContainerUtil.find( groups, new Condition<TemplatesGroup>() { @Override public boolean value(TemplatesGroup group) { return groupId.equals(group.getId()); } }); if (group != null) { myProjectTypeList.setSelectedValue(group, true); } } if (myProjectTypeList.getSelectedValue() == null) { myProjectTypeList.setSelectedIndex(0); } myTemplatesList.restoreSelection(); }
RefHashMap(int initialCapacity, float loadFactor) { this(initialCapacity, loadFactor, ContainerUtil.<K>canonicalStrategy()); }