Java ThrowableComputable.compute方法代码示例

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <E extends Throwable> VirtualFile doActionAndRestoreEncoding(@NotNull VirtualFile fileBefore,
                                                                           @NotNull ThrowableComputable<VirtualFile, E> action) throws E {
  EncodingRegistry registry = getInstance();
  Charset charsetBefore = registry.getEncoding(fileBefore, true);
  VirtualFile fileAfter = null;
  try {
    fileAfter = action.compute();
    return fileAfter;
  }
  finally {
    if (fileAfter != null) {
      Charset actual = registry.getEncoding(fileAfter, true);
      if (!Comparing.equal(actual, charsetBefore)) {
        registry.setEncoding(fileAfter, charsetBefore);
      }
    }
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
private <T> T wrapNativeCall(final ThrowableComputable<T, SVNException> runnable) throws SVNException {
  try {
    NativeLogReader.startTracking();
    final T t = runnable.compute();
    final List<NativeLogReader.CallInfo> logged = NativeLogReader.getLogged();
    final StringBuilder sb = new StringBuilder();
    for (NativeLogReader.CallInfo info : logged) {
      final String message = SvnNativeCallsTranslator.getMessage(info);
      if (message != null) {
        if (sb.length() > 0) sb.append('\n');
        sb.append(message);
      }
    }
    if (sb.length() > 0) {
      VcsBalloonProblemNotifier.showOverChangesView(myProject, sb.toString(), MessageType.ERROR);
      LOG.info(sb.toString());
    }
    return t;
  } finally {
    NativeLogReader.clear();
    NativeLogReader.endTracking();
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
@Override
public <T, E extends Exception> T runProcessWithProgressSynchronously(@NotNull final ThrowableComputable<T, E> process,
                                                 @NotNull @Nls String progressTitle,
                                                 boolean canBeCanceled,
                                                 @Nullable Project project) throws E {

  final Ref<T> result = new Ref<T>();
  final Ref<E> exceptionRef = new Ref<E>();
  Task.Modal task = new Task.Modal(project, progressTitle, canBeCanceled) {
    @Override
    public void run(@NotNull ProgressIndicator indicator) {
      try {
        T compute = process.compute();
        result.set(compute);
      }
      catch (Exception e) {
        exceptionRef.set((E)e);
      }
    }
  };
  runProcessWithProgressSynchronously(task, null);
  if (!exceptionRef.isNull()) throw exceptionRef.get();
  return result.get();
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <E extends Throwable> VirtualFile doActionAndRestoreEncoding(@Nonnull VirtualFile fileBefore,
                                                                           @Nonnull ThrowableComputable<VirtualFile, E> action) throws E {
  EncodingRegistry registry = getInstance();
  Charset charsetBefore = registry.getEncoding(fileBefore, true);
  VirtualFile fileAfter = null;
  try {
    fileAfter = action.compute();
    return fileAfter;
  }
  finally {
    if (fileAfter != null) {
      Charset actual = registry.getEncoding(fileAfter, true);
      if (!Comparing.equal(actual, charsetBefore)) {
        registry.setEncoding(fileAfter, charsetBefore);
      }
    }
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T> T executeWithClassLoader(final ThrowableComputable<T, Exception> action, final ClassLoader classLoader)
  throws Exception {
  final Thread thread = Thread.currentThread();
  final ClassLoader prev = thread.getContextClassLoader();
  try {
    thread.setContextClassLoader(classLoader);
    return action.compute();
  }
  finally {
    thread.setContextClassLoader(prev);
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T> T openCleanOrResetBroken(@NotNull ThrowableComputable<T, IOException> factoryComputable, Runnable cleanupCallback) throws IOException {
  for(int i = 0; i < 2; ++i) {
    try {
      return factoryComputable.compute();
    } catch (IOException ex) {
      if (i == 1) throw ex;
      cleanupCallback.run();
    }
  }

  return null;
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public synchronized <T extends Throwable> void runTransaction(@NotNull GithubAuthData expected,
                                                              @NotNull ThrowableComputable<GithubAuthData, T> task) throws T {
  if (expected != myAuthData) {
    return;
  }

  myAuthData = task.compute();
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T> T runInterruptable(@NotNull final ProgressIndicator indicator,
                                     @NotNull ThrowableComputable<T, IOException> task) throws IOException {
  ScheduledFuture<?> future = null;
  try {
    final Thread thread = Thread.currentThread();
    future = addCancellationListener(indicator, thread);

    return task.compute();
  }
  finally {
    if (future != null) future.cancel(true);
    Thread.interrupted();
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T, E extends Throwable> T compute(@Nonnull ThrowableComputable<T, E> action) throws E {
  AccessToken token = start();
  try {
    return action.compute();
  } finally {
    token.finish();
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T, E extends Throwable> T compute(@Nonnull ThrowableComputable<T, E> action) throws E {
  AccessToken token = start();
  try {
    return action.compute();
  }
  finally {
    token.finish();
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T> T openCleanOrResetBroken(@Nonnull ThrowableComputable<T, IOException> factoryComputable, Runnable cleanupCallback) throws IOException {
  for (int i = 0; i < 2; ++i) {
    try {
      return factoryComputable.compute();
    }
    catch (IOException ex) {
      if (i == 1) throw ex;
      cleanupCallback.run();
    }
  }

  return null;
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
public static <T, E extends Throwable> T performPsiModification(String trace, @Nonnull ThrowableComputable<T, E> runnable) throws E {
  startPsiModification(trace);
  try {
    return runnable.compute();
  }
  finally {
    finishPsiModification();
  }
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
@Override
public <T, E extends Throwable> T runReadAction(@NotNull ThrowableComputable<T, E> computation) throws E {
  return computation.compute();
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
@Override
public <T, E extends Throwable> T runWriteAction(@NotNull ThrowableComputable<T, E> computation) throws E {
  return computation.compute();
}
 

import com.intellij.openapi.util.ThrowableComputable; //导入方法依赖的package包/类
/**
 * @param currentRevision - just a hint for optimization
 */
private FileAnnotation annotate(VirtualFile file, final VcsRevisionNumber revisionNumber, final boolean currentRevision,
                                final ThrowableComputable<FileAnnotation, VcsException> delegate) throws VcsException {
  final AnnotationProvider annotationProvider = myAnnotationProvider;

  final FilePath filePath = VcsContextFactory.SERVICE.getInstance().createFilePathOn(file);

  final VcsCacheableAnnotationProvider cacheableAnnotationProvider = (VcsCacheableAnnotationProvider)annotationProvider;

  VcsAnnotation vcsAnnotation = null;
  if (revisionNumber != null) {
    vcsAnnotation = myCache.get(VcsContextFactory.SERVICE.getInstance().createFilePathOn(file), myVcs.getKeyInstanceMethod(), revisionNumber);
  }

  if (vcsAnnotation != null) {
    final VcsHistoryProvider historyProvider = myVcs.getVcsHistoryProvider();
    final VcsAbstractHistorySession history = getHistory(revisionNumber, filePath, historyProvider, vcsAnnotation.getFirstRevision());
    if (history == null) return null;
    // question is whether we need "not moved" path here?
    final ContentRevision fileContent = myVcs.getDiffProvider().createFileContent(revisionNumber, file);
    final FileAnnotation restored = cacheableAnnotationProvider.
      restore(vcsAnnotation, history, fileContent.getContent(), currentRevision,
                                                                        revisionNumber);
    if (restored != null) {
      return restored;
    }
  }

  final FileAnnotation fileAnnotation = delegate.compute();
  vcsAnnotation = cacheableAnnotationProvider.createCacheable(fileAnnotation);
  if (vcsAnnotation == null) return fileAnnotation;

  if (revisionNumber != null) {
    myCache.put(filePath, myVcs.getKeyInstanceMethod(), revisionNumber, vcsAnnotation);
  }

  if (myVcs.getVcsHistoryProvider() instanceof VcsCacheableHistorySessionFactory) {
    loadHistoryInBackgroundToCache(revisionNumber, filePath, vcsAnnotation);
  }
  return fileAnnotation;
}