Java Code Examples for com.intellij.openapi.application.ReadAction#compute()

/**
 * Pause the current thread until dumb mode ends, and then run the read action. Indexes are guaranteed to be available inside that read action,
 * unless this method is already called with read access allowed.
 *
 * @throws ProcessCanceledException if the project is closed during dumb mode
 */
public void runReadActionInSmartMode(@Nonnull Runnable r) {
  if (ApplicationManager.getApplication().isReadAccessAllowed()) {
    // we can't wait for smart mode to begin (it'd result in a deadlock),
    // so let's just pretend it's already smart and fail with IndexNotReadyException if not
    r.run();
    return;
  }

  while (true) {
    waitForSmartMode();
    boolean success = ReadAction.compute(() -> {
      if (getProject().isDisposed()) {
        throw new ProcessCanceledException();
      }
      if (isDumb()) {
        return false;
      }
      r.run();
      return true;
    });
    if (success) break;
  }
}
 

@VisibleForTesting
@Override
@Nullable
public Module findModuleForProcess(Project project, String packageName) {
  for (Module module : ModuleManager.getInstance(project).getModules()) {
    if (AndroidFacet.getInstance(module) == null) {
      continue; // A module must have an attached AndroidFacet to have a package name.
    }

    BlazeModuleSystem moduleSystem = BlazeModuleSystem.getInstance(module);
    String modulePackageName = ReadAction.compute(() -> moduleSystem.getPackageName());
    if (modulePackageName != null && modulePackageName.equals(packageName)) {
      return module;
    }
  }
  return null;
}
 

@Nonnull
String[] getExcludedUrls() {
  return ReadAction.compute(() -> {
    CachedUrls cache = myCache;
    long actualModCount = Arrays.stream(ProjectManager.getInstance().getOpenProjects()).map(ProjectRootManager::getInstance).mapToLong(ProjectRootManager::getModificationCount).sum();
    String[] urls;
    if (cache != null && actualModCount == cache.myModificationCount) {
      urls = cache.myUrls;
    }
    else {
      Collection<String> excludedUrls = new THashSet<>();
      for (Project project : ProjectManager.getInstance().getOpenProjects()) {
        for (Module module : ModuleManager.getInstance(project).getModules()) {
          urls = ModuleRootManager.getInstance(module).getExcludeRootUrls();
          ContainerUtil.addAll(excludedUrls, urls);
        }
      }
      urls = ArrayUtilRt.toStringArray(excludedUrls);
      Arrays.sort(urls);
      myCache = new CachedUrls(actualModCount, urls);
    }
    return urls;
  });
}
 

@Override
public boolean matchesSource(
    Project project,
    TargetInfo target,
    @Nullable PsiFile sourcePsiFile,
    File sourceFile,
    @Nullable TestSize testSize) {
  if (!(sourcePsiFile instanceof PsiClassOwner)) {
    return false;
  }
  String targetName = target.label.targetName().toString();
  if (!targetName.contains("/")) {
    return false;
  }
  return ReadAction.compute(() -> doMatchesSource((PsiClassOwner) sourcePsiFile, targetName));
}
 

@Override
public boolean isValid() {
  if (myIsDeleted) return false;
  return ReadAction.compute(() -> {
    if (getRefManager().getProject().isDisposed()) return false;

    final PsiFile file = myID.getContainingFile();
    //no need to check resolve in offline mode
    if (ApplicationManager.getApplication().isHeadlessEnvironment()) {
      return file != null && file.isPhysical();
    }

    final PsiElement element = getPsiElement();
    return element != null && element.isPhysical();
  });
}
 

@Override
public boolean matchesSource(
    Project project,
    TargetInfo target,
    @Nullable PsiFile sourcePsiFile,
    File sourceFile,
    @Nullable TestSize testSize) {
  if (!(sourcePsiFile instanceof PsiClassOwner)) {
    return false;
  }
  if (target.testClass == null) {
    return false;
  }
  return ReadAction.compute(
      () -> doMatchesSource((PsiClassOwner) sourcePsiFile, target.testClass));
}
 

@Override
@Nullable
public Object retrieveElement(@Nonnull final Object pointer) {
  if (pointer instanceof SmartPsiElementPointer) {
    return ReadAction.compute(() -> ((SmartPsiElementPointer)pointer).getElement());
  }

  return super.retrieveElement(pointer);
}
 

private void fullDirRefresh(@Nonnull VirtualDirectoryImpl dir, @Nonnull RefreshContext refreshContext) {
  while (true) {
    // obtaining directory snapshot
    Pair<String[], VirtualFile[]> result = getDirectorySnapshot(refreshContext.persistence, dir);
    if (result == null) return;
    String[] persistedNames = result.getFirst();
    VirtualFile[] children = result.getSecond();

    RefreshingFileVisitor refreshingFileVisitor = new RefreshingFileVisitor(dir, refreshContext, null, Arrays.asList(children));
    refreshingFileVisitor.visit(dir);
    if (myCancelled) {
      addAllEventsFrom(refreshingFileVisitor);
      break;
    }

    // generating events unless a directory was changed in between
    boolean hasEvents = ReadAction.compute(() -> {
      if (ApplicationManager.getApplication().isDisposed()) {
        return true;
      }
      if (!Arrays.equals(persistedNames, refreshContext.persistence.list(dir)) || !Arrays.equals(children, dir.getChildren())) {
        if (LOG.isDebugEnabled()) LOG.debug("retry: " + dir);
        return false;
      }

      addAllEventsFrom(refreshingFileVisitor);
      return true;
    });
    if (hasEvents) {
      break;
    }
  }
}
 

@Nullable
public static PsiFile restoreFileFromVirtual(@Nonnull VirtualFile virtualFile, @Nonnull Project project, @Nonnull Language language) {
  return ReadAction.compute(() -> {
    if (project.isDisposed()) return null;
    VirtualFile child = restoreVFile(virtualFile);
    if (child == null || !child.isValid()) return null;
    PsiFile file = PsiManager.getInstance(project).findFile(child);
    if (file != null) {
      return file.getViewProvider().getPsi(language == Language.ANY ? file.getViewProvider().getBaseLanguage() : language);
    }

    return null;
  });
}
 

@Nonnull
@Override
public Object createAnchor(@Nonnull Object element) {
  if (element instanceof PsiElement) {
    PsiElement psi = (PsiElement)element;
    return ReadAction.compute(() -> {
      if (!psi.isValid()) return psi;
      return SmartPointerManager.getInstance(psi.getProject()).createSmartPsiElementPointer(psi);
    });
  }
  return super.createAnchor(element);
}
 

private int readSafely(@Nonnull InputStream stream, @Nonnull byte[] buffer, int offset, int length) throws IOException {
  int n = stream.read(buffer, offset, length);
  if (n <= 0) {
    // maybe locked because someone else is writing to it
    // repeat inside read action to guarantee all writes are finished
    if (toLog()) {
      log("F: processFirstBytes(): inputStream.read() returned " + n + "; retrying with read action. stream=" + streamInfo(stream));
    }
    n = ReadAction.compute(() -> stream.read(buffer, offset, length));
    if (toLog()) {
      log("F: processFirstBytes(): under read action inputStream.read() returned " + n + "; stream=" + streamInfo(stream));
    }
  }
  return n;
}
 

@Override
public boolean execute(@Nonnull DefinitionsScopedSearch.SearchParameters queryParameters, @Nonnull Processor<? super PsiElement> consumer)
{
	PsiElement element = queryParameters.getElement();
	if(element instanceof DotNetVirtualImplementOwner)
	{
		Collection<DotNetVirtualImplementOwner> members = ReadAction.compute(() -> OverrideUtil.collectOverridenMembers((DotNetVirtualImplementOwner) element));
		return ContainerUtil.process(members, consumer);
	}
	return true;
}
 

private void performFileProcessing(@Nonnull PsiFile file) {
  for (AbstractLayoutCodeProcessor processor : myProcessors) {
    FutureTask<Boolean> writeTask = ReadAction.compute(() -> processor.prepareTask(file, myProcessChangedTextOnly));

    ProgressIndicatorProvider.checkCanceled();

    ApplicationManager.getApplication().invokeAndWait(() -> WriteCommandAction.runWriteCommandAction(myProject, myCommandName, null, writeTask));

    checkStop(writeTask, file);
  }
}
 

/**
 * do not call this method from plugins, use {@link XDebuggerUtil#createPositionByOffset(VirtualFile, int)} instead
 */
@Nullable
public static XSourcePositionImpl createByOffset(@Nullable VirtualFile file, final int offset) {
  if (file == null) return null;

  return new XSourcePositionImpl(file) {
    private final AtomicNotNullLazyValue<Integer> myLine = new AtomicNotNullLazyValue<Integer>() {
      @Nonnull
      @Override
      protected Integer compute() {
        return ReadAction.compute(() -> {
          Document document = FileDocumentManager.getInstance().getDocument(file);
          if (document == null) {
            return -1;
          }
          return DocumentUtil.isValidOffset(offset, document) ? document.getLineNumber(offset) : -1;
        });
      }
    };

    @Override
    public int getLine() {
      return myLine.getValue();
    }

    @Override
    public int getOffset() {
      return offset;
    }
  };
}
 

@Override
public int getTodoItemCount(final Module val) {
  Iterator<PsiFile> iterator = myBuilder.getFiles(val);
  int count = 0;
  while (iterator.hasNext()) {
    final PsiFile psiFile = iterator.next();
    count += ReadAction.compute(() -> getTreeStructure().getTodoItemCount(psiFile));
  }
  return count;
}
 

@Nullable
private static Module getWorkspaceModule(Project project) {
  return ReadAction.compute(
      () ->
          ModuleManager.getInstance(project)
              .findModuleByName(BlazeDataStorage.WORKSPACE_MODULE_NAME));
}
 

public void findUsages(@Nonnull FindUsagesProcessPresentation processPresentation, @Nonnull Processor<? super UsageInfo> consumer) {
  try {
    myProgress.setIndeterminate(true);
    myProgress.setText("Scanning indexed files...");
    Set<VirtualFile> filesForFastWordSearch = ReadAction.compute(this::getFilesForFastWordSearch);
    myProgress.setIndeterminate(false);
    if (LOG.isDebugEnabled()) {
      LOG.debug("Searching for " + myFindModel.getStringToFind() + " in " + filesForFastWordSearch.size() + " indexed files");
    }

    searchInFiles(filesForFastWordSearch, processPresentation, consumer);

    myProgress.setIndeterminate(true);
    myProgress.setText("Scanning non-indexed files...");
    boolean canRelyOnIndices = canRelyOnIndices();
    final Collection<VirtualFile> otherFiles = collectFilesInScope(filesForFastWordSearch, canRelyOnIndices);
    myProgress.setIndeterminate(false);

    if (LOG.isDebugEnabled()) {
      LOG.debug("Searching for " + myFindModel.getStringToFind() + " in " + otherFiles.size() + " non-indexed files");
    }
    myProgress.checkCanceled();
    long start = System.currentTimeMillis();
    searchInFiles(otherFiles, processPresentation, consumer);
    if (canRelyOnIndices && otherFiles.size() > 1000) {
      long time = System.currentTimeMillis() - start;
      logStats(otherFiles, time);
    }
  }
  catch (ProcessCanceledException e) {
    processPresentation.setCanceled(true);
    if (LOG.isDebugEnabled()) {
      LOG.debug("Usage search canceled", e);
    }
  }

  if (!myLargeFiles.isEmpty()) {
    processPresentation.setLargeFilesWereNotScanned(myLargeFiles);
  }

  if (!myProgress.isCanceled()) {
    myProgress.setText(FindBundle.message("find.progress.search.completed"));
  }
}
 

public static boolean isGeneratedSourceByAnyFilter(@Nonnull VirtualFile file, @Nonnull Project project) {
  return ReadAction.compute(() -> !project.isDisposed() && file.isValid() && EP_NAME.getExtensionList().stream().anyMatch(filter -> filter.isGeneratedSource(file, project)));
}
 

@Nullable
private String getClassName() {
  return ReadAction.compute(() -> psiClass.getQualifiedName());
}
 

@Nullable
@Override
public VirtualFile findClassFile(String fqcn) {
  GlobalSearchScope searchScope = module.getModuleRuntimeScope(false);

  PsiClass[] psiClasses =
      ReadAction.compute(
          () ->
              JavaPsiFacade.getInstance(project)
                  .findClasses(getContainingClassName(fqcn), searchScope));
  if (psiClasses.length == 0) {
    return null;
  }

  BlazeProjectData projectData =
      BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
  if (projectData == null) {
    return null;
  }

  // It's possible that there's more than one source file in the project corresponding to
  // the same fully-qualified class name, with Blaze choosing the appropriate source to use
  // according to some configuration flags. Here we check each of them until we find the one
  // that was chosen during Blaze sync.
  for (PsiClass psiClass : psiClasses) {
    PsiFile psiFile = psiClass.getContainingFile();
    if (psiFile == null) {
      continue;
    }

    VirtualFile virtualFile = psiFile.getVirtualFile();
    if (virtualFile == null) {
      continue;
    }

    FileType fileType = psiFile.getFileType();
    VirtualFile classFile = null;

    if (fileType == StdFileTypes.JAVA) {
      classFile =
          findClassFileForSourceAndRegisterResourcePackage(projectData, virtualFile, fqcn);
    } else if (fileType == StdFileTypes.CLASS) {
      classFile = findClassFileForIJarClass(projectData, virtualFile, fqcn);
    }

    if (classFile != null) {
      return classFile;
    }
  }

  return null;
}