Java ContainerUtil.map2Array方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private Comment[] fetchComments(final long id) throws Exception {
  GithubConnection connection = getConnection();
  try {
    List<GithubIssueComment> result = GithubApiUtil.getIssueComments(connection, getRepoAuthor(), getRepoName(), id);

    return ContainerUtil.map2Array(result, Comment.class, new Function<GithubIssueComment, Comment>() {
      @Override
      public Comment fun(GithubIssueComment comment) {
        return new GithubComment(comment.getCreatedAt(), comment.getUser().getLogin(), comment.getBodyHtml(),
                                 comment.getUser().getAvatarUrl(),
                                 comment.getUser().getHtmlUrl());
      }
    });
  }
  finally {
    connection.close();
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public PhabricatorTask[] getIssues(@Nullable String query, int offset, int limit, boolean withClosed) throws Exception {
  // Phabricator will return an error when asked for more than 100 tasks
  int lim = Math.min(limit, 100);
  Params params = new Params()
    .add("queryKey", withClosed ? "all" : "open")
    .add("attachments[projects]", "1")
    .add("limit", String.valueOf(lim));
  // TODO:
  //  .add("offset", String.valueOf(offset));
  if (offset > 0) {
    return new PhabricatorTask[]{};
  }
  if (query != null) {
    Matcher m = TASK_ID.matcher(query);
    if (m.matches()) {
      params.add("constraints[ids][0]", m.group(1));
    } else if (query.length() >= MIN_PHAB_QUERY_LEN) {
      params.add("constraints[query]", query);
    } else {
      return new PhabricatorTask[]{};
    }
  }

  SearchResponse res = apiCall("maniphest.search", SearchResponse.class, params);
  return ContainerUtil
    .map2Array(res.getData(), PhabricatorTask.class, t -> new PhabricatorTask(t, this));
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@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);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private static String[] getButtonTitles() {
  return ContainerUtil.map2Array(values(), String.class, new Function<Decision, String>() {
    @Override
    public String fun(Decision decision) {
      return decision.myButtonText;
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public Object[] getVariants() {
  List<Injectable> list = InjectLanguageAction.getAllInjectables();
  return ContainerUtil.map2Array(list, LookupElement.class, new Function<Injectable, LookupElement>() {
    @Override
    public LookupElement fun(Injectable injectable) {
      return LookupElementBuilder.create(injectable.getId()).withIcon(injectable.getIcon()).withTailText(
        "(" + injectable.getDisplayName() + ")", true);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
@NotNull
public String[] getSubIds() {
  return ContainerUtil.map2Array(getShownScopes(), String.class, new Function<NamedScope, String>() {
    @Override
    public String fun(NamedScope scope) {
      return scope.getName();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
private static ElementFilter getClassReferenceFilter(PsiElement element) {
  //throw new foo
  if (AFTER_THROW_NEW.accepts(element)) {
    return THROWABLES_FILTER;
  }
  
  //throws list
  PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class);
  if (method != null && PsiTreeUtil.isAncestor(method.getThrowsList(), element, true)) {
    return THROWABLES_FILTER;
  }

  //new xxx.yyy
  if (psiElement().afterLeaf(psiElement().withText(".")).withSuperParent(2, psiElement(PsiNewExpression.class)).accepts(element)) {
    if (((PsiNewExpression)element.getParent().getParent()).getClassReference() == element.getParent()) {
      PsiType[] types = ExpectedTypesGetter.getExpectedTypes(element, false);
      return new OrFilter(ContainerUtil.map2Array(types, ElementFilter.class, new Function<PsiType, ElementFilter>() {
        @Override
        public ElementFilter fun(PsiType type) {
          return new AssignableFromFilter(type);
        }
      }));
    }
  }

  return null;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static PsiMethodMember[] convertToMethodMembers(Collection<CandidateInfo> candidates) {
  return ContainerUtil.map2Array(candidates, PsiMethodMember.class, new Function<CandidateInfo, PsiMethodMember>() {
    @Override
    public PsiMethodMember fun(final CandidateInfo s) {
      return new PsiMethodMember(s);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
@NotNull
public ResolveResult[] multiResolve(boolean incompleteCode) {
  final RngGrammar scope = getScope();
  if (scope == null) {
    return ResolveResult.EMPTY_ARRAY;
  }

  final Set<Define> set = DefinitionResolver.resolve(scope, myValue.getValue());
  if (set == null || set.size() == 0) return ResolveResult.EMPTY_ARRAY;

  return ContainerUtil.map2Array(set, ResolveResult.class, this);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void doMoveSymbolsTest(@NotNull String toFileName, String... symbolNames) {
  String root = "/refactoring/move/" + getTestName(true);
  String rootBefore = root + "/before/src";
  String rootAfter = root + "/after/src";
  VirtualFile dir1 = myFixture.copyDirectoryToProject(rootBefore, "");
  PsiDocumentManager.getInstance(myFixture.getProject()).commitAllDocuments();

  final PsiNamedElement[] symbols = ContainerUtil.map2Array(symbolNames, PsiNamedElement.class, new Function<String, PsiNamedElement>() {
    @Override
    public PsiNamedElement fun(String name) {
      final PsiNamedElement found = findFirstNamedElement(name);
      assertNotNull("Symbol '" + name + "' does not exist", found);
      return found;
    }
  });

  VirtualFile toVirtualFile = dir1.findFileByRelativePath(toFileName);
  String path = toVirtualFile != null ? toVirtualFile.getPath() : (dir1.getPath() + "/" + toFileName);
  new PyMoveModuleMembersProcessor(myFixture.getProject(),
                                   symbols,
                                   path,
                                   false).run();

  VirtualFile dir2 = getVirtualFileByName(PythonTestUtil.getTestDataPath() + rootAfter);
  try {
    PlatformTestUtil.assertDirectoriesEqual(dir2, dir1);
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static PsiField[] getAllFields(GrTypeDefinition grType) {
  Map<String, CandidateInfo> fieldsMap = CollectClassMembersUtil.getAllFields(grType);
  return ContainerUtil.map2Array(fieldsMap.values(), PsiField.class, new Function<CandidateInfo, PsiField>() {
    @Override
    public PsiField fun(CandidateInfo entry) {
      return (PsiField)entry.getElement();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static SuppressIntentionAction[] convertBatchToSuppressIntentionActions(@NotNull SuppressQuickFix[] actions) {
  return ContainerUtil.map2Array(actions, SuppressIntentionAction.class, new Function<SuppressQuickFix, SuppressIntentionAction>() {
    @Override
    public SuppressIntentionAction fun(SuppressQuickFix fix) {
      return convertBatchToSuppressIntentionAction(fix);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public MyNode[] buildChildren() {
  return ContainerUtil.map2Array(myTaskActivationState.getTasks(myPhase), MyNode.class, new Function<String, MyNode>() {
    @Override
    public MyNode fun(final String taskName) {
      return new TaskNode(taskName, PhaseNode.this);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public StatisticsInfo[] getAllValues(final String context) {
  final String[] strings;
  synchronized (LOCK) {
    strings = getUnit(getUnitNumber(context)).getKeys2(context);
  }
  return ContainerUtil.map2Array(strings, StatisticsInfo.class, new NotNullFunction<String, StatisticsInfo>() {
    @NotNull
    public StatisticsInfo fun(final String s) {
      return new StatisticsInfo(context, s);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
protected <T extends PsiElement> T[] findChildrenByType(IElementType elementType, Class<T> arrayClass) {
  return ContainerUtil.map2Array(SharedImplUtil.getChildrenOfType(getNode(), elementType), arrayClass, new Function<ASTNode, T>() {
    @Override
    public T fun(final ASTNode s) {
      return (T)s.getPsi();
    }
  });
}