Java Code Examples for com.intellij.openapi.util.Computable#compute()

void assignId(@Nonnull Computable<ObjectStubSerializer> serializer, String name) throws IOException {
  Computable<ObjectStubSerializer> old = myNameToLazySerializer.put(name, serializer);
  if (old != null) {
    ObjectStubSerializer existing = old.compute();
    ObjectStubSerializer computed = serializer.compute();
    if (existing != computed) {
      throw new AssertionError("ID: " + name + " is not unique, but found in both " + existing.getClass().getName() + " and " + computed.getClass().getName());
    }
    return;
  }

  int id;
  if (myUnmodifiable) {
    id = myNameStorage.tryEnumerate(name);
    if (id == 0) {
      LOG.debug("serialized " + name + " is ignored in unmodifiable stub serialization manager");
      return;
    }
  }
  else {
    id = myNameStorage.enumerate(name);
  }
  myIdToName.put(id, name);
  myNameToId.put(name, id);
}
 

@Override
public void removeData(
  @NotNull Computable<Collection<Module>> toRemove,
  @NotNull Collection<DataNode<TargetMetadata>> toIgnore,
  @NotNull ProjectData projectData,
  @NotNull Project project,
  @NotNull IdeModifiableModelsProvider modelsProvider
) {
  for (Module module : toRemove.compute()) {
    module.clearOption(PantsConstants.PANTS_TARGET_ADDRESSES_KEY);
  }
}
 

@Nullable
public static String getDisplayNameByKey(@Nullable HighlightDisplayKey key) {
  if (key == null) {
    return null;
  }
  else {
    final Computable<String> computable = ourKeyToDisplayNameMap.get(key);
    return computable == null ? null : computable.compute();
  }
}
 

@Override
public <T> T runReadAction(@Nonnull final Computable<T> computation) {
  if (checkReadAccessAllowedAndNoPendingWrites()) {
    return computation.compute();
  }
  startRead();
  try {
    return computation.compute();
  }
  finally {
    endRead();
  }
}
 

public Component queryImpl(Computable<Component> runnable) {
  try {
    myQueryImpl = true;
    return runnable.compute();
  }
  finally {
    myQueryImpl = false;
  }
}
 

@Nullable
private <T> T withTimeout(long maxDurationMillis, @Nonnull Computable<T> task) {
  if (isTestingMode()) {
    return task.compute();
  }

  return ProgressIndicatorUtils.withTimeout(maxDurationMillis, task);
}
 

@Nonnull
private ObjectStubSerializer instantiateSerializer(int id, @Nullable Stub parentStub) throws SerializerNotFoundException {
  String name = myIdToName.get(id);
  Computable<ObjectStubSerializer> lazy = name == null ? null : myNameToLazySerializer.get(name);
  ObjectStubSerializer serializer = lazy == null ? null : lazy.compute();
  if (serializer == null) {
    throw reportMissingSerializer(id, parentStub);
  }
  return serializer;
}
 

@Nullable
public static WeighingComparable<PsiElement, ProximityLocation> getProximity(final Computable<? extends PsiElement> elementComputable, final PsiElement context, ProcessingContext processingContext) {
  PsiElement element = elementComputable.compute();
  if (element == null || context == null) return null;
  Module contextModule = processingContext.get(MODULE_BY_LOCATION);
  if (contextModule == null) {
    contextModule = ModuleUtilCore.findModuleForPsiElement(context);
    processingContext.put(MODULE_BY_LOCATION, contextModule);
  }

  return new WeighingComparable<>(elementComputable, new ProximityLocation(context, contextModule, processingContext), getProximityWeighers());
}
 

@Nullable
public <T> T runWithFormattingDisabled(@Nonnull Computable<T> runnable) {
  disableFormatting();
  try {
    return runnable.compute();
  }
  finally {
    enableFormatting();
  }
}
 

private void addCancelCallback(Computable<Boolean> cbb) {
  Computable<Boolean> callback = myCancelCallback;
  myCancelCallback = () -> cbb.compute() && (callback == null || callback.compute());
}
 

@Override
public <T> T runReadAction(@Nonnull Computable<T> computation) {
  return computation.compute();
}
 

@RequiredUIAccess
@Override
public <T> T runWriteAction(@Nonnull Computable<T> computation) {
  return computation.compute();
}
 

private <T> T withLock(Computable<T> computable) {
  synchronized (myArrangerLock) {
    return computable.compute();
  }
}