Java SmartList类代码示例

import com.intellij.util.SmartList; //导入依赖的package包/类
@Nullable
private static IProperty getResolvedProperty(@NotNull final XmlAttributeValue codeValue) {
    return CachedValuesManager.getCachedValue(codeValue, KEY, () -> {
        List<IProperty> allProperties = new SmartList<>();
        for (PsiReference nextRef : codeValue.getReferences()) {
            if (nextRef instanceof PsiPolyVariantReference) {
                Arrays.stream(((PsiPolyVariantReference) nextRef).multiResolve(false))
                      .filter(ResolveResult::isValidResult)
                      .map(ResolveResult::getElement)
                      .map(o -> ObjectUtils.tryCast(o, IProperty.class))
                      .filter(Objects::nonNull)
                      .forEach(allProperties::add);
            } else {
                Optional.ofNullable(nextRef.resolve())
                        .map(o -> ObjectUtils.tryCast(o, IProperty.class))
                        .ifPresent(allProperties::add);
            }
        }

        IProperty theChosenOne = chooseForLocale(allProperties);
        return new CachedValueProvider.Result<>(theChosenOne, PsiModificationTracker.MODIFICATION_COUNT);
    });
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
@Override
protected List<PsiElement> getPsiElementsToProcess() {
  return ApplicationManager.getApplication().runReadAction(new Computable<List<PsiElement>>() {
    @Override
    public List<PsiElement> compute() {
      final PsiFile file = PsiManager.getInstance(project).findFile(myFile);
      if (file == null) {
        return Collections.emptyList();
      }

      final FileViewProvider viewProvider = file.getViewProvider();
      final List<PsiElement> elementsToProcess = new SmartList<PsiElement>();

      for (Language lang : viewProvider.getLanguages()) {
        elementsToProcess.add(viewProvider.getPsi(lang));
      }

      return elementsToProcess;
    }
  });
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@SuppressWarnings("ForLoopReplaceableByForEach")
public static <T extends DomElement> List<T> getChildrenOf(DomElement parent, final Class<T> type) {
  final List<T> list = new SmartList<T>();
  List<? extends AbstractDomChildrenDescription> descriptions = parent.getGenericInfo().getChildrenDescriptions();
  for (int i = 0, descriptionsSize = descriptions.size(); i < descriptionsSize; i++) {
    AbstractDomChildrenDescription description = descriptions.get(i);
    if (description.getType() instanceof Class && type.isAssignableFrom((Class<?>)description.getType())) {
      List<T> values = (List<T>)description.getValues(parent);
      for (int j = 0, valuesSize = values.size(); j < valuesSize; j++) {
        T value = values.get(j);
        if (value.exists()) {
          list.add(value);
        }
      }
    }
  }
  return list;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
public static List<LineMarkerInfo> merge(@NotNull List<MergeableLineMarkerInfo> markers) {
  List<LineMarkerInfo> result = new SmartList<LineMarkerInfo>();
  for (int i = 0; i < markers.size(); i++) {
    MergeableLineMarkerInfo marker = markers.get(i);
    List<MergeableLineMarkerInfo> toMerge = new SmartList<MergeableLineMarkerInfo>();
    for (int k = markers.size() - 1; k > i; k--) {
      MergeableLineMarkerInfo current = markers.get(k);
      if (marker.canMergeWith(current)) {
        toMerge.add(0, current);
        markers.remove(k);
      }
    }
    if (toMerge.isEmpty()) {
      result.add(marker);
    }
    else {
      toMerge.add(0, marker);
      result.add(new MyLineMarkerInfo(toMerge));
    }
  }
  return result;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
@Override
public <T extends BeforeRunTask> List<T> getBeforeRunTasks(RunConfiguration settings, Key<T> taskProviderID) {
  if (settings instanceof WrappingRunConfiguration) {
    return getBeforeRunTasks(((WrappingRunConfiguration)settings).getPeer(), taskProviderID);
  }
  List<BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings);
  if (tasks == null) {
    tasks = getBeforeRunTasks(settings);
    myConfigurationToBeforeTasksMap.put(settings, tasks);
  }
  List<T> result = new SmartList<T>();
  for (BeforeRunTask task : tasks) {
    if (task.getProviderId() == taskProviderID) {
      //noinspection unchecked
      result.add((T)task);
    }
  }
  return result;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
public ProblemDescriptor[] checkFile(@NotNull PsiFile file, @NotNull final InspectionManager manager, final boolean isOnTheFly) {
  if (!(file instanceof PropertiesFile)) return null;
  final List<IProperty> properties = ((PropertiesFile)file).getProperties();
  final List<ProblemDescriptor> descriptors = new SmartList<ProblemDescriptor>();
  for (IProperty property : properties) {
    ProgressManager.checkCanceled();
    final PropertyImpl propertyImpl = (PropertyImpl)property;
    for (ASTNode node : ContainerUtil.ar(propertyImpl.getKeyNode(), propertyImpl.getValueNode())) {
      if (node != null) {
        PsiElement key = node.getPsi();
        TextRange textRange = getTrailingSpaces(key, myIgnoreVisibleSpaces);
        if (textRange != null) {
          descriptors.add(manager.createProblemDescriptor(key, textRange, "Trailing spaces", ProblemHighlightType.GENERIC_ERROR_OR_WARNING, true, new RemoveTrailingSpacesFix(myIgnoreVisibleSpaces)));
        }
      }
    }
  }
  return descriptors.toArray(new ProblemDescriptor[descriptors.size()]);
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
private List<AnnotationData> doCollect(@NotNull PsiModifierListOwner listOwner, boolean onlyWritable) {
  String externalName = getExternalName(listOwner, false);
  if (externalName == null) return NO_DATA;

  List<PsiFile> files = findExternalAnnotationsFiles(listOwner);
  if (files == null) return NO_DATA;

  SmartList<AnnotationData> result = new SmartList<AnnotationData>();
  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;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
/**
 * Template configuration is not included
 */
@Override
@NotNull
public List<RunConfiguration> getConfigurationsList(@NotNull ConfigurationType type) {
  List<RunConfiguration> result = null;
  for (RunnerAndConfigurationSettings settings : getSortedConfigurations()) {
    RunConfiguration configuration = settings.getConfiguration();
    if (type.getId().equals(configuration.getType().getId())) {
      if (result == null) {
        result = new SmartList<RunConfiguration>();
      }
      result.add(configuration);
    }
  }
  return ContainerUtil.notNullize(result);
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
public VariableResolverProcessor(@NotNull PsiJavaCodeReferenceElement place, @NotNull PsiFile placeFile) {
  super(place.getReferenceName(), ourFilter, new PsiConflictResolver[]{new JavaVariableConflictResolver()}, new SmartList<CandidateInfo>(), place, placeFile);

  PsiClass access = null;
  PsiElement qualifier = place.getQualifier();
  if (qualifier instanceof PsiExpression) {
    final JavaResolveResult accessClass = PsiUtil.getAccessObjectClass((PsiExpression)qualifier);
    final PsiElement element = accessClass.getElement();
    if (element instanceof PsiTypeParameter) {
      PsiElementFactory factory = JavaPsiFacade.getInstance(placeFile.getProject()).getElementFactory();
      final PsiClassType type = factory.createType((PsiTypeParameter)element);
      final PsiType accessType = accessClass.getSubstitutor().substitute(type);
      if (accessType instanceof PsiArrayType) {
        LanguageLevel languageLevel = PsiUtil.getLanguageLevel(placeFile);
        access = factory.getArrayClass(languageLevel);
      }
      else if (accessType instanceof PsiClassType) {
        access = ((PsiClassType)accessType).resolve();
      }
    }
    else if (element instanceof PsiClass) {
      access = (PsiClass)element;
    }
  }
  myAccessClass = access;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
private void add(@NotNull Element state, @Nullable ProgramRunner runner, @Nullable T data) throws InvalidDataException {
  if (runner == null) {
    if (unloadedSettings == null) {
      unloadedSettings = new SmartList<Element>();
    }
    unloadedSettings.add(state);
    return;
  }

  if (data != null) {
    ((JDOMExternalizable)data).readExternal(state);
  }

  settings.put(runner, data);
  loadedIds.add(runner.getRunnerId());
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
public static List<Pair<Breakpoint, Event>> getEventDescriptors(SuspendContextImpl suspendContext) {
  DebuggerManagerThreadImpl.assertIsManagerThread();
  if(suspendContext == null) {
    return Collections.emptyList();
  }
  final EventSet events = suspendContext.getEventSet();
  if(events == null) {
    return Collections.emptyList();
  }
  final List<Pair<Breakpoint, Event>> eventDescriptors = new SmartList<Pair<Breakpoint, Event>>();

  final RequestManagerImpl requestManager = suspendContext.getDebugProcess().getRequestsManager();
  for (final Event event : events) {
    final Requestor requestor = requestManager.findRequestor(event.request());
    if (requestor instanceof Breakpoint) {
      eventDescriptors.add(Pair.create((Breakpoint)requestor, event));
    }
  }
  return eventDescriptors;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
public static List<JavaPsiClassReferenceElement> createClassLookupItems(final PsiClass psiClass,
                                                                        boolean withInners,
                                                                        InsertHandler<JavaPsiClassReferenceElement> insertHandler,
                                                                        Condition<PsiClass> condition) {
  List<JavaPsiClassReferenceElement> result = new SmartList<JavaPsiClassReferenceElement>();
  if (condition.value(psiClass)) {
    result.add(AllClassesGetter.createLookupItem(psiClass, insertHandler));
  }
  String name = psiClass.getName();
  if (withInners && name != null) {
    for (PsiClass inner : psiClass.getInnerClasses()) {
      if (inner.hasModifierProperty(PsiModifier.STATIC)) {
        for (JavaPsiClassReferenceElement lookupInner : createClassLookupItems(inner, true, insertHandler, condition)) {
          String forced = lookupInner.getForcedPresentableName();
          String qualifiedName = name + "." + (forced != null ? forced : inner.getName());
          lookupInner.setForcedPresentableName(qualifiedName);
          lookupInner.setLookupString(qualifiedName);
          result.add(lookupInner);
        }
      }
    }
  }
  return result;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@Nullable
private static List<PsiMethod> selectMethod(final PsiMethod[] methods, final Trinity<PsiClass, PsiFile, String> previousLineResult) {
  if (previousLineResult == null || previousLineResult.getThird() == null) return null;

  final List<PsiMethod> result = new SmartList<PsiMethod>();
  for (final PsiMethod method : methods) {
    method.accept(new JavaRecursiveElementVisitor() {
      @Override
      public void visitCallExpression(PsiCallExpression callExpression) {
        final PsiMethod resolved = callExpression.resolveMethod();
        if (resolved != null) {
          if (resolved.getName().equals(previousLineResult.getThird())) {
            result.add(method);
          }
        }
      }
    });
  }

  return result;
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
@NotNull
@Override
public ProjectTemplate[] createTemplates(@Nullable String group, WizardContext context) {
  // myGroups contains only not-null keys
  if (group == null) {
    return ProjectTemplate.EMPTY_ARRAY;
  }

  List<ProjectTemplate> templates = null;
  for (Pair<URL, ClassLoader> url : myGroups.getValue().get(group)) {
    try {
      for (String child : UrlUtil.getChildrenRelativePaths(url.first)) {
        if (child.endsWith(ZIP)) {
          if (templates == null) {
            templates = new SmartList<ProjectTemplate>();
          }
          templates.add(new LocalArchivedTemplate(new URL(url.first.toExternalForm() + '/' + child), url.second));
        }
      }
    }
    catch (IOException e) {
      LOG.error(e);
    }
  }
  return ContainerUtil.isEmpty(templates) ? ProjectTemplate.EMPTY_ARRAY : templates.toArray(new ProjectTemplate[templates.size()]);
}
 

import com.intellij.util.SmartList; //导入依赖的package包/类
private void updateBreakpoints(@NotNull Document document) {
  Collection<XLineBreakpointImpl> breakpoints = myBreakpoints.getKeysByValue(document);
  if (breakpoints == null) {
    return;
  }

  TIntHashSet lines = new TIntHashSet();
  List<XBreakpoint<?>> toRemove = new SmartList<XBreakpoint<?>>();
  for (XLineBreakpointImpl breakpoint : breakpoints) {
    breakpoint.updatePosition();
    if (!breakpoint.isValid() || !lines.add(breakpoint.getLine())) {
      toRemove.add(breakpoint);
    }
  }

  removeBreakpoints(toRemove);
}