Java Result类代码示例

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@Override
protected void run(@NotNull Result<PsiFile> result) throws Throwable {
    final PsiPackage packageElement = directoryService.getPackage(directory);
    if (packageElement == null) {
        throw new InvalidDirectoryException("Target directory does not provide a package");
    }

    final String fileName = Extensions.append(name, StdFileTypes.JAVA);
    final PsiFile found = directory.findFile(fileName);
    if (found != null) {
        throw new ClassAlreadyExistsException("Class '" + name + "'already exists in " + packageElement.getName());
    }

    final String packageName = packageElement.getQualifiedName();
    final String className = Extensions.remove(this.name, StdFileTypes.JAVA);
    try {
        final String java = converter.convert(packageName, className, json);
        final PsiFile classFile = fileFactory.createFileFromText(fileName, JavaFileType.INSTANCE, java);
        CodeStyleManager.getInstance(classFile.getProject()).reformat(classFile);
        JavaCodeStyleManager.getInstance(classFile.getProject()).optimizeImports(classFile);
        final PsiFile created = (PsiFile) directory.add(classFile);
        result.setResult(created);
    } catch (IOException e) {
        throw new ClassCreationException("Failed to create new class from JSON", e);
    }
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
private VirtualFile createLog4JTest(final Project project, final MavenId projectId, final VirtualFile appDirectory)
{
    return new WriteCommandAction<VirtualFile>(project, "Create Log4J Test File", PsiFile.EMPTY_ARRAY)
    {
        @Override
        protected void run(@NotNull Result<VirtualFile> result) throws Throwable
        {

            try
            {
                VirtualFile configFile = appDirectory.findOrCreateChildData(this, "log4j2-test.xml");
                final FileTemplateManager manager = FileTemplateManager.getInstance(project);
                final FileTemplate template = manager.getInternalTemplate(MuleFileTemplateDescriptorManager.LOG4J2_TEST);
                final Properties defaultProperties = manager.getDefaultProperties();
                final String text = template.getText(defaultProperties);
                VfsUtil.saveText(configFile, text);
                result.setResult(configFile);
            }
            catch (IOException e)
            {
                showError(project, e);
            }
        }
    }.execute().getResultObject();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  final IdeaTestFixtureFactory factory = IdeaTestFixtureFactory.getFixtureFactory();

  myTestFixture = createFixture(factory);

  myTestFixture.setTestDataPath(getTestDataBasePath() + getTestDataPath());

  Class<? extends LocalInspectionTool>[] inspectionClasses = new DefaultInspectionProvider().getInspectionClasses();
  if (getName().contains("Inspection")) {
    inspectionClasses = ArrayUtil.mergeArrays(inspectionClasses, ApplicationLoader.getInspectionClasses());
  }

  myTestFixture.setUp();

  myTestFixture.enableInspections(inspectionClasses);

  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      ResourceUtil.copyFiles(HighlightingTestBase.this);
      init();
    }
  }.execute().throwException();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@Override
public Promise<Void> changeLanguageLevel(@NotNull Module module, @NotNull final LanguageLevel level) {
  if (!myProjectsManager.isMavenizedModule(module)) return null;

  MavenProject mavenProject = myProjectsManager.findProject(module);
  if (mavenProject == null) return null;

  final MavenDomProjectModel model = MavenDomUtil.getMavenDomProjectModel(myProject, mavenProject.getFile());
  if (model == null) return null;

  new WriteCommandAction(myProject, "Add Maven Dependency", DomUtil.getFile(model)) {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      MavenDomConfiguration configuration = getCompilerPlugin(model).getConfiguration();
      XmlTag tag = configuration.ensureTagExists();
      setChildTagValue(tag, "source", level.getCompilerComplianceDefaultOption());
      setChildTagValue(tag, "target", level.getCompilerComplianceDefaultOption());
      Document document = PsiDocumentManager.getInstance(myProject).getDocument(DomUtil.getFile(model));
      if (document != null) {
        FileDocumentManager.getInstance().saveDocument(document);
      }
    }
  }.execute();
  return myProjectsManager.forceUpdateProjects(Collections.singleton(mavenProject));
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
protected PsiDirectory createSubdirectory(PsiDirectory fileDirectory, String subDirectoryName) throws Exception {
    new WriteCommandAction(this.project) {

        @Override
        protected void run(@NotNull Result result) throws Throwable {
            fileDirectory.createSubdirectory(subDirectoryName);
        }

        @Override
        public String getGroupID() {
            return "Create Command";
        }

    }.execute();

    return fileDirectory.findSubdirectory(subDirectoryName);
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public void testRemoveModuleSpecifiedWithInclude() throws IOException {
  Collection<String> modules = Arrays.asList("one", "two", "three", "four", "five");
  final String body = getSettingsFileWithModules(modules);
  for (final String module : modules) {
    final GradleSettingsFile file = getTestFile(body);
    new WriteCommandAction<Object>(getProject(), file.getPsiFile()) {
      @Override
      protected void run(@NotNull Result<Object> result) throws Throwable {
        file.removeModule(module);
      }
    }.execute();
    Set<String> postDelete = ImmutableSet.copyOf(file.getModules());
    assertEquals(module + " was not deleted", modules.size() - 1, postDelete.size());
    assertFalse(module + " was not deleted", postDelete.contains(module));
    Predicate<String> notCurrentModule = Predicates.not(Predicates.equalTo(module));
    String expectedFileContents = getSettingsFileWithModules(Iterables.filter(modules, notCurrentModule));
    assertEquals(expectedFileContents, file.getPsiFile().getText());
  }
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@Override
public PsiFile configureByText(@NotNull final FileType fileType, @NotNull @NonNls final String text) {
  assertInitialized();
  final String extension = fileType.getDefaultExtension();
  final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
  if (fileTypeManager.getFileTypeByExtension(extension) != fileType) {
    new WriteCommandAction(getProject()) {
      @Override
      protected void run(@NotNull Result result) throws Exception {
        fileTypeManager.associateExtension(fileType, extension);
      }
    }.execute();
  }
  final String fileName = "aaa." + extension;
  return configureByText(fileName, text);
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
protected PsiFile addFileToProject(@NotNull final String rootPath, @NotNull final String relativePath, @NotNull final String fileText) {
  return new WriteCommandAction<PsiFile>(getProject()) {
    @Override
    protected void run(@NotNull Result<PsiFile> result) throws Throwable {
      try {
        if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
          final VirtualFile file = myTempDirFixture.createFile(relativePath, fileText);
          result.setResult(PsiManager.getInstance(getProject()).findFile(file));
        }
        else {
          result.setResult(((HeavyIdeaTestFixture)myProjectFixture).addFileToProject(rootPath, relativePath, fileText));
        }
      }
      catch (IOException e) {
        throw new RuntimeException(e);
      }
      finally {
        ((PsiModificationTrackerImpl)PsiManager.getInstance(getProject()).getModificationTracker()).incCounter();
      }
    }
  }.execute().getResultObject();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public CompilerTester(Project project, List<Module> modules) throws Exception {
  myProject = project;
  myModules = modules;
  myMainOutput = new TempDirTestFixtureImpl();
  myMainOutput.setUp();

  CompilerTestUtil.enableExternalCompiler();
  new WriteCommandAction(getProject()) {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      //noinspection ConstantConditions
      CompilerProjectExtension.getInstance(getProject()).setCompilerOutputUrl(myMainOutput.findOrCreateDir("out").getUrl());
      for (Module module : myModules) {
        ModuleRootModificationUtil.setModuleSdk(module, JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk());
      }
    }
  }.execute();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@NotNull
protected PsiFile createFile(@NotNull final Module module, @NotNull final VirtualFile vDir, @NotNull final String fileName, @NotNull final String text) throws IOException {
  return new WriteAction<PsiFile>() {
    @Override
    protected void run(@NotNull Result<PsiFile> result) throws Throwable {
      if (!ModuleRootManager.getInstance(module).getFileIndex().isInSourceContent(vDir)) {
        addSourceContentToRoots(module, vDir);
      }

      final VirtualFile vFile = vDir.createChildData(vDir, fileName);
      VfsUtil.saveText(vFile, text);
      assertNotNull(vFile);
      final PsiFile file = myPsiManager.findFile(vFile);
      assertNotNull(file);
      result.setResult(file);
    }
  }.execute().getResultObject();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public static void chooseAndOverrideOrImplementMethods(final Project project,
                                                       final Editor editor,
                                                       final PsiClass aClass,
                                                       final boolean toImplement) {
  LOG.assertTrue(aClass.isValid());
  ApplicationManager.getApplication().assertReadAccessAllowed();

  Collection<CandidateInfo> candidates = getMethodsToOverrideImplement(aClass, toImplement);
  Collection<CandidateInfo> secondary = toImplement || aClass.isInterface() ?
                                        ContainerUtil.<CandidateInfo>newArrayList() : getMethodsToOverrideImplement(aClass, true);

  final MemberChooser<PsiMethodMember> chooser = showOverrideImplementChooser(editor, aClass, toImplement, candidates, secondary);
  if (chooser == null) return;

  final List<PsiMethodMember> selectedElements = chooser.getSelectedElements();
  if (selectedElements == null || selectedElements.isEmpty()) return;

  LOG.assertTrue(aClass.isValid());
  new WriteCommandAction(project, aClass.getContainingFile()) {
    @Override
    protected void run(@NotNull final Result result) throws Throwable {
      overrideOrImplementMethodsInRightPlace(editor, aClass, selectedElements, chooser.isCopyJavadoc(), chooser.isInsertOverrideAnnotation());
    }
  }.execute();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
@Override
public void invoke(@NotNull final Project project,
                   @NotNull final PsiFile file,
                   @Nullable("is null when called from inspection") Editor editor,
                   @NotNull final PsiElement startElement,
                   @NotNull PsiElement endElement) {
  if (isAvailable(project, null, file)) {
    new WriteCommandAction(project) {
      @Override
      protected void run(@NotNull Result result) throws Throwable {
        final PsiDirectory directory = chooseDirectory(project, file);
        if (directory == null) return;
        ApplicationManager.getApplication().runWriteAction(new Runnable() {
          @Override
          public void run() {
            doCreate(directory, startElement);
          }
        });
      }
    }.execute();
  }
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public void testCaseInsensitiveRename() throws IOException {
  File file = createTempFile("file.txt", "");
  File home = file.getParentFile();
  assertOrderedEquals(Collections.singletonList("file.txt"), home.list());

  final VirtualFile vFile = myFS.refreshAndFindFileByIoFile(file);
  assertNotNull(vFile);
  new WriteAction<Void>() {
    @Override
    protected void run(@NotNull Result<Void> result) throws Throwable {
      vFile.rename(LocalFileSystemTest.class, "FILE.txt");
    }
  }.execute();
  assertEquals("FILE.txt", vFile.getName());
  assertOrderedEquals(Collections.singletonList("FILE.txt"), home.list());
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public static <T extends XBreakpointType> XBreakpoint addBreakpoint(@NotNull final Project project,
                                                                    @NotNull final Class<T> exceptionType,
                                                                    @NotNull final XBreakpointProperties properties) {
  final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  XBreakpointType[] types = XBreakpointUtil.getBreakpointTypes();
  final Ref<XBreakpoint> breakpoint = Ref.create(null);
  for (XBreakpointType type : types) {
    if (exceptionType.isInstance(type)) {
      final T breakpointType = exceptionType.cast(type);
      new WriteAction() {
        @Override
        protected void run(@NotNull Result result) throws Throwable {
          breakpoint.set(breakpointManager.addBreakpoint(breakpointType, properties));
        }
      }.execute();
      break;
    }
  }
  return breakpoint.get();
}
 

import com.intellij.openapi.application.Result; //导入依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
  final MavenDomDependency dep = getDependency(file, editor);

  final VirtualFile[] files;
  if (myFileChooser == null) {
    final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, false, true, true, false, false);
    final PsiFile currentValue = dep != null ? dep.getSystemPath().getValue() : null;
    final VirtualFile toSelect = currentValue == null ? null : currentValue.getVirtualFile();
    files = FileChooser.chooseFiles(descriptor, project, toSelect);
  }
  else {
    files = myFileChooser.produce();
  }
  if (files == null || files.length == 0) return;

  final PsiFile selectedFile = PsiManager.getInstance(project).findFile(files[0]);
  if (selectedFile == null) return;

  if (dep != null) {
    new WriteCommandAction(project) {
      protected void run(@NotNull Result result) throws Throwable {
        dep.getSystemPath().setValue(selectedFile);
      }
    }.execute();
  }
}