Java ProgressIndicator.checkCanceled方法代码示例

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
@NotNull
private String getAnalysisOutput(@NotNull final ProgressIndicator progressIndicator) throws Exception {
    final List<String> gradlewCommand = System.getProperty("os.name").startsWith("Windows")
            ? Arrays.asList("cmd", "/c", "gradlew.bat", "staticAnalys")
            : Arrays.asList("./gradlew", "staticAnalys");
    gradlewProcess = new ProcessBuilder(gradlewCommand)
            .directory(new File(project.getBasePath()))
            .redirectErrorStream(true)
            .start();
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(gradlewProcess.getInputStream()));
    StringBuilder analysisOutputBuilder = new StringBuilder();

    String outputLine;
    while ((outputLine = bufferedReader.readLine()) != null) {
        progressIndicator.setText2(outputLine);
        progressIndicator.checkCanceled();
        analysisOutputBuilder.append(outputLine);
        analysisOutputBuilder.append('\n');
    }

    return analysisOutputBuilder.toString();
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
static void highlightTodos(@NotNull PsiFile file,
                           @NotNull CharSequence text,
                           int startOffset,
                           int endOffset,
                           @NotNull ProgressIndicator progress,
                           @NotNull ProperTextRange priorityRange,
                           @NotNull Collection<HighlightInfo> insideResult,
                           @NotNull Collection<HighlightInfo> outsideResult) {
  PsiTodoSearchHelper helper = PsiTodoSearchHelper.SERVICE.getInstance(file.getProject());
  if (helper == null) return;
  TodoItem[] todoItems = helper.findTodoItems(file, startOffset, endOffset);
  if (todoItems.length == 0) return;

  for (TodoItem todoItem : todoItems) {
    progress.checkCanceled();
    TextRange range = todoItem.getTextRange();
    String description = text.subSequence(range.getStartOffset(), range.getEndOffset()).toString();
    TextAttributes attributes = todoItem.getPattern().getAttributes().getTextAttributes();
    HighlightInfo.Builder builder = HighlightInfo.newHighlightInfo(HighlightInfoType.TODO).range(range);
    builder.textAttributes(attributes);
    builder.descriptionAndTooltip(description);
    HighlightInfo info = builder.createUnconditionally();
    (priorityRange.containsRange(info.getStartOffset(), info.getEndOffset()) ? insideResult : outsideResult).add(info);
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
public void run(@NotNull ProgressIndicator indicator) {
  indicator.setIndeterminate(true);
  indicator.setText2(VcsBundle.message("commit.wait.util.synched.text"));
  synchronized (myLock) {
    if (myStarted) {
      LOG.error("Waiter running under progress being started again.");
      return;
    }
    myStarted = true;
    while (! myDone) {
      try {
        // every second check whether we are canceled
        myLock.wait(500);
      }
      catch (InterruptedException e) {
        // ok
      }
      indicator.checkCanceled();
    }
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
protected void waitForProcess() {
  if (myHandler != null) {
    ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
    while (!myHandler.waitFor(50)) {
      try {
        if (indicator != null) {
          indicator.checkCanceled();
        }
      }
      catch (ProcessCanceledException pce) {
        myHandler.destroyProcess();
        throw pce;
      }
    }
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
public static boolean processTextOccurrences(@NotNull CharSequence text,
                                             int startOffset,
                                             int endOffset,
                                             @NotNull StringSearcher searcher,
                                             @Nullable ProgressIndicator progress,
                                             @NotNull TIntProcedure processor) {
  if (endOffset > text.length()) {
    throw new AssertionError("end>length");
  }
  for (int index = startOffset; index < endOffset; index++) {
    if (progress != null) progress.checkCanceled();
    //noinspection AssignmentToForLoopParameter
    index = searcher.scan(text, index, endOffset);
    if (index < 0) break;
    if (checkJavaIdentifier(text, startOffset, endOffset, searcher, index)) {
      if (!processor.execute(index)) return false;
    }
  }
  return true;
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
public static int postLesson(@NotNull final Project project, @NotNull final Lesson lesson) {
  if (!checkIfAuthorized(project, "postLesson")) return -1;

  final HttpPost request = new HttpPost(EduStepicNames.STEPIC_API_URL + "/lessons");

  String requestBody = new Gson().toJson(new StepicWrappers.LessonWrapper(lesson));
  request.setEntity(new StringEntity(requestBody, ContentType.APPLICATION_JSON));

  try {
    final CloseableHttpClient client = EduStepicAuthorizedClient.getHttpClient();
    if (client == null) return -1;
    final CloseableHttpResponse response = client.execute(request);
    final HttpEntity responseEntity = response.getEntity();
    final String responseString = responseEntity != null ? EntityUtils.toString(responseEntity) : "";
    final StatusLine line = response.getStatusLine();
    EntityUtils.consume(responseEntity);
    if (line.getStatusCode() != HttpStatus.SC_CREATED) {
      final String message = FAILED_TITLE + "lesson ";
      LOG.error(message + responseString);
      showErrorNotification(project, message, responseString);
      return 0;
    }
    final Lesson postedLesson = new Gson().fromJson(responseString, RemoteCourse.class).getLessons(true).get(0);
    lesson.setId(postedLesson.getId());
    for (Task task : lesson.getTaskList()) {
      final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
      if (indicator != null) {
        indicator.checkCanceled();
      }
      postTask(project, task, postedLesson.getId());
    }
    return postedLesson.getId();
  }
  catch (IOException e) {
    LOG.error(e.getMessage());
  }
  return -1;
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
/**
 * @param indicator           Progress indicator.
 * @param inputStream         source stream
 * @param outputStream        destination stream
 * @param expectedContentSize expected content size, used in progress indicator (negative means unknown length)
 * @return bytes copied
 * @throws IOException              if IO error occur
 * @throws ProcessCanceledException if process was canceled.
 */
public static int copyStreamContent(@Nullable ProgressIndicator indicator,
                                    @NotNull InputStream inputStream,
                                    @NotNull OutputStream outputStream,
                                    int expectedContentSize) throws IOException, ProcessCanceledException {
  if (indicator != null) {
    indicator.checkCanceled();
    if (expectedContentSize < 0) {
      indicator.setIndeterminate(true);
    }
  }

  final byte[] buffer = new byte[8 * 1024];
  int count;
  int total = 0;
  while ((count = inputStream.read(buffer)) > 0) {
    outputStream.write(buffer, 0, count);
    total += count;

    if (indicator != null) {
      indicator.checkCanceled();

      if (expectedContentSize > 0) {
        indicator.setFraction((double)total / expectedContentSize);
      }
    }
  }

  if (indicator != null) {
    indicator.checkCanceled();
  }

  if (total < expectedContentSize) {
    throw new IOException(String.format("Connection closed at byte %d. Expected %d bytes.", total, expectedContentSize));
  }

  return total;
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
private void delegateCommitToVcsThread(final GeneralCommitProcessor processor) {
  final ProgressIndicator indicator = new DelegatingProgressIndicator();

  final Semaphore endSemaphore = new Semaphore();
  endSemaphore.down();

  ChangeListManagerImpl.getInstanceImpl(myProject).executeOnUpdaterThread(new Runnable() {
    @Override
    public void run() {
      indicator.setText("Performing VCS commit...");
      try {
        ProgressManager.getInstance().runProcess(new Runnable() {
          @Override
          public void run() {
            indicator.checkCanceled();
            generalCommit(processor);
          }
        }, indicator);
      }
      finally {
        endSemaphore.up();
      }
    }
  });

  indicator.setText("Waiting for VCS background tasks to finish...");
  while (!endSemaphore.waitFor(20)) {
    indicator.checkCanceled();
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
private static void collectAndShowDuplicates(final Project project) {
  final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  if (indicator != null && !indicator.isCanceled()) {
    indicator.setText("Collecting project images...");
    indicator.setIndeterminate(false);
    final List<VirtualFile> images = new ArrayList<VirtualFile>();
    for (String ext : IMAGE_EXTENSIONS) {
      images.addAll(FilenameIndex.getAllFilesByExt(project, ext));
    }

    final Map<Long, Set<VirtualFile>> duplicates = new HashMap<Long, Set<VirtualFile>>();
    final Map<Long, VirtualFile> all = new HashMap<Long, VirtualFile>();
    for (int i = 0; i < images.size(); i++) {
      indicator.setFraction((double)(i + 1) / (double)images.size());
      final VirtualFile file = images.get(i);
      if (!(file.getFileSystem() instanceof LocalFileSystem)) continue;
      final long length = file.getLength();
      if (all.containsKey(length)) {
        if (!duplicates.containsKey(length)) {
          final HashSet<VirtualFile> files = new HashSet<VirtualFile>();
          files.add(all.get(length));
          duplicates.put(length, files);
        }
        duplicates.get(length).add(file);
      } else {
        all.put(length, file);
      }
      indicator.checkCanceled();
    }
    showResults(project, images, duplicates, all);
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
private void optimizeImportsOnTheFlyLater(@NotNull final ProgressIndicator progress) {
  if ((myHasRedundantImports || myHasMissortedImports) && !progress.isCanceled()) {
    // schedule optimise action at the time of session disposal, which is after all applyInformation() calls
    Disposable invokeFixLater = new Disposable() {
      @Override
      public void dispose() {
        // later because should invoke when highlighting is finished
        ApplicationManager.getApplication().invokeLater(new Runnable() {
          @Override
          public void run() {
            if (myProject.isDisposed() || !myFile.isValid() || !myFile.isWritable()) return;
            IntentionAction optimizeImportsFix = QuickFixFactory.getInstance().createOptimizeImportsFix(true);
            if (optimizeImportsFix.isAvailable(myProject, null, myFile)) {
              optimizeImportsFix.invoke(myProject, null, myFile);
            }
          }
        });
      }
    };
    Disposer.register((DaemonProgressIndicator)progress, invokeFixLater);
    if (progress.isCanceled()) {
      Disposer.dispose(invokeFixLater);
      Disposer.dispose((DaemonProgressIndicator)progress);
      progress.checkCanceled();
    }
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
@Nullable
public FileContent take(@NotNull ProgressIndicator indicator) throws ProcessCanceledException {
  final FileContent content = doTake();
  if (content == null) {
    return null;
  }
  final long length = content.getLength();
  while (true) {
    try {
      indicator.checkCanceled();
    }
    catch (ProcessCanceledException e) {
      pushback(content);
      throw e;
    }

    synchronized (myProceedWithProcessingLock) {
      final boolean requestingLargeSize = length > LARGE_SIZE_REQUEST_THRESHOLD;
      if (requestingLargeSize) {
        myLargeSizeRequested = true;
      }
      try {
        if (myLargeSizeRequested && !requestingLargeSize ||
            myBytesBeingProcessed + length > Math.max(PROCESSED_FILE_BYTES_THRESHOLD, length)) {
          myProceedWithProcessingLock.wait(300);
        }
        else {
          myBytesBeingProcessed += length;
          if (requestingLargeSize) {
            myLargeSizeRequested = false;
          }
          return content;
        }
      }
      catch (InterruptedException ignore) {
      }
    }
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
public static boolean processElementsContainingWordInElement(@NotNull final TextOccurenceProcessor processor,
                                                             @NotNull final PsiElement scope,
                                                             @NotNull final StringSearcher searcher,
                                                             final boolean processInjectedPsi,
                                                             final ProgressIndicator progress) {
  if (progress != null) progress.checkCanceled();

  PsiFile file = scope.getContainingFile();
  FileViewProvider viewProvider = file.getViewProvider();
  final CharSequence buffer = viewProvider.getContents();

  TextRange range = scope.getTextRange();
  if (range == null) {
    LOG.error("Element " + scope + " of class " + scope.getClass() + " has null range");
    return true;
  }

  final int scopeStart = range.getStartOffset();
  final int startOffset = scopeStart;
  int endOffset = range.getEndOffset();
  if (endOffset > buffer.length()) {
    diagnoseInvalidRange(scope, file, viewProvider, buffer, range);
    return true;
  }

  final Project project = file.getProject();
  final TreeElement[] lastElement = {null};
  return processTextOccurrences(buffer, startOffset, endOffset, searcher, progress, new TIntProcedure() {
    @Override
    public boolean execute(int offset) {
      if (progress != null) progress.checkCanceled();
      lastElement[0] = processTreeUp(project, processor, scope, searcher, offset - scopeStart, processInjectedPsi, progress,
                                     lastElement[0]);
      return lastElement[0] != null;
    }
  });
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
private void addHighlightsFromResults(@NotNull List<HighlightInfo> outInfos, @NotNull ProgressIndicator indicator) {
  InspectionProfile inspectionProfile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile();
  PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
  InjectedLanguageManager ilManager = InjectedLanguageManager.getInstance(myProject);
  Set<Pair<TextRange, String>> emptyActionRegistered = new THashSet<Pair<TextRange, String>>();

  for (Map.Entry<PsiFile, List<InspectionResult>> entry : result.entrySet()) {
    indicator.checkCanceled();
    PsiFile file = entry.getKey();
    Document documentRange = documentManager.getDocument(file);
    if (documentRange == null) continue;
    List<InspectionResult> resultList = entry.getValue();
    synchronized (resultList) {
      for (InspectionResult inspectionResult : resultList) {
        indicator.checkCanceled();
        LocalInspectionToolWrapper tool = inspectionResult.tool;
        HighlightSeverity severity = inspectionProfile.getErrorLevel(HighlightDisplayKey.find(tool.getShortName()), file).getSeverity();
        for (ProblemDescriptor descriptor : inspectionResult.foundProblems) {
          indicator.checkCanceled();
          PsiElement element = descriptor.getPsiElement();
          if (element != null) {
            createHighlightsForDescriptor(outInfos, emptyActionRegistered, ilManager, file, documentRange, tool, severity, descriptor, element);
          }
        }
      }
    }
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
@NotNull
public static <T> FairDiffIterable diff(@NotNull T[] data1, @NotNull T[] data2, @NotNull ProgressIndicator indicator) {
  indicator.checkCanceled();

  try {
    // TODO: use ProgressIndicator inside
    Diff.Change change = Diff.buildChanges(data1, data2);
    return fair(create(change, data1.length, data2.length));
  }
  catch (FilesTooBigForDiffException e) {
    throw new DiffTooBigException();
  }
}
 

import com.intellij.openapi.progress.ProgressIndicator; //导入方法依赖的package包/类
private static void download(@NotNull String url, @NotNull File destination, @NotNull ProgressIndicator indicator) throws IOException {
  indicator.setText(String.format("Downloading %s", destination.getName()));
  HttpURLConnection connection = HttpConfigurable.getInstance().openHttpConnection(url);
  int contentLength = connection.getContentLength();
  if (contentLength <= 0) {
    indicator.setIndeterminate(true);
  }
  InputStream readStream = null;
  OutputStream stream = null;
  try {
    readStream = connection.getInputStream();
    //noinspection IOResourceOpenedButNotSafelyClosed
    stream = new BufferedOutputStream(new FileOutputStream(destination));
    byte[] buffer = new byte[2 * 1024 * 1024];
    int read;
    int totalRead = 0;
    final long startTime = System.currentTimeMillis();
    for (read = readStream.read(buffer); read > 0; read = readStream.read(buffer)) {
      totalRead += read;
      stream.write(buffer, 0, read);
      long duration = System.currentTimeMillis() - startTime; // Duration is in ms
      long downloadRate = duration == 0 ? 0 : (totalRead / duration);
      String message =
        String.format("Downloading %1$s (%2$s/s)", destination.getName(), WelcomeUIUtils.getSizeLabel(downloadRate * 1000));
      indicator.setText(message);
      if (contentLength > 0) {
        indicator.setFraction(((double)totalRead) / contentLength);
      }
      indicator.checkCanceled();
    }
  }
  finally {
    if (stream != null) {
      stream.close();
    }
    if (readStream != null) {
      readStream.close();
    }
  }
}