@Override
public void computeChildren(final @NotNull XCompositeNode node) {
Promise<Void> promise =
Variables.processScopeVariables(scope, node, context, callFrame == null);
if (callFrame != null) {
promise.done(
new ObsolescentConsumer<Void>(node) {
@Override
public void consume(Void ignored) {
callFrame
.getReceiverVariable()
.done(
new ObsolescentConsumer<Variable>(node) {
@Override
public void consume(Variable variable) {
node.addChildren(
variable == null
? XValueChildrenList.EMPTY
: XValueChildrenList.singleton(
new VariableView(variable, context)),
true);
}
})
.rejected(
new ObsolescentConsumer<Throwable>(node) {
@Override
public void consume(@Nullable Throwable error) {
node.addChildren(XValueChildrenList.EMPTY, true);
}
});
}
});
}
}
@NotNull
public static <T> Promise<T> all(
@NotNull Collection<Promise<?>> promises, @Nullable T totalResult) {
if (promises.isEmpty()) {
//noinspection unchecked
return (Promise<T>) DONE;
}
final AsyncPromise<T> totalPromise = new AsyncPromise<T>();
Consumer done = new CountDownConsumer<T>(promises.size(), totalPromise, totalResult);
Consumer<Throwable> rejected =
new Consumer<Throwable>() {
@Override
public void consume(Throwable error) {
totalPromise.setError(error);
}
};
for (Promise<?> promise : promises) {
//noinspection unchecked
promise.done(done);
promise.rejected(rejected);
}
return totalPromise;
}
@NotNull
public static <T> Promise<T> chooseDebuggee(
@NotNull final Collection<T> targets,
final int selectedIndex,
@NotNull final Function<T, String> itemToString) {
if (targets.size() == 1) {
return Promise.resolve(ContainerUtil.getFirstItem(targets));
} else if (targets.isEmpty()) {
return Promise.reject("No tabs to inspect");
}
final AsyncPromise<T> result = new AsyncPromise<T>();
ApplicationManager.getApplication()
.invokeLater(
new Runnable() {
@Override
public void run() {
final JBList list = new JBList(targets);
list.setCellRenderer(
new ColoredListCellRenderer() {
@Override
protected void customizeCellRenderer(
JList list, Object value, int index, boolean selected, boolean hasFocus) {
//noinspection unchecked
append(itemToString.fun((T) value));
}
});
if (selectedIndex != -1) {
list.setSelectedIndex(selectedIndex);
}
JBPopupFactory.getInstance()
.createListPopupBuilder(list)
.setTitle("Choose Page to Debug")
.setItemChoosenCallback(
new Runnable() {
@Override
public void run() {
@SuppressWarnings("unchecked")
T value = (T) list.getSelectedValue();
if (value == null) {
result.setError(Promise.createError("No target to inspect"));
} else {
result.setResult(value);
}
}
})
.createPopup()
.showInFocusCenter();
}
});
return result;
}
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
Throwable cause = future.cause();
setError(cause == null ? Promise.createError("No success") : cause);
}
}
public static Promise<Void> all(@NotNull Collection<Promise<?>> promises) {
if (promises.isEmpty()) {
return DONE;
}
final AsyncPromise<Void> totalPromise = new AsyncPromise<Void>();
Consumer done = new CountDownConsumer(promises.size(), totalPromise);
Consumer<String> rejected =
new Consumer<String>() {
@Override
public void consume(String error) {
if (totalPromise.state == AsyncPromise.State.PENDING) {
totalPromise.setError(error);
}
}
};
for (Promise<?> promise : promises) {
//noinspection unchecked
promise.done(done);
promise.rejected(rejected);
}
return totalPromise;
}
@NotNull
@Override
public Promise<XExpression> calculateEvaluationExpression() {
if (evaluationExpression != null) {
return Promise.resolve(evaluationExpression);
} else {
final AsyncPromise<XExpression> res = new AsyncPromise<XExpression>();
myEvaluationContext
.getManagerThread()
.schedule(
new SuspendContextCommandImpl(myEvaluationContext.getSuspendContext()) {
@Override
public Priority getPriority() {
return Priority.HIGH;
}
@Override
public void contextAction() throws Exception {
evaluationExpression =
ApplicationManager.getApplication()
.runReadAction(
new Computable<XExpression>() {
@Override
public XExpression compute() {
try {
PsiElement psiExpression =
getDescriptor()
.getTreeEvaluation(
JavaValue.this, getDebuggerContext());
if (psiExpression != null) {
XExpression res =
TextWithImportsImpl.toXExpression(
new TextWithImportsImpl(psiExpression));
// add runtime imports if any
Set<String> imports =
psiExpression.getUserData(
DebuggerTreeNodeExpression.ADDITIONAL_IMPORTS_KEY);
if (imports != null && res != null) {
if (res.getCustomInfo() != null) {
imports.add(res.getCustomInfo());
}
res =
new XExpressionImpl(
res.getExpression(),
res.getLanguage(),
StringUtil.join(imports, ","),
res.getMode());
}
return res;
}
} catch (EvaluateException e) {
LOG.info(e);
}
return null;
}
});
res.setResult(evaluationExpression);
}
});
return res;
}
}
public abstract class Client extends UserDataHolderBase {
static final RuntimeException REJECTED = Promise.createError("rejected");
protected final Channel channel;
final ConcurrentIntObjectMap<AsyncPromise<Object>> messageCallbackMap =
ContainerUtil.createConcurrentIntObjectMap();
protected Client(@NotNull Channel channel) {
this.channel = channel;
}
@NotNull
public final EventLoop getEventLoop() {
return channel.eventLoop();
}
@NotNull
public final ByteBufAllocator getByteBufAllocator() {
return channel.alloc();
}
protected abstract ChannelFuture send(@NotNull ByteBuf message);
public abstract void sendHeartbeat();
@Nullable
final <T> AsyncPromise<T> send(int messageId, @NotNull ByteBuf message) {
ChannelFuture channelFuture = send(message);
if (messageId == -1) {
return null;
}
ChannelFutureAwarePromise<T> promise =
new ChannelFutureAwarePromise<T>(messageId, messageCallbackMap);
channelFuture.addListener(promise);
//noinspection unchecked
messageCallbackMap.put(messageId, (AsyncPromise<Object>) promise);
return promise;
}
final void rejectAsyncResults(@NotNull ExceptionHandler exceptionHandler) {
if (!messageCallbackMap.isEmpty()) {
Enumeration<AsyncPromise<Object>> elements = messageCallbackMap.elements();
while (elements.hasMoreElements()) {
try {
elements.nextElement().setError(REJECTED);
} catch (Throwable e) {
exceptionHandler.exceptionCaught(e);
}
}
}
}
private static final class ChannelFutureAwarePromise<T> extends AsyncPromise<T>
implements ChannelFutureListener {
private final int messageId;
private final ConcurrentIntObjectMap<?> messageCallbackMap;
public ChannelFutureAwarePromise(int messageId, ConcurrentIntObjectMap<?> messageCallbackMap) {
this.messageId = messageId;
this.messageCallbackMap = messageCallbackMap;
}
@Override
public boolean setError(@NotNull Throwable error) {
boolean result = super.setError(error);
messageCallbackMap.remove(messageId);
return result;
}
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
Throwable cause = future.cause();
setError(cause == null ? Promise.createError("No success") : cause);
}
}
}
}