Java ReadActionProcessor类代码示例

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  //System.out.println( "processDirectories() : " + psiPackage + " : " + scope );

  final PsiManager psiManager = PsiManager.getInstance( _project );
  return PackageIndex.getInstance( _project )
    .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
public static ReadActionProcessor<PsiReference> createImplicitDefaultAnnotationMethodConsumer(final Processor<PsiReference> consumer) {
  return new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(final PsiReference reference) {
      if (reference instanceof PsiJavaCodeReferenceElement) {
        PsiJavaCodeReferenceElement javaReference = (PsiJavaCodeReferenceElement)reference;
        if (javaReference.getParent() instanceof PsiAnnotation) {
          PsiNameValuePair[] members = ((PsiAnnotation)javaReference.getParent()).getParameterList().getAttributes();
          if (members.length == 1 && members[0].getNameIdentifier() == null) {
            PsiReference t = members[0].getReference();
            if (t != null && !consumer.process(t)) return false;
          }
        }
      }
      return true;
    }
  };
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  final PsiManager psiManager = PsiManager.getInstance(myProject);
  return PackageIndex.getInstance(myProject)
    .getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget,
                                         @NotNull final FindUsagesOptions options,
                                         @NotNull final Processor<UsageInfo> processor) {
  for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) {
    for (final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) {
      boolean success = ReferencesSearch
        .search(new ReferencesSearch.SearchParameters(ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() {
          @Override
          public PsiElement compute() {
            return PomService.convertToPsi(psiTarget);
          }
        }), options.searchScope, false, options.fastTrack))
        .forEach(new ReadActionProcessor<PsiReference>() {
          @Override
          public boolean processInReadAction(final PsiReference reference) {
            return addResult(reference, options, processor);
          }
        });
      if (!success) return false;
    }
  }
  return true;
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
public QuerySearchRequest(@NotNull Query<PsiReference> query,
                          @NotNull final SearchRequestCollector collector,
                          boolean inReadAction,
                          @NotNull final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }
  else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
private static boolean process18MethodPointers(@NotNull final Processor<PsiReference> processor,
                                               @NotNull final PsiMethod constructor,
                                               @NotNull PsiClass aClass) {
  return ReferencesSearch.search(aClass).forEach(new ReadActionProcessor<PsiReference>() {
    @Override
    public boolean processInReadAction(PsiReference reference) {
      final PsiElement element = reference.getElement();
      if (element != null) {
        final PsiElement parent = element.getParent();
        if (parent instanceof PsiMethodReferenceExpression &&
            ((PsiMethodReferenceExpression)parent).getReferenceNameElement() instanceof PsiKeyword) {
          if (((PsiMethodReferenceExpression)parent).isReferenceTo(constructor)) {
            if (!processor.process((PsiReference)parent)) return false;
          }
        }
      }
      return true;
    }
  });
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
@Override
public boolean processPackageDirectories(@NotNull PsiPackage psiPackage,
                                         @NotNull final GlobalSearchScope scope,
                                         @NotNull final Processor<PsiDirectory> consumer,
                                         boolean includeLibrarySources) {
  final PsiManager psiManager = PsiManager.getInstance(getProject());
  return PackageIndex.getInstance(getProject()).getDirsByPackageName(psiPackage.getQualifiedName(), includeLibrarySources)
    .forEach(new ReadActionProcessor<VirtualFile>() {
      @Override
      public boolean processInReadAction(final VirtualFile dir) {
        if (!scope.contains(dir)) return true;
        PsiDirectory psiDir = psiManager.findDirectory(dir);
        return psiDir == null || consumer.process(psiDir);
      }
    });
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget,
                                         @NotNull final Processor<UsageInfo> processor,
                                         @NotNull final FindUsagesOptions options) {
  for (AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME)) {
    for (AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget)) {
      boolean success = ReferencesSearch
        .search(new ReferencesSearch.SearchParameters(PomService.convertToPsi(psiTarget), options.searchScope, false, options.fastTrack))
        .forEach(new ReadActionProcessor<PsiReference>() {
          @Override
          public boolean processInReadAction(final PsiReference reference) {
            return addResult(processor, reference, options);
          }
        });
      if (!success) return false;
    }
  }
  return true;
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
public boolean processFilesWithText(@NotNull final GlobalSearchScope scope,
                                    final short searchContext,
                                    final boolean caseSensitively,
                                    @NotNull String text,
                                    @NotNull final Processor<VirtualFile> processor) {
  List<IdIndexEntry> entries = getWordEntries(text, caseSensitively);
  if (entries.isEmpty()) return true;

  final CommonProcessors.CollectProcessor<VirtualFile> collectProcessor = new CommonProcessors.CollectProcessor<VirtualFile>();
  processFilesContainingAllKeys(scope, new Condition<Integer>() {
    @Override
    public boolean value(Integer integer) {
      return (integer.intValue() & searchContext) != 0;
    }
  }, collectProcessor, entries);

  final FileIndexFacade index = FileIndexFacade.getInstance(myManager.getProject());
  return ContainerUtil.process(collectProcessor.getResults(), new ReadActionProcessor<VirtualFile>() {
    @Override
    public boolean processInReadAction(VirtualFile virtualFile) {
      return !index.shouldBeFound(scope, virtualFile) || processor.process(virtualFile);
    }
  });
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
public QuerySearchRequest(@NotNull Query<PsiReference> query,
                          @NotNull final SearchRequestCollector collector,
                          boolean inReadAction,
                          @NotNull final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
            return processor.process(psiReference, collector);
      }
    };
  } else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }

}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
@Nonnull
private static Processor<PsiElement> localProcessor(@Nonnull final BulkOccurrenceProcessor processor,
                                                    @Nonnull final ProgressIndicator progress,
                                                    @Nonnull final StringSearcher searcher) {
  return new ReadActionProcessor<PsiElement>() {
    @Override
    public boolean processInReadAction(PsiElement scopeElement) {
      if (scopeElement instanceof PsiCompiledElement) {
        // can't scan text of the element
        return true;
      }

      return scopeElement.isValid() &&
             processor.execute(scopeElement, LowLevelSearchUtil.getTextOccurrencesInScope(scopeElement, searcher, progress), searcher);
    }

    @Override
    public String toString() {
      return processor.toString();
    }
  };
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
public QuerySearchRequest(Query<PsiReference> query,
                          final SearchRequestCollector collector,
                          boolean inReadAction, final PairProcessor<PsiReference, SearchRequestCollector> processor) {
  this.query = query;
  this.collector = collector;
  if (inReadAction) {
    this.processor = new ReadActionProcessor<PsiReference>() {
      @RequiredReadAction
      @Override
      public boolean processInReadAction(PsiReference psiReference) {
            return processor.process(psiReference, collector);
      }
    };
  } else {
    this.processor = new Processor<PsiReference>() {
      @Override
      public boolean process(PsiReference psiReference) {
        return processor.process(psiReference, collector);
      }
    };
  }

}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
@Override
public boolean processPackageDirectories(@NotNull PsiJavaPackage psiPackage, @NotNull final GlobalSearchScope scope, @NotNull final Processor<PsiDirectory> consumer)
{
	final PsiManager psiManager = PsiManager.getInstance(getProject());
	return DirectoryIndex.getInstance(getProject()).getDirectoriesByPackageName(psiPackage.getQualifiedName(), false).forEach(new ReadActionProcessor<VirtualFile>()
	{
		@RequiredReadAction
		@Override
		public boolean processInReadAction(final VirtualFile dir)
		{
			if(!scope.contains(dir))
			{
				return true;
			}
			PsiDirectory psiDir = psiManager.findDirectory(dir);
			return psiDir == null || consumer.process(psiDir);
		}
	});
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final FindUsagesOptions options, @NotNull final Processor<UsageInfo> processor)
{
	for(AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME))
	{
		for(final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget))
		{
			boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(ReadAction.compute(() -> PomService.convertToPsi(psiTarget)), options.searchScope, false, options
					.fastTrack)).forEach(new ReadActionProcessor<PsiReference>()
			{
				@Override
				public boolean processInReadAction(final PsiReference reference)
				{
					return addResult(reference, options, processor);
				}
			});
			if(!success)
			{
				return false;
			}
		}
	}
	return true;
}
 

import com.intellij.openapi.application.ReadActionProcessor; //导入依赖的package包/类
private static boolean addClassesUsages(@NotNull PsiPackage aPackage,
                                        @NotNull final JavaPackageFindUsagesOptions options,
                                        @NotNull final Processor<UsageInfo> processor) {
  ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
  if (progress != null){
    progress.pushState();
  }

  List<PsiClass> classes = new ArrayList<PsiClass>();
  addClassesInPackage(aPackage, options.isIncludeSubpackages, classes);
  for (final PsiClass aClass : classes) {
    if (progress != null) {
      String name = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
        @Override
        public String compute() {
          return aClass.getName();
        }
      });
      progress.setText(FindBundle.message("find.searching.for.references.to.class.progress", name));
      progress.checkCanceled();
    }
    boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor<PsiReference>() {
      @Override
      public boolean processInReadAction(final PsiReference psiReference) {
        return addResult(psiReference, options, processor);
      }
    });
    if (!success) return false;
  }

  if (progress != null){
    progress.popState();
  }
  return true;
}