Java ContainerUtil.addIfNotNull方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
boolean addCustomRootsForModule(OrderRootType type,
                                ModuleRootModel rootModel,
                                Collection<VirtualFile> result,
                                boolean includeProduction,
                                boolean includeTests) {
  for (OrderEnumerationHandler handler : myCustomHandlers) {
    final List<String> urls = new ArrayList<String>();
    final boolean added = handler.addCustomModuleRoots(type, rootModel, urls, includeProduction, includeTests);
    for (String url : urls) {
      ContainerUtil.addIfNotNull(VirtualFileManager.getInstance().findFileByUrl(url), result);
    }

    if (added) return true;
  }
  return false;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public Result<PsiModifierList> compute() {
  List<PsiModifierList> modifiers = ContainerUtil.newArrayList();
  for(PsiDirectory directory: getDirectories()) {
    PsiFile file = directory.findFile(PACKAGE_INFO_FILE);
    PsiPackageStatement stmt = file == null ? null : PsiTreeUtil.getChildOfType(file, PsiPackageStatement.class);
    PsiModifierList modifierList = stmt == null ? null : stmt.getAnnotationList();
    ContainerUtil.addIfNotNull(modifiers, modifierList);
  }

  for (PsiClass aClass : getFacade().findClasses(getQualifiedName() + ".package-info", allScope())) {
    ContainerUtil.addIfNotNull(modifiers, aClass.getModifierList());
  }

  PsiCompositeModifierList result = modifiers.isEmpty() ? null : new PsiCompositeModifierList(getManager(), modifiers);
  return new Result<PsiModifierList>(result, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
protected M computeCombinedModel(@NotNull Scope scope) {
  final List<M> models = getAllModels(scope);
  switch (models.size()) {
    case 0:
      return null;
    case 1:
      return models.get(0);
  }
  final Set<XmlFile> configFiles = new LinkedHashSet<XmlFile>();
  final LinkedHashSet<DomFileElement<T>> list = new LinkedHashSet<DomFileElement<T>>(models.size());
  for (M model: models) {
    final Set<XmlFile> files = model.getConfigFiles();
    for (XmlFile file: files) {
      ContainerUtil.addIfNotNull(getDomRoot(file), list);
    }
    configFiles.addAll(files);
  }
  final DomFileElement<T> mergedModel = getModelMerger().mergeModels(DomFileElement.class, list);
  final M firstModel = models.get(0);
  return createCombinedModel(configFiles, mergedModel, firstModel, scope);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
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();
  ContainerUtil.addIfNotNull(editorFeatures, SpellCheckingEditorCustomizationProvider.getInstance().getEnabledCustomization());

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

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
@Override
public Set<VirtualFile> getAdditionalRootsToIndex() {
  Set<VirtualFile> roots = new THashSet<VirtualFile>();
  for (String url : myStandardResources.getValue()) {
    VirtualFile file = VfsUtilCore.findRelativeFile(url, null);
    if (file != null) {
      roots.add(file);
    }
  }

  String path = FetchExtResourceAction.getExternalResourcesPath();
  VirtualFile extResources = LocalFileSystem.getInstance().findFileByPath(path);
  ContainerUtil.addIfNotNull(extResources, roots);

  return roots;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static void addItemsForMarkers(List<RelatedItemLineMarkerInfo> markers,
                                       List<GotoRelatedItem> result) {
  Set<PsiFile> addedFiles = new HashSet<PsiFile>();
  for (RelatedItemLineMarkerInfo<?> marker : markers) {
    Collection<? extends GotoRelatedItem> items = marker.createGotoRelatedItems();
    for (GotoRelatedItem item : items) {
      PsiElement element = item.getElement();
      if (element instanceof PsiFile) {
        PsiFile file = (PsiFile)element;
        if (addedFiles.contains(file)) {
          continue;
        }
      }
      if (element != null) {
        ContainerUtil.addIfNotNull(element.getContainingFile(), addedFiles);
      }
      result.add(item);
    }
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
@NotNull
protected List<String> collectNewParameterNames() {
  final Set<String> enclosingScopeReads = new LinkedHashSet<String>();
  for (ScopeOwner owner : PsiTreeUtil.collectElementsOfType(myFunction, ScopeOwner.class)) {
    final AnalysisResult result = analyseScope(owner);
    if (!result.nonlocalWritesToEnclosingScope.isEmpty()) {
      throw new IncorrectOperationException(PyBundle.message("refactoring.make.function.top.level.error.nonlocal.writes"));
    }
    if (!result.readsOfSelfParametersFromEnclosingScope.isEmpty()) {
      throw new IncorrectOperationException(PyBundle.message("refactoring.make.function.top.level.error.self.reads"));
    }
    for (PsiElement element : result.readsFromEnclosingScope) {
      if (element instanceof PyElement) {
        ContainerUtil.addIfNotNull(enclosingScopeReads, ((PyElement)element).getName());
      }
    }
  }
  return Lists.newArrayList(enclosingScopeReads);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static List<VirtualFile> calcRoots(@Nullable VirtualFile home) {
  if (home == null) {
    return Collections.emptyList();
  }

  final VirtualFile lib = home.findChild("lib");
  if (lib == null) {
    return Collections.emptyList();
  }

  List<VirtualFile> result = new ArrayList<VirtualFile>();
  for (VirtualFile file : lib.getChildren()) {
    if ("jar".equals(file.getExtension())) {
      ContainerUtil.addIfNotNull(StandardFileSystems.getJarRootForLocalFile(file), result);
    }
  }
  return result;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void addConstantsFromReferencedClassesInSwitch(final Consumer<LookupElement> results) {
  final Set<PsiField> fields = ReferenceExpressionCompletionContributor.findConstantsUsedInSwitch(myPlace);
  final Set<PsiClass> classes = new HashSet<PsiClass>();
  for (PsiField field : fields) {
    ContainerUtil.addIfNotNull(classes, field.getContainingClass());
  }
  for (PsiClass aClass : classes) {
    processMembers(new Consumer<LookupElement>() {
      @Override
      public void consume(LookupElement element) {
        //noinspection SuspiciousMethodCalls
        if (!fields.contains(element.getObject())) {
          results.consume(TailTypeDecorator.withTail(element, TailType.CASE_COLON));
        }
      }
    }, aClass, true, false);
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
boolean addCustomRootsForLibrary(OrderEntry forOrderEntry, OrderRootType type, Collection<VirtualFile> result) {
  for (OrderEnumerationHandler handler : myCustomHandlers) {
    final List<String> urls = new ArrayList<String>();
    final boolean added =
      handler.addCustomRootsForLibrary(forOrderEntry, type, urls);
    for (String url : urls) {
      ContainerUtil.addIfNotNull(VirtualFileManager.getInstance().findFileByUrl(url), result);
    }
    if (added) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public Iterable<T> classify(final Iterable<T> source, final ProcessingContext context) {
  List<T> nulls = null;
  TreeMap<Comparable, List<T>> map = new TreeMap<Comparable, List<T>>();
  for (T t : source) {
    final Comparable weight = getWeight(t, context);
    if (weight == null) {
      if (nulls == null) nulls = new SmartList<T>();
      nulls.add(t);
    } else {
      List<T> list = map.get(weight);
      if (list == null) {
        map.put(weight, list = new SmartList<T>());
      }
      list.add(t);
    }
  }

  final List<List<T>> values = new ArrayList<List<T>>();
  values.addAll(myNegated ? map.descendingMap().values() : map.values());
  ContainerUtil.addIfNotNull(values, nulls);

  return new Iterable<T>() {
    @Override
    public Iterator<T> iterator() {
      return new FlatteningIterator<List<T>, T>(values.iterator()) {
        @Override
        protected Iterator<T> createValueIterator(List<T> group) {
          return myNext.classify(group, context).iterator();
        }
      };
    }
  };
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private List<LibraryCompositionSettings> getLibrariesCompositionSettingsList() {
  List<LibraryCompositionSettings> list = new ArrayList<LibraryCompositionSettings>();
  List<FrameworkSupportNode> selected = getSelectedNodes();
  for (FrameworkSupportNode node : selected) {
    ContainerUtil.addIfNotNull(list, getLibraryCompositionSettings(node));
  }
  return list;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public IgnoreBaseClassQuickFix(@NotNull PyClass baseClass, @NotNull TypeEvalContext context) {
  myBaseClassNames = new ArrayList<String>();
  ContainerUtil.addIfNotNull(myBaseClassNames, baseClass.getQualifiedName());
  for (PyClass ancestor : baseClass.getAncestorClasses(context)) {
    ContainerUtil.addIfNotNull(myBaseClassNames, ancestor.getQualifiedName());
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
private LocalQuickFix[] createNPEFixes(PsiExpression qualifier, PsiExpression expression, boolean onTheFly) {
  if (qualifier == null || expression == null) return null;
  if (qualifier instanceof PsiMethodCallExpression) return null;

  try {
    final List<LocalQuickFix> fixes = new SmartList<LocalQuickFix>();

    if (isVolatileFieldReference(qualifier)) {
      ContainerUtil.addIfNotNull(fixes, createIntroduceVariableFix(qualifier));
    }
    else if (!(qualifier instanceof PsiLiteralExpression && ((PsiLiteralExpression)qualifier).getValue() == null))  {
      if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4)) {
        final Project project = qualifier.getProject();
        final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
        final PsiBinaryExpression binary = (PsiBinaryExpression)elementFactory.createExpressionFromText("a != null", null);
        binary.getLOperand().replace(qualifier);
        ContainerUtil.addIfNotNull(fixes, createAssertFix(binary, expression));
      }

      addSurroundWithIfFix(qualifier, fixes, onTheFly);

      if (ReplaceWithTernaryOperatorFix.isAvailable(qualifier, expression)) {
        fixes.add(new ReplaceWithTernaryOperatorFix(qualifier));
      }
    }

    ContainerUtil.addIfNotNull(fixes, DfaOptionalSupport.registerReplaceOptionalOfWithOfNullableFix(qualifier));
    return fixes.isEmpty() ? null : fixes.toArray(new LocalQuickFix[fixes.size()]);
  }
  catch (IncorrectOperationException e) {
    LOG.error(e);
    return null;
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public List<WCInfoWithBranches> loadRoots() {
  List<WCInfoWithBranches> result = ContainerUtil.newArrayList();

  for (WCInfo info : myVcs.getAllWcInfos()) {
    ContainerUtil.addIfNotNull(result, createInfo(info));
  }

  return result;
}