/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
public class AsyncResult<T> extends ActionCallback {
private static final Logger LOG = Logger.getInstance(AsyncResult.class);
- private static final AsyncResult REJECTED = new Rejected();
- private static final AsyncResult DONE_LIST = new Done<Object>(Collections.EMPTY_LIST);
-
protected T myResult;
public AsyncResult() {
return subResult;
}
+ @SuppressWarnings("unused")
@NotNull
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public ActionCallback subCallback(@NotNull Consumer<T> doneHandler) {
ActionCallback subCallback = new ActionCallback();
doWhenDone(new SubCallbackDoneCallback<T>(subCallback, doneHandler)).notifyWhenRejected(subCallback);
return this;
}
- @NotNull
- @Deprecated
- /**
- * @deprecated Use {@link #doWhenRejected(com.intellij.util.Consumer)} (to remove in IDEA 16)
- */
- public AsyncResult<T> doWhenRejected(@SuppressWarnings("deprecation") @NotNull final Handler<T> handler) {
- doWhenRejected(new Runnable() {
- @Override
- public void run() {
- handler.run(myResult);
- }
- });
- return this;
- }
-
@NotNull
public AsyncResult<T> doWhenRejected(@NotNull final PairConsumer<T, String> consumer) {
doWhenRejected(new Runnable() {
void run(T t);
}
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public static class Done<T> extends AsyncResult<T> {
public Done(T value) {
setDone(value);
}
}
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public static class Rejected<T> extends AsyncResult<T> {
public Rejected() {
setRejected();
}
@NotNull
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public static <R> AsyncResult<R> rejected() {
- //noinspection unchecked
- return REJECTED;
+ //noinspection unchecked,deprecation
+ return new Rejected();
}
@NotNull
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public static <R> AsyncResult<R> rejected(@NotNull String errorMessage) {
AsyncResult<R> result = new AsyncResult<R>();
result.reject(errorMessage);
}
@NotNull
+ @Deprecated
+ /**
+ * @deprecated Don't use AsyncResult - use Promise instead.
+ */
public static <R extends List> AsyncResult<R> doneList() {
//noinspection unchecked
- return DONE_LIST;
+ return done((R)Collections.emptyList());
}
// we don't use inner class, avoid memory leak, we don't want to hold this result while dependent is computing
/*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.ArrayList;
import java.util.List;
+@SuppressWarnings("unused")
+@Deprecated
/**
- * Please note - rejected results are not collected.
+ * @deprecated Don't use AsyncResult - use Promise instead.
*/
public final class CollectingAsyncResult<T> {
private final List<AsyncResult<T>> asyncResults = new SmartList<AsyncResult<T>>();
}
public AsyncResult<AbstractTreeNode> expandPathToElement(Object element) {
- if (myAbstractTreeBuilder == null) return new AsyncResult.Rejected<AbstractTreeNode>();
+ if (myAbstractTreeBuilder == null) return AsyncResult.rejected();
ArrayList<AbstractTreeNode> pathToElement = getPathToElement(element);
- if (pathToElement.isEmpty()) return new AsyncResult.Rejected<AbstractTreeNode>();
+ if (pathToElement.isEmpty()) return AsyncResult.rejected();
final AsyncResult<AbstractTreeNode> result = new AsyncResult<AbstractTreeNode>();
final AbstractTreeNode toExpand = pathToElement.get(pathToElement.size() - 1);
@NotNull
@Override
public AsyncResult<EditorWindow> getActiveWindow() {
- return new AsyncResult.Done<EditorWindow>(null);
+ return AsyncResult.done(null);
}
@Override
@NotNull
public AsyncResult<Object> revalidateElement(Object element) {
- if (isDisposed()) return new AsyncResult.Rejected<Object>();
+ if (isDisposed()) return AsyncResult.rejected();
AbstractTreeStructure structure = getTreeStructure();
- if (structure == null) return new AsyncResult.Rejected<Object>();
+ if (structure == null) return AsyncResult.rejected();
return structure.revalidateElement(element);
}
}
@NotNull
- private Promise<Void> processExistingNode(@NotNull final DefaultMutableTreeNode childNode,
+ private Promise<?> processExistingNode(@NotNull final DefaultMutableTreeNode childNode,
final NodeDescriptor childDescriptor,
@NotNull final DefaultMutableTreeNode parentNode,
@NotNull final MutualMap<Object, Integer> elementToIndexMap,
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import com.intellij.openapi.actionSystem.PlatformDataKeys;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.AsyncResult;
import com.intellij.openapi.util.Disposer;
import com.intellij.util.Consumer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+import org.jetbrains.concurrency.AsyncPromise;
+import org.jetbrains.concurrency.Promise;
import javax.swing.*;
if (myWasEverShown) return;
try {
- findParentDisposable().doWhenDone(new Consumer<Disposable>() {
- public void consume(Disposable parent) {
- Project project = null;
- if (ApplicationManager.getApplication() != null) {
- project = CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext());
+ findParentDisposable()
+ .done(new Consumer<Disposable>() {
+ public void consume(Disposable parent) {
+ Project project = null;
+ if (ApplicationManager.getApplication() != null) {
+ project = CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext());
+ }
+ initialize(parent, myChild, project);
+ Disposer.register(parent, myChild);
}
- initialize(parent, myChild, project);
- Disposer.register(parent, myChild);
- }
- });
+ });
}
finally {
myWasEverShown = true;
protected abstract void initialize(@NotNull Disposable parent, @NotNull T child, @Nullable Project project);
@NotNull
- private AsyncResult<Disposable> findParentDisposable() {
+ private Promise<Disposable> findParentDisposable() {
return findDisposable(myParent, PlatformDataKeys.UI_DISPOSABLE);
}
-
- private static AsyncResult<Disposable> findDisposable(Disposable defaultValue, final DataKey<? extends Disposable> key) {
+ private static Promise<Disposable> findDisposable(Disposable defaultValue, final DataKey<? extends Disposable> key) {
if (defaultValue == null) {
if (ApplicationManager.getApplication() != null) {
- final AsyncResult<Disposable> result = new AsyncResult<Disposable>();
- DataManager.getInstance().getDataContextFromFocus().doWhenDone(new Consumer<DataContext>() {
- public void consume(DataContext context) {
- Disposable disposable = key.getData(context);
- if (disposable == null) {
- disposable = Disposer.get("ui");
+ final AsyncPromise<Disposable> result = new AsyncPromise<Disposable>();
+ DataManager.getInstance().getDataContextFromFocus()
+ .doWhenDone(new Consumer<DataContext>() {
+ @Override
+ public void consume(DataContext context) {
+ Disposable disposable = key.getData(context);
+ if (disposable == null) {
+ disposable = Disposer.get("ui");
+ }
+ result.setResult(disposable);
}
- result.setDone(disposable);
- }
- });
+ });
return result;
}
else {
}
}
else {
- return new AsyncResult.Done<Disposable>(defaultValue);
+ return Promise.resolve(defaultValue);
}
}
-
-}
+}
\ No newline at end of file
/*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
try {
File parentDir = FileUtil.createTempDirectory("funcTest", "");
File sourceDir = context.getPathMacro().resolveFile(path, context.getBaseDir());
-
+
context.message("Cloning project: " + sourceDir.getAbsolutePath(), context.getCurrentLine());
FileUtil.copyDir(sourceDir, parentDir);
File projectDir = new File(parentDir, sourceDir.getName());
return openProject(context, projectDir.getAbsolutePath());
}
catch (IOException e) {
- return new AsyncResult.Rejected<String>("Cannot create temp directory for clone");
+ return AsyncResult.rejected("Cannot create temp directory for clone");
}
}
/*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@Override
public AsyncResult<Object> revalidate(NodeElement element) {
if (element == actionSystem) {
- return new AsyncResult.Done<Object>(newActionSystem);
+ return AsyncResult.done(newActionSystem);
}
else if (element == fabrique) {
- return new AsyncResult.Done<Object>(newFabrique);
+ return AsyncResult.done(newFabrique);
}
return null;
}
}
public AsyncResult<Object> revalidateElement(Object element) {
- return new AsyncResult.Done<Object>(element);
+ return AsyncResult.done(element);
}
}
\ No newline at end of file
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.popup.PopupStep;
import com.intellij.openapi.ui.popup.util.BaseListPopupStep;
-import com.intellij.openapi.util.AsyncResult;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.text.StringUtil;
import gnu.trove.THashMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+import org.jetbrains.concurrency.AsyncPromise;
+import org.jetbrains.concurrency.Promise;
+import org.jetbrains.concurrency.PromiseKt;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
}
@NotNull
- public static <P extends XBreakpointProperties> AsyncResult<XLineBreakpoint> toggleAndReturnLineBreakpoint(@NotNull final Project project,
-
@NotNull final XLineBreakpointType<P> type,
- @NotNull final XSourcePosition position,
- final boolean temporary,
- @Nullable final Editor editor) {
- return new WriteAction<AsyncResult<XLineBreakpoint>>() {
+ public static <P extends XBreakpointProperties> Promise<XLineBreakpoint> toggleAndReturnLineBreakpoint(@NotNull final Project project,
+ @NotNull final XLineBreakpointType<P> type,
+ @NotNull final XSourcePosition position,
+ final boolean temporary,
+ @Nullable final Editor editor) {
+ return new WriteAction<Promise<XLineBreakpoint>>() {
@Override
- protected void run(@NotNull Result<AsyncResult<XLineBreakpoint>> result) throws Throwable {
+ protected void run(@NotNull Result<Promise<XLineBreakpoint>> result) throws Throwable {
final VirtualFile file = position.getFile();
final int line = position.getLine();
final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
if (!variants.isEmpty() && editor != null) {
RelativePoint relativePoint = DebuggerUIUtil.getPositionForPopup(editor, line);
if (variants.size() > 1 && relativePoint != null) {
- final AsyncResult<XLineBreakpoint> res = new AsyncResult<XLineBreakpoint>();
+ final AsyncPromise<XLineBreakpoint> res = new AsyncPromise<XLineBreakpoint>();
class MySelectionListener implements ListSelectionListener {
RangeHighlighter myHighlighter = null;
@Override
public void run() {
P properties = (P)selectedValue.createProperties();
- res.setDone(breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary));
+ res.setResult(breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary));
}
});
return FINAL_CHOICE;
}
else {
P properties = variants.get(0).createProperties();
- result.setResult(AsyncResult.done(
- (XLineBreakpoint)breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary)));
+ result.setResult(
+ Promise.resolve((XLineBreakpoint)breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary)));
return;
}
}
P properties = type.createBreakpointProperties(file, line);
- result.setResult(AsyncResult
- .done((XLineBreakpoint)breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary)));
+ result.setResult(
+ Promise.resolve((XLineBreakpoint)breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary)));
return;
}
- result.setResult(AsyncResult.<XLineBreakpoint>rejected());
+ result.setResult(PromiseKt.<XLineBreakpoint>rejectedPromise());
}
}.execute().getResultObject();
}
import com.intellij.openapi.editor.FoldRegion;
import com.intellij.openapi.editor.markup.GutterIconRenderer;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.AsyncResult;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+import org.jetbrains.concurrency.Promise;
+import org.jetbrains.concurrency.PromiseKt;
import java.util.ArrayList;
import java.util.Collections;
* - if folded, checks if line breakpoints could be toggled inside folded text
*/
@NotNull
- public static AsyncResult<XLineBreakpoint> toggleLineBreakpoint(@NotNull Project project,
- @NotNull XSourcePosition position,
- @Nullable Editor editor,
- boolean temporary,
- boolean moveCarret) {
+ public static Promise<XLineBreakpoint> toggleLineBreakpoint(@NotNull Project project,
+ @NotNull XSourcePosition position,
+ @Nullable Editor editor,
+ boolean temporary,
+ boolean moveCarret) {
int lineStart = position.getLine();
VirtualFile file = position.getFile();
// for folded text check each line and find out type with the biggest priority
final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
XLineBreakpointType<?>[] lineTypes = XDebuggerUtil.getInstance().getLineBreakpointTypes();
- XLineBreakpointType typeWinner = null;
+ XLineBreakpointType<?> typeWinner = null;
int lineWinner = -1;
for (int line = lineStart; line <= linesEnd; line++) {
int maxPriority = 0;
if (typeWinner != null) {
XSourcePosition winPosition = (lineStart == lineWinner) ? position : XSourcePositionImpl.create(file, lineWinner);
if (winPosition != null) {
- AsyncResult<XLineBreakpoint> res =
- XDebuggerUtilImpl.toggleAndReturnLineBreakpoint(project, typeWinner, winPosition, temporary, editor);
+ Promise<XLineBreakpoint> res = XDebuggerUtilImpl.toggleAndReturnLineBreakpoint(project, typeWinner, winPosition, temporary, editor);
if (editor != null && lineStart != lineWinner) {
int offset = editor.getDocument().getLineStartOffset(lineWinner);
}
}
- return AsyncResult.rejected();
+ return PromiseKt.rejectedPromise();
}
}
import com.intellij.openapi.project.DumbAwareRunnable;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.startup.StartupManager;
-import com.intellij.openapi.util.AsyncResult;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
if (!myProject.isDisposed() && myProject.isInitialized() && file.isValid()) {
ActionManagerEx.getInstanceEx().fireBeforeActionPerformed(IdeActions.ACTION_TOGGLE_LINE_BREAKPOINT, e.getMouseEvent());
- AsyncResult<XLineBreakpoint> result = XBreakpointUtil.toggleLineBreakpoint(
- myProject, XSourcePositionImpl.create(file, line), editor, mouseEvent.isAltDown(), false);
- result.doWhenDone(new Consumer<XLineBreakpoint>() {
- @Override
- public void consume(XLineBreakpoint breakpoint) {
- if (!mouseEvent.isAltDown() && mouseEvent.isShiftDown() && breakpoint != null) {
- breakpoint.setSuspendPolicy(SuspendPolicy.NONE);
- String selection = editor.getSelectionModel().getSelectedText();
- if (selection != null) {
- breakpoint.setLogExpression(selection);
+ XBreakpointUtil
+ .toggleLineBreakpoint(myProject, XSourcePositionImpl.create(file, line), editor, mouseEvent.isAltDown(), false)
+ .done(new Consumer<XLineBreakpoint>() {
+ @Override
+ public void consume(XLineBreakpoint breakpoint) {
+ if (!mouseEvent.isAltDown() && mouseEvent.isShiftDown() && breakpoint != null) {
+ breakpoint.setSuspendPolicy(SuspendPolicy.NONE);
+ String selection = editor.getSelectionModel().getSelectedText();
+ if (selection != null) {
+ breakpoint.setLogExpression(selection);
+ }
+ else {
+ breakpoint.setLogMessage(true);
+ }
+ // edit breakpoint
+ DebuggerUIUtil
+ .showXBreakpointEditorBalloon(myProject, mouseEvent.getPoint(), ((EditorEx)editor).getGutterComponentEx(),
+ false, breakpoint);
}
- else {
- breakpoint.setLogMessage(true);
- }
- // edit breakpoint
- DebuggerUIUtil.showXBreakpointEditorBalloon(myProject, mouseEvent.getPoint(), ((EditorEx)editor).getGutterComponentEx(), false, breakpoint);
}
- }
- });
+ });
}
}
});
projects / idea / community.git / commitdiff