Java Promise类代码示例

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@NotNull
private static Promise<String> evaluateExpression(@NotNull EvaluateContext evaluateContext, @NotNull String expression) {
  return evaluateContext.evaluate(expression).then(new AsyncFunction<EvaluateResult, String>() {
    @NotNull
    @Override
    public Promise<String> fun(EvaluateResult result) {
      Value value = result.value;
      if (value == null) {
        return Promise.resolve("Log expression result doesn't have value");
      }
      else {
        if (value instanceof StringValue && ((StringValue)value).isTruncated()) {
          return ((StringValue)value).getFullString();
        }
        else {
          return Promise.resolve(value.getValueString());
        }
      }
    }
  });
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@NotNull
public static Promise<Value> evaluateGet(@NotNull final Variable variable,
                                         @NotNull Object host,
                                         @NotNull EvaluateContext evaluateContext,
                                         @NotNull String selfName) {
  StringBuilder builder = new StringBuilder(selfName);
  appendUnquotedName(builder, variable.getName());
  return evaluateContext.evaluate(builder.toString(), Collections.singletonMap(selfName, host), false)
    .then(new Function<EvaluateResult, Value>() {
      @Override
      public Value fun(EvaluateResult result) {
        variable.setValue(result.value);
        return result.value;
      }
    });
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@NotNull
@Override
public Promise<VirtualFile> download() {
  synchronized (myLock) {
    switch (getState()) {
      case DOWNLOADING_NOT_STARTED:
        startDownloading();
        return createDownloadedCallback(this);
      case DOWNLOADING_IN_PROGRESS:
        return createDownloadedCallback(this);
      case DOWNLOADED:
        return Promise.resolve(myLocalVirtualFile);

      case ERROR_OCCURRED:
      default:
        return Promise.reject("errorOccured");
    }
  }
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的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 org.jetbrains.concurrency.Promise; //导入依赖的package包/类
public void testAddModuleDependency() throws IOException {
  createTwoModulesPom("m1", "m2");
  VirtualFile m1 = createModulePom("m1", "<groupId>test</groupId>" +
                                         "<artifactId>m1</artifactId>" +
                                         "<version>1</version>");
  createModulePom("m2", "<groupId>test</groupId>" +
                        "<artifactId>m2</artifactId>" +
                        "<version>1</version>");
  importProject();

  Promise<Void> result = getExtension().addModuleDependency(getModule("m1"), getModule("m2"), DependencyScope.COMPILE);
  assertNotNull(result);
  assertHasDependency(m1, "test", "m2");
  waitUntilImported(result);
  assertModuleModuleDeps("m1", "m2");
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
public void testChangeLanguageLevel() throws IOException {
  importProject("<groupId>test</groupId>" +
                "<artifactId>project</artifactId>" +
                "<version>1</version>");

  Module module = getModule("project");
  assertEquals(LanguageLevel.JDK_1_5, EffectiveLanguageLevelUtil.getEffectiveLanguageLevel(module));
  Promise<Void> result = getExtension().changeLanguageLevel(module, LanguageLevel.JDK_1_8);
  assertNotNull(result);
  XmlTag tag = findTag("project.build.plugins.plugin");
  assertNotNull(tag);
  assertEquals("maven-compiler-plugin", tag.getSubTagText("artifactId"));
  XmlTag configuration = tag.findFirstSubTag("configuration");
  assertNotNull(configuration);
  assertEquals("1.8", configuration.getSubTagText("source"));
  assertEquals("1.8", configuration.getSubTagText("target"));

  waitUntilImported(result);
  assertEquals(LanguageLevel.JDK_1_8, EffectiveLanguageLevelUtil.getEffectiveLanguageLevel(module));
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
@NotNull
public Promise stopAsync() {
    final Collection<XDebugProcess> values = debugProcesses.values();
    for (XDebugProcess value : values) {
        value.stopAsync();
    }
    return getDefaultDebugProcesses().stopAsync();
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public void evaluate(@NotNull String expression, @NotNull XEvaluationCallback callback,
                     @Nullable XSourcePosition expressionPosition) {
    log.debug("evaluating: " + expression);
    Promise<LuaDebugValue> promise = myController.execute("return " + expression);
    promise.done(callback::evaluated);
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public Promise<Void> addDependency(@NotNull Module from, @NotNull Module to, @NotNull DependencyScope scope) {
  for (JavaProjectModelModifier modifier : getModelModifiers()) {
    Promise<Void> promise = modifier.addModuleDependency(from, to, scope);
    if (promise != null) {
      return promise;
    }
  }
  return Promise.REJECTED;
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public Promise<Void> changeLanguageLevel(@NotNull Module module, @NotNull LanguageLevel languageLevel) {
  for (JavaProjectModelModifier modifier : getModelModifiers()) {
    Promise<Void> promise = modifier.changeLanguageLevel(module, languageLevel);
    if (promise != null) {
      return promise;
    }
  }
  return Promise.REJECTED;
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public Promise<Void> addExternalLibraryDependency(@NotNull final Collection<Module> modules,
                                                  @NotNull final ExternalLibraryDescriptor descriptor,
                                                  @NotNull final DependencyScope scope) {
  List<String> defaultRoots = descriptor.getLibraryClassesRoots();
  Module firstModule = ContainerUtil.getFirstItem(modules);
  LOG.assertTrue(firstModule != null);
  LocateLibraryDialog dialog = new LocateLibraryDialog(firstModule, defaultRoots, descriptor.getPresentableName());
  List<String> classesRoots = dialog.showAndGetResult();
  if (!classesRoots.isEmpty()) {
    String libraryName = classesRoots.size() > 1 ? descriptor.getPresentableName() : null;
    final List<String> urls = OrderEntryFix.refreshAndConvertToUrls(classesRoots);
    if (modules.size() == 1) {
      ModuleRootModificationUtil.addModuleLibrary(firstModule, libraryName, urls, Collections.<String>emptyList(), scope);
    }
    else {
      new WriteAction() {
        protected void run(@NotNull Result result) {
          Library library =
            LibraryUtil.createLibrary(LibraryTablesRegistrar.getInstance().getLibraryTable(myProject), descriptor.getPresentableName());
          Library.ModifiableModel model = library.getModifiableModel();
          for (String url : urls) {
            model.addRoot(url, OrderRootType.CLASSES);
          }
          model.commit();
          for (Module module : modules) {
            ModuleRootModificationUtil.addDependency(module, library, scope, false);
          }
        }
      }.execute();
    }
  }
  return Promise.DONE;
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public Promise<Void> changeLanguageLevel(@NotNull Module module, @NotNull LanguageLevel level) {
  final LanguageLevel moduleLevel = LanguageLevelModuleExtensionImpl.getInstance(module).getLanguageLevel();
  if (moduleLevel != null && JavaSdkUtil.isLanguageLevelAcceptable(myProject, module, level)) {
    final ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel();
    rootModel.getModuleExtension(LanguageLevelModuleExtension.class).setLanguageLevel(level);
    rootModel.commit();
  }
  else {
    LanguageLevelProjectExtension.getInstance(myProject).setLanguageLevel(level);
    ProjectRootManagerEx.getInstanceEx(myProject).makeRootsChange(EmptyRunnable.INSTANCE, false, true);
  }
  return Promise.DONE;
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@Override
public void consume(Throwable error) {
  Promise.logError(CommandProcessorKt.getLOG(), error);
  if (error != AsyncPromise.OBSOLETE_ERROR) {
    session.reportError((description == null ? "" : description + ": ") + error.getMessage());
  }
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@NotNull
public Promise<Content> loadChildren(@NotNull XValue value) {
  TestCompositeNode childrenNode = new TestCompositeNode();
  value.computeChildren(childrenNode);
  return childrenNode.loadContent(Conditions.<XValueGroup>alwaysFalse(), Conditions.<VariableView>alwaysFalse())
    .done(new Consumer<Content>() {
      @Override
      public void consume(Content content) {
        children = content;
      }
    });
}
 

import org.jetbrains.concurrency.Promise; //导入依赖的package包/类
@NotNull
@Override
public Promise<String> getSource(@NotNull Script script) {
  if (!containsScript(script)) {
    return Promise.reject("No Script");
  }
  //noinspection unchecked
  return scriptSourceLoader.get((SCRIPT)script);
}