Java NotNullFunction类代码示例

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
protected PsiElement applyChanges(@NotNull final Project project,
                                  @NotNull final String localName,
                                  @Nullable final PsiExpression initializer,
                                  @NotNull final V variable,
                                  @NotNull final Collection<PsiReference> references,
                                  final boolean delete, @NotNull final NotNullFunction<PsiDeclarationStatement, PsiElement> action) {
  final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);

  return ApplicationManager.getApplication().runWriteAction(
    new Computable<PsiElement>() {
      @Override
      public PsiElement compute() {
        final PsiElement newDeclaration = moveDeclaration(elementFactory, localName, variable, initializer, action, references);
        if (delete) {
          beforeDelete(project, variable, newDeclaration);
          variable.normalizeDeclaration();
          variable.delete();
        }
        return newDeclaration;
      }
    }
  );
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
@NotNull
private static PermanentGraph<Integer> buildPermanentGraph(@NotNull List<? extends GraphCommit<Integer>> commits,
                                                           @NotNull RefsModel refsModel,
                                                           @NotNull final VcsLogHashMap hashMap,
                                                           @NotNull Map<VirtualFile, VcsLogProvider> providers) {
  if (commits.isEmpty()) {
    return EmptyPermanentGraph.getInstance();
  }
  NotNullFunction<Integer, Hash> hashGetter = new NotNullFunction<Integer, Hash>() {
    @NotNull
    @Override
    public Hash fun(Integer commitIndex) {
      return hashMap.getHash(commitIndex);
    }
  };
  GraphColorManagerImpl colorManager = new GraphColorManagerImpl(refsModel, hashGetter, getRefManagerMap(providers));
  Set<Integer> branches = getBranchCommitHashIndexes(refsModel.getAllRefs(), hashMap);
  StopWatch sw = StopWatch.start("building graph");
  PermanentGraphImpl<Integer> permanentGraph = PermanentGraphImpl.newInstance(commits, colorManager, branches);
  sw.report();
  return permanentGraph;
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private void doTest(@NotNull Collection<FileType> fileTypes) throws CollectUsagesException {
  final Set<UsageDescriptor> usages = new FileTypeUsagesCollector().getProjectUsages(getProject());
  for (UsageDescriptor usage : usages) {
    assertEquals(1, usage.getValue());
  }
  assertEquals(
    ContainerUtil.map2Set(fileTypes, new NotNullFunction<FileType, String>() {
      @NotNull
      @Override
      public String fun(FileType fileType) {
        return fileType.getName();
      }
    }),
    ContainerUtil.map2Set(usages, new NotNullFunction<UsageDescriptor, String>() {
      @NotNull
      @Override
      public String fun(UsageDescriptor usageDescriptor) {
        return usageDescriptor.getKey();
      }
    })
  );
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
public void iterateAllCaches(final NotNullFunction<ChangesCacheFile, Boolean> consumer) {
  final AbstractVcs[] vcses = myPlManager.getAllActiveVcss();
  for (AbstractVcs vcs : vcses) {
    final CommittedChangesProvider provider = vcs.getCommittedChangesProvider();
    if (provider instanceof CachingCommittedChangesProvider) {
      final Map<VirtualFile, RepositoryLocation> map = getAllRootsUnderVcs(vcs);
      for (VirtualFile root : map.keySet()) {
        final RepositoryLocation location = map.get(root);
        final ChangesCacheFile cacheFile = getCacheFile(vcs, root, location);
        if (Boolean.TRUE.equals(consumer.fun(cacheFile))) {
          return;
        }
      }
    }
  }
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private boolean hasCachesWithEmptiness(final boolean emptiness) {
  final Ref<Boolean> resultRef = new Ref<Boolean>(Boolean.FALSE);
  myCachesHolder.iterateAllCaches(new NotNullFunction<ChangesCacheFile, Boolean>() {
    @Override
    @NotNull
    public Boolean fun(final ChangesCacheFile changesCacheFile) {
      try {
        if (changesCacheFile.isEmpty() == emptiness) {
          resultRef.set(true);
          return true;
        }
      }
      catch (IOException e) {
        LOG.info(e);
      }
      return false;
    }
  });
  return resultRef.get();
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private void updateExtensionTabs() {
  final ChangesViewContentEP[] contentEPs = myProject.getExtensions(ChangesViewContentEP.EP_NAME);
  for(ChangesViewContentEP ep: contentEPs) {
    final NotNullFunction<Project,Boolean> predicate = ep.newPredicateInstance(myProject);
    if (predicate == null) continue;
    Content epContent = findEPContent(ep);
    final Boolean predicateResult = predicate.fun(myProject);
    if (predicateResult.equals(Boolean.TRUE) && epContent == null) {
      addExtensionTab(ep);
    }
    else if (predicateResult.equals(Boolean.FALSE) && epContent != null) {
      if (!(epContent.getComponent() instanceof ContentStub)) {
        ep.getInstance(myProject).disposeContent();
      }
      myContentManager.removeContent(epContent, true);
    }
  }
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private static Collection<RunContentDescriptor> getConsoles(Project project) {
  PythonConsoleToolWindow toolWindow = PythonConsoleToolWindow.getInstance(project);

  if (toolWindow != null && toolWindow.getToolWindow().isVisible()) {
    RunContentDescriptor selectedContentDescriptor = toolWindow.getSelectedContentDescriptor();
    return selectedContentDescriptor != null ? Lists.newArrayList(selectedContentDescriptor) : Lists.<RunContentDescriptor>newArrayList();
  }

  Collection<RunContentDescriptor> descriptors =
    ExecutionHelper.findRunningConsole(project, new NotNullFunction<RunContentDescriptor, Boolean>() {
      @NotNull
      @Override
      public Boolean fun(RunContentDescriptor dom) {
        return dom.getExecutionConsole() instanceof PyCodeExecutor && isAlive(dom);
      }
    });

  if (descriptors.isEmpty() && toolWindow != null) {
    return toolWindow.getConsoleContentDescriptors();
  }
  else {
    return descriptors;
  }
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private static <T> NotNullLazyValue<List<SmartPsiElementPointer>> createPointersThunk(boolean lazy,
                                                                                      final Project project,
                                                                                      final Factory<Collection<T>> targets,
                                                                                      final NotNullFunction<T, Collection<? extends PsiElement>> converter) {
  if (!lazy) {
    return NotNullLazyValue.createConstantValue(calcPsiTargets(project, targets.create(), converter));
  }

  return new NotNullLazyValue<List<SmartPsiElementPointer>>() {
    @Override
    @NotNull
    public List<SmartPsiElementPointer> compute() {
      return calcPsiTargets(project, targets.create(), converter);
    }
  };
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
/**
 * Consider using {@link DomService#getXmlFileHeader(com.intellij.psi.xml.XmlFile)} when implementing this.
 */
@SuppressWarnings({"MethodMayBeStatic"})
@NotNull
public List<String> getAllowedNamespaces(@NotNull String namespaceKey, @NotNull XmlFile file) {
  final NotNullFunction<XmlTag, List<String>> function = myNamespacePolicies.get(namespaceKey);
  if (function instanceof ConstantFunction) {
    return function.fun(null);
  }

  if (function != null) {
    final XmlDocument document = file.getDocument();
    if (document != null) {
      final XmlTag tag = document.getRootTag();
      if (tag != null) {
        return function.fun(tag);
      }
    }
  } else {
    return Collections.singletonList(namespaceKey);
  }
  return Collections.emptyList();
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
private void logClassPathOnce(@NotNull Project project) {
  List<VirtualFile> files = GradleBuildClasspathManager.getInstance(project).getAllClasspathEntries();
  if (ContainerUtil.equalsIdentity(files, myLastClassPath)) {
    return;
  }
  myLastClassPath = files;

  List<String> paths = ContainerUtil.map(files, new NotNullFunction<VirtualFile, String>() {
    @NotNull
    @Override
    public String fun(VirtualFile vf) {
      return vf.getPath();
    }
  });
  String classPath = Joiner.on(':').join(paths);
  LOG.info(String.format("Android DSL resolver classpath (project %1$s): %2$s", project.getName(), classPath));
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
public void setRepositoryURLs(SVNURL[] urls,
                              final boolean showFiles,
                              @Nullable NotNullFunction<RepositoryBrowserComponent, Expander> defaultExpanderFactory,
                              boolean expandFirst) {
  RepositoryTreeModel model = new RepositoryTreeModel(myVCS, showFiles, this);

  if (defaultExpanderFactory != null) {
    model.setDefaultExpanderFactory(defaultExpanderFactory);
  }

  model.setRoots(urls);
  Disposer.register(this, model);
  myRepositoryTree.setModel(model);

  if (expandFirst) {
    myRepositoryTree.expandRow(0);
  }
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
public SvnRepositoryContentRevision createRevisionLazily(final String path, final boolean isBeforeRevision) {
  final boolean knownAsDirectory = myKnownAsDirectories.contains(path);
  final FilePath localPath = getLocalPath(path, new NotNullFunction<File, Boolean>() {
    @NotNull
    public Boolean fun(final File file) {
      if (knownAsDirectory) return Boolean.TRUE;
      // list will be next
      myWithoutDirStatus.add(new Pair<Integer, Boolean>(myList.size(), isBeforeRevision));
      return Boolean.FALSE;
    }
  });
  long revision = getRevision(isBeforeRevision);
  return localPath == null
         ? SvnRepositoryContentRevision.createForRemotePath(myVcs, myRepositoryRoot, path, knownAsDirectory, revision)
         : SvnRepositoryContentRevision.create(myVcs, myRepositoryRoot, path, localPath, revision);
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
public SvnMergeInfoRootPanelManual(@NotNull Project project,
                                   @NotNull NotNullFunction<WCInfoWithBranches, WCInfoWithBranches> refresher,
                                   @NotNull Runnable listener,
                                   boolean onlyOneRoot,
                                   @NotNull WCInfoWithBranches info) {
  myOnlyOneRoot = onlyOneRoot;
  myInfo = info;
  myProject = project;
  myRefresher = refresher;
  myListener = listener;
  myBranchToLocal = ContainerUtil.newHashMap();

  init();
  myInclude.setVisible(!onlyOneRoot);
  initWithData();
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
/** @deprecated use lookup by user data (to remove in IDEA 13) */
public static Collection<RunContentDescriptor> findRunningConsoleByCmdLine(final Project project,
                                                                           @NotNull final NotNullFunction<String, Boolean> cmdLineMatcher) {
  return findRunningConsole(project, new NotNullFunction<RunContentDescriptor, Boolean>() {
    @NotNull
    @Override
    public Boolean fun(RunContentDescriptor selectedContent) {
      final ProcessHandler processHandler = selectedContent.getProcessHandler();
      if (processHandler instanceof OSProcessHandler && !processHandler.isProcessTerminated()) {
        final String commandLine = ((OSProcessHandler)processHandler).getCommandLine();
        return cmdLineMatcher.fun(commandLine);
      }
      return false;
    }
  });
}
 

import com.intellij.util.NotNullFunction; //导入依赖的package包/类
public static Collection<RunContentDescriptor> findRunningConsole(final Project project,
                                                                  @NotNull final NotNullFunction<RunContentDescriptor, Boolean> descriptorMatcher) {
  final ExecutionManager executionManager = ExecutionManager.getInstance(project);

  final RunContentDescriptor selectedContent = executionManager.getContentManager().getSelectedContent();
  if (selectedContent != null) {
    final ToolWindow toolWindow = ExecutionManager.getInstance(project).getContentManager().getToolWindowByDescriptor(selectedContent);
    if (toolWindow != null && toolWindow.isVisible()) {
      if (descriptorMatcher.fun(selectedContent)) {
        return Collections.singletonList(selectedContent);
      }
    }
  }

  final ArrayList<RunContentDescriptor> result = ContainerUtil.newArrayList();
  for (RunContentDescriptor runContentDescriptor : executionManager.getContentManager().getAllDescriptors()) {
    if (descriptorMatcher.fun(runContentDescriptor)) {
      result.add(runContentDescriptor);
    }
  }
  return result;
}