Java ContainerUtil.map2Set方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private static Set<File> getBundledScriptFolders() {
  final GroovyFrameworkConfigNotification[] extensions = GroovyFrameworkConfigNotification.EP_NAME.getExtensions();
  Set<Class> classes = new HashSet<Class>(ContainerUtil.map2Set(extensions, new Function<GroovyFrameworkConfigNotification, Class>() {
    @Override
    public Class fun(GroovyFrameworkConfigNotification notification) {
      return notification.getClass();
    }
  }));
  classes.add(GroovyFrameworkConfigNotification.class); // for default extension

  // perhaps a separate extension for that?
  Set<File> scriptFolders = new LinkedHashSet<File>();
  for (Class aClass : classes) {
    File jarPath = new File(PathUtil.getJarPathForClass(aClass));
    if (jarPath.isFile()) {
      jarPath = jarPath.getParentFile();
    }
    scriptFolders.add(new File(jarPath, "standardDsls"));
  }
  return scriptFolders;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public void testLabelsAndColors() throws Exception {
  final TrelloCard card = myRepository.fetchCardById(COLORED_CARD_ID);
  assertNotNull(card);
  final List<TrelloLabel> labels = card.getLabels();

  assertEquals(6, labels.size());
  final Set<String> labelNames = ContainerUtil.map2Set(labels, new Function<TrelloLabel, String>() {
    @Override
    public String fun(TrelloLabel label) {
      return label.getName();
    }
  });
  assertEquals(ContainerUtil.newHashSet("Sky colored label", "Boring label", "Dull label", ""), labelNames);

  assertEquals(EnumSet.of(SKY, LIME, PINK, BLACK), card.getColors());
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public Set<UsageDescriptor> getUsages() {
  final IdeaPluginDescriptor[] plugins = PluginManagerCore.getPlugins();
  final List<IdeaPluginDescriptor> nonBundledEnabledPlugins = ContainerUtil.filter(plugins, new Condition<IdeaPluginDescriptor>() {
    public boolean value(final IdeaPluginDescriptor d) {
      return d.isEnabled() && !d.isBundled() && d.getPluginId() != null;
    }
  });

  return ContainerUtil.map2Set(nonBundledEnabledPlugins, new Function<IdeaPluginDescriptor, UsageDescriptor>() {
    @Override
    public UsageDescriptor fun(IdeaPluginDescriptor descriptor) {
      return new UsageDescriptor(descriptor.getPluginId().getIdString(), 1);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void assertVisitedPaths(File from, String... expected) {
  VirtualFile vDir = refreshAndFind(from);
  assertNotNull(vDir);

  Set<String> expectedSet = ContainerUtil.map2Set(expected, new Function<String, String>() {
    @Override
    public String fun(String path) {
      return FileUtil.toSystemIndependentName(path);
    }
  });
  expectedSet.add(vDir.getPath());

  final Set<String> actualSet = new HashSet<String>();
  VfsUtilCore.visitChildrenRecursively(vDir, new VirtualFileVisitor() {
    @Override
    public boolean visitFile(@NotNull VirtualFile file) {
      actualSet.add(file.getPath());
      return true;
    }
  });

  assertEquals(expectedSet, actualSet);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static char getFirstFreeDriveLetter() {
  final Set<Character> roots = ContainerUtil.map2Set(File.listRoots(), new Function<File, Character>() {
    @Override
    public Character fun(File root) {
      return root.getPath().toUpperCase(Locale.US).charAt(0);
    }
  });

  char drive = 0;
  for (char c = 'E'; c <= 'Z'; c++) {
    if (!roots.contains(c)) {
      drive = c;
      break;
    }
  }

  assertFalse("Occupied: " + roots.toString(), drive == 0);
  return drive;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private <R extends Repository, S extends PushSource, T extends PushTarget> List<PushSupport<R, S, T>> getAffectedSupports() {
  Collection<Repository> repositories = myGlobalRepositoryManager.getRepositories();
  Collection<AbstractVcs> vcss = ContainerUtil.map2Set(repositories, new Function<Repository, AbstractVcs>() {
    @Override
    public AbstractVcs fun(@NotNull Repository repository) {
      return repository.getVcs();
    }
  });
  return ContainerUtil.map(vcss, new Function<AbstractVcs, PushSupport<R, S, T>>() {
    @Override
    public PushSupport<R, S, T> fun(AbstractVcs vcs) {
      //noinspection unchecked
      return DvcsUtil.getPushSupport(vcs);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private List<PsiField> getReferencedFields(@NotNull final PsiField field) {
  final List<PsiField> referencedElements = new ArrayList<PsiField>();

  PsiExpression fieldInitializer = field.getInitializer();
  PsiClass containingClass = field.getContainingClass();

  if (fieldInitializer == null || containingClass == null) {
    return referencedElements;
  }

  Set<PsiField> classFields = myCachedClassFields.get(containingClass);
  if (classFields == null) {
    classFields = ContainerUtil.map2Set(containingClass.getFields(), Functions.<PsiField>id());
    myCachedClassFields.put(containingClass, classFields);
  }

  final Set<PsiField> containingClassFields = classFields;
  fieldInitializer.accept(new JavaRecursiveElementVisitor() {
    public int myCurrentMethodLookupDepth;
    private static final int MAX_METHOD_LOOKUP_DEPTH = 3;

    @Override
    public void visitReferenceExpression(PsiReferenceExpression expression) {
      PsiElement ref = expression.resolve();
      if (ref instanceof PsiField && containingClassFields.contains(ref) && hasSameStaticModifier(field, (PsiField)ref)) {
        referencedElements.add((PsiField)ref);
      }
      else if (ref instanceof PsiMethod && myCurrentMethodLookupDepth < MAX_METHOD_LOOKUP_DEPTH) {
        myCurrentMethodLookupDepth++;
        visitMethod((PsiMethod)ref);
        myCurrentMethodLookupDepth--;
      }

      super.visitReferenceExpression(expression);
    }
  });

  return referencedElements;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static Set<String> getLocalBranches(GitRepository repository) {
  return ContainerUtil.map2Set(repository.getBranches().getLocalBranches(), new Function<GitBranch, String>() {
    @Override
    public String fun(GitBranch branch) {
      return branch.getName();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private Set<String> groupByLeaves() throws Exception {
  SliceTreeStructure treeStructure = configureTree(getTestName(false));
  final SliceRootNode root = (SliceRootNode)treeStructure.getRootElement();
  Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
  Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
  return ContainerUtil.map2Set(leaves, new Function<PsiElement, String>() {
    @Override
    public String fun(PsiElement element) {
      return element.getText();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Nullable
private Set<Integer> getMatchedCommitIndex(@Nullable Collection<Hash> commits) {
  if (commits == null) {
    return null;
  }

  return ContainerUtil.map2Set(commits, new Function<Hash, Integer>() {
    @Override
    public Integer fun(Hash hash) {
      return myHashMap.getCommitIndex(hash);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static Set<Integer> convertNodeIndexesToIds(@NotNull final LinearGraph graph, @NotNull Collection<Integer> nodeIndexes) {
  return ContainerUtil.map2Set(nodeIndexes, new Function<Integer, Integer>() {
    @Override
    public Integer fun(Integer nodeIndex) {
      return graph.getNodeId(nodeIndex);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static Set<String> getTrackedRemoteBranchesFromConfig(GitRepository repository) {
  return ContainerUtil.map2Set(repository.getBranchTrackInfos(), new Function<GitBranchTrackInfo, String>() {
    @Override
    public String fun(GitBranchTrackInfo trackInfo) {
      return trackInfo.getRemoteBranch().getName();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public AllFileTemplatesConfigurable(Project project) {
  myProject = project;
  myManager = getInstance(project);
  myScheme = myManager.getCurrentScheme();
  myInternalTemplateNames = ContainerUtil.map2Set(myManager.getInternalTemplates(), new Function<FileTemplate, String>() {
    @Override
    public String fun(FileTemplate template) {
      return template.getName();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public Set<UsageDescriptor> getUsages() {
  return ContainerUtil.map2Set(PluginManagerCore.getDisabledPlugins(), new Function<String, UsageDescriptor>() {
    @Override
    public UsageDescriptor fun(String descriptor) {
      return new UsageDescriptor(descriptor, 1);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public final Set<String> getRootsToIndex() {
  return ContainerUtil.map2Set(getAdditionalRootsToIndex(), new NotNullFunction<VirtualFile, String>() {
    @NotNull
    @Override
    public String fun(VirtualFile virtualFile) {
      return virtualFile.getUrl();
    }
  });
}