Java Code Examples for com.intellij.util.ThrowableRunnable#run()

public static void tearDownIgnoringObjectNotDisposedException(ThrowableRunnable<Exception> delegate) throws Exception {
	try {
		delegate.run();
	} catch (RuntimeException e) {
		// We don't want to release the editor in the Tool Output tool window, so we ignore
		// ObjectNotDisposedExceptions related to this particular editor
		if ( e.getClass().getName().equals("com.intellij.openapi.util.TraceableDisposable$ObjectNotDisposedException")
				|| e instanceof CompoundRuntimeException ) {
			StringWriter stringWriter = new StringWriter();
			e.printStackTrace(new PrintWriter(stringWriter));
			String stack = stringWriter.toString();
			if ( stack.contains("ANTLRv4PluginController.createToolWindows")
					|| stack.contains("org.antlr.intellij.plugin.preview.InputPanel.createPreviewEditor") ) {
				return;
			}
		}

		throw e;
	}
}
 

public static boolean wrap(final ThrowableRunnable<VcsException> runnable, final Project project, final String title) {
  final VcsException[] exc = new VcsException[1];
  final Runnable process = new Runnable() {
    @Override
    public void run() {
      try {
        runnable.run();
      }
      catch (VcsException e) {
        exc[0] = e;
      }
    }
  };
  final boolean notCanceled;
  if (ApplicationManager.getApplication().isDispatchThread()) {
    notCanceled = ProgressManager.getInstance().runProcessWithProgressSynchronously(process, title, true, project);
  } else {
    process.run();
    notCanceled = true;
  }
  if (exc[0] != null) {
    AbstractVcsHelper.getInstance(project).showError(exc[0], title);
    return false;
  }
  return notCanceled;
}
 

public static void runExport(final Project project, @Nonnull ThrowableRunnable<IOException> runnable) {
  try {
    runnable.run();
  }
  catch (IOException e) {
    Runnable showError = new Runnable() {
      @Override
      public void run() {
        Messages.showMessageDialog(
          project,
          InspectionsBundle.message("inspection.export.error.writing.to", "export file"),
          InspectionsBundle.message("inspection.export.results.error.title"),
          Messages.getErrorIcon()
        );
      }
    };
    ApplicationManager.getApplication().invokeLater(showError, ModalityState.NON_MODAL);
    throw new ProcessCanceledException();
  }
}
 

private void executeNestedInitializationTask(@Nonnull ThrowableRunnable<?> callable, CountDownLatch proceedLatch) {
  Application app = ApplicationManager.getApplication();
  try {
    // To correctly apply file removals in indices's shutdown hook we should process all initialization tasks
    // Todo: make processing removed files more robust because ignoring 'dispose in progress' delays application exit and
    // may cause memory leaks IDEA-183718, IDEA-169374,
    if (app.isDisposed() /*|| app.isDisposeInProgress()*/) return;
    callable.run();
  }
  catch (Throwable t) {
    onThrowable(t);
  }
  finally {
    proceedLatch.countDown();
  }
}
 

@Inject
@ReviewAfterMigrationToJRE(9)
public MacOSDefaultMenuInitializer(AboutManager aboutManager, DataManager dataManager, WindowManager windowManager) {
  myAboutManager = aboutManager;
  myDataManager = dataManager;
  myWindowManager = windowManager;
  if (SystemInfo.isMac) {
    try {
      ThrowableRunnable<Throwable> task = SystemInfo.isJavaVersionAtLeast(9) ? new Java9Worker(this::showAbout) : new PreJava9Worker(this::showAbout);

      task.run();

      installAutoUpdateMenu();
    }
    catch (Throwable t) {
      LOGGER.warn(t);
    }
  }
}
 

private void maybeUpdateInReadAction(
    PsiClass specClass, String componentQualifiedName, ShouldUpdateChecker checker) {
  final ThrowableRunnable<RuntimeException> job =
      () -> {
        if (checker.shouldStopUpdate()) return;

        final LayoutSpecModel layoutModel = ComponentGenerateUtils.createLayoutModel(specClass);
        update(componentQualifiedName, layoutModel);
      };
  if (ApplicationManager.getApplication().isReadAccessAllowed()) {
    job.run();
  } else {
    ReadAction.run(job);
  }
}
 

public static <T extends Throwable> void runInContext(CompileContext context, String title, ThrowableRunnable<T> action) throws T {
  if (title != null) {
    context.getProgressIndicator().pushState();
    context.getProgressIndicator().setText(title);
  }
  try {
    action.run();
  }
  finally {
    if (title != null) {
      context.getProgressIndicator().popState();
    }
  }
}
 

/**
 * Invokes the given runnable with alternative resolve set to true.
 *
 * @see #setAlternativeResolveEnabled(boolean)
 */
public <E extends Throwable> void runWithAlternativeResolveEnabled(@Nonnull ThrowableRunnable<E> runnable) throws E {
  setAlternativeResolveEnabled(true);
  try {
    runnable.run();
  }
  finally {
    setAlternativeResolveEnabled(false);
  }
}
 

private static void catchAndWarn(@Nonnull ThrowableRunnable<IOException> runnable) {
  try {
    runnable.run();
  }
  catch (IOException e) {
    LOG.warn(e);
  }
}
 

public static <E extends Throwable> void runWithClassLoader(final ClassLoader classLoader, final ThrowableRunnable<E> runnable) throws E {
  final ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
  try {
    Thread.currentThread().setContextClassLoader(classLoader);
    runnable.run();
  }
  finally {
    Thread.currentThread().setContextClassLoader(oldClassLoader);
  }
}
 

public static <T extends Throwable> void guardPsiModificationsIn(@Nonnull ThrowableRunnable<T> runnable) throws T {
  ApplicationManager.getApplication().assertWriteAccessAllowed();
  boolean old = allowPsiModification;
  try {
    allowPsiModification = false;
    runnable.run();
  }
  finally {
    allowPsiModification = old;
  }
}
 

private void callImpl(final MySection section, final boolean start) throws VcsException {
  final List<ThrowableRunnable<VcsException>> list = new ArrayList<ThrowableRunnable<VcsException>>(2);
  synchronized (myLock) {
    if (start) {
      section.start(list);
    } else {
      section.stop(list);
    }
  }
  for (ThrowableRunnable<VcsException> runnable : list) {
    runnable.run();
  }
}
 

private <T extends Throwable> void withLock(ThrowableRunnable<T> r) throws T {
  myKeyHashToVirtualFileMapping.getPagedFileStorage().lock();
  try {
    r.run();
  }
  finally {
    myKeyHashToVirtualFileMapping.getPagedFileStorage().unlock();
  }
}
 

@TestOnly
public static <T extends Throwable> void runWithDisabledPreview(ThrowableRunnable<T> runnable) throws T {
  PREVIEW_IN_TESTS = false;
  try {
    runnable.run();
  }
  finally {
    PREVIEW_IN_TESTS = true;
  }
}
 

@TestOnly
public static <T extends Throwable> void withIgnoredConflicts(@Nonnull ThrowableRunnable<T> r) throws T {
  try {
    myTestIgnore = true;
    r.run();
  }
  finally {
    myTestIgnore = false;
  }
}