com.intellij.xdebugger.frame.XValue Java Examples

@Override
public void computeChildren(@NotNull XCompositeNode node)
{
    final XValueChildrenList list = new XValueChildrenList();
    final DebuggerValue[] innerElements = debuggerValue.values();
    int i = 0;
    for (DebuggerValue innerElement : innerElements)
    {
        final XValue value = WeaveValueFactory.create(innerElement);
        if (value != null)
        {
            list.add("[" + i + "]", value);
        }
        i++;
    }
    node.addChildren(list, false);
    super.computeChildren(node);
}
 

@Override
public void computeChildren(@NotNull XCompositeNode node)
{
    final XValueChildrenList list = new XValueChildrenList();
    final FieldDebuggerValue[] innerElements = debuggerValue.fields();
    for (FieldDebuggerValue innerElement : innerElements)
    {
        final XValue value = innerElement.key().attr().length > 0 ? WeaveValueFactory.create(innerElement) : WeaveValueFactory.create(innerElement.value());
        if (value != null)
        {
            list.add(innerElement.key().name(), value);
        }
    }
    node.addChildren(list, false);
    super.computeChildren(node);
}
 

public XInspectDialog(@Nonnull Project project,
                      XDebuggerEditorsProvider editorsProvider,
                      XSourcePosition sourcePosition,
                      @Nonnull String name,
                      @Nonnull XValue value,
                      XValueMarkers<?, ?> markers) {
  super(project, false);

  setTitle(XDebuggerBundle.message("inspect.value.dialog.title", name));
  setModal(false);

  Pair<XValue, String> initialItem = Pair.create(value, name);
  XDebuggerTreeCreator creator = new XDebuggerTreeCreator(project, editorsProvider, sourcePosition, markers);
  myDebuggerTreePanel = new DebuggerTreeWithHistoryPanel<Pair<XValue, String>>(initialItem, creator, project);
  init();
}
 

@Override
public void computeChildren(@Nonnull final XCompositeNode node) {
  myDialog.startEvaluation(new XEvaluationCallbackBase() {
    @Override
    public void evaluated(@Nonnull final XValue result) {
      String name = UIUtil.removeMnemonic(XDebuggerBundle.message("xdebugger.evaluate.result"));
      node.addChildren(XValueChildrenList.singleton(name, result), true);
      myDialog.evaluationDone();
    }

    @Override
    public void errorOccurred(@Nonnull final String errorMessage) {
      node.setErrorMessage(errorMessage);
      myDialog.evaluationDone();
    }
  });
}
 

protected void perform(final XValueNodeImpl node, @Nonnull final String nodeName, final AnActionEvent e) {
  XValue value = node.getValueContainer();
  XNavigatable navigatable = new XNavigatable() {
    public void setSourcePosition(@Nullable final XSourcePosition sourcePosition) {
      if (sourcePosition != null) {
        AppUIUtil.invokeOnEdt(new Runnable() {
          public void run() {
            Project project = node.getTree().getProject();
            if (project.isDisposed()) return;

            sourcePosition.createNavigatable(project).navigate(true);
          }
        });
      }
    }
  };
  startComputingSourcePosition(value, navigatable);
}
 

@Override
public void perform(@Nonnull Project project, AnActionEvent event) {
  XDebugSession session = XDebuggerManager.getInstance(project).getCurrentSession();
  if (session == null) return;

  XValueMarkers<?, ?> markers = ((XDebugSessionImpl)session).getValueMarkers();
  XValueNodeImpl node = XDebuggerTreeActionBase.getSelectedNode(event.getDataContext());
  if (markers == null || node == null) return;
  XValue value = node.getValueContainer();

  ValueMarkup existing = markers.getMarkup(value);
  if (existing != null) {
    markers.unmarkValue(value);
  }
  else {
    ValueMarkerPresentationDialog dialog = new ValueMarkerPresentationDialog(node.getName());
    dialog.show();
    ValueMarkup markup = dialog.getConfiguredMarkup();
    if (dialog.isOK() && markup != null) {
      markers.markValue(value, markup);
    }
  }
  session.rebuildViews();
}
 

@Override
public void addChildren(@Nonnull XValueChildrenList children, boolean last) {
  final List<XValue> list = new ArrayList<XValue>();
  for (int i = 0; i < children.size(); i++) {
    list.add(children.getValue(i));
  }
  addChildren(list, last);
}
 

public static XValue create(DebuggerValue value)
{
    if (value instanceof ArrayDebuggerValue)
    {
        return new ArrayWeaveValue((ArrayDebuggerValue) value);
    }
    else if (value instanceof ObjectDebuggerValue)
    {
        return new ObjectWeaveValue((ObjectDebuggerValue) value);
    }
    else if (value instanceof FieldDebuggerValue)
    {
        return new FieldWeaveValue((FieldDebuggerValue) value);
    }
    else if (value instanceof DebuggerFunction)
    {
        return new FunctionWeaveValue((DebuggerFunction) value);
    }
    else if (value instanceof OperatorDebuggerValue)
    {
        return new OperatorWeaveValue((OperatorDebuggerValue) value);
    }
    else if (value instanceof SimpleDebuggerValue)
    {
        return new SimpleWeaveValue((SimpleDebuggerValue) value);
    }

    throw new RuntimeException("Debugger value not supported ");
}
 

public void unmarkValue(@Nonnull XValue value) {
  //noinspection unchecked
  final V v = (V)value;
  M m = myProvider.getMarker(v);
  if (m != null) {
    myProvider.unmarkValue(v, m);
    myMarkers.remove(m);
  }
}
 

@Nullable
public ValueMarkup getMarkup(@Nonnull XValue value) {
  Class<V> valueClass = myProvider.getValueClass();
  if (!valueClass.isInstance(value)) return null;

  V v = valueClass.cast(value);
  if (!myProvider.canMark(v)) return null;

  M m = myProvider.getMarker(v);
  if (m == null) return null;

  return myMarkers.get(m);
}
 

/**
 * Checks if value has evaluation expression ready, or calculation is pending
 */
public static boolean hasEvaluationExpression(@Nonnull XValue value) {
  AsyncResult<XExpression> promise = value.calculateEvaluationExpression();
  if (promise.isDone()) {
    return promise.getResult() != null;
  }
  return true;
}
 

@Override
protected void perform(XValueNodeImpl node, @Nonnull final String nodeName, AnActionEvent e) {
  XDebuggerTree tree = node.getTree();
  XValue value = node.getValueContainer();
  XInspectDialog dialog = new XInspectDialog(tree.getProject(), tree.getEditorsProvider(), tree.getSourcePosition(), nodeName, value,
                                             tree.getValueMarkers());
  dialog.show();
}
 

@Override
public boolean isMarked(@Nonnull Project project, @Nonnull AnActionEvent event) {
  XValueMarkers<?, ?> markers = getValueMarkers(project);
  if (markers == null) return false;

  XValue value = XDebuggerTreeActionBase.getSelectedValue(event.getDataContext());
  return value != null && markers.getMarkup(value) != null;
}
 

@Override
public boolean isEnabled(@Nonnull Project project, AnActionEvent event) {
  XValueMarkers<?, ?> markers = getValueMarkers(project);
  if (markers == null) return false;

  XValue value = XDebuggerTreeActionBase.getSelectedValue(event.getDataContext());
  return value != null && markers.canMarkValue(value);
}
 

@Override
public void createDescriptorByNode(Object node, ResultConsumer<Pair<XValue, String>> resultConsumer) {
  if (node instanceof XValueNodeImpl) {
    XValueNodeImpl valueNode = (XValueNodeImpl)node;
    resultConsumer.onSuccess(Pair.create(valueNode.getValueContainer(), valueNode.getName()));
  }
}
 

@Nonnull
@Override
public Tree createTree(@Nonnull Pair<XValue, String> descriptor) {
  XDebuggerTree tree = new XDebuggerTree(myProject, myProvider, myPosition, XDebuggerActions.INSPECT_TREE_POPUP_GROUP, myMarkers);
  tree.setRoot(new XValueNodeImpl(tree, null, descriptor.getSecond(), descriptor.getFirst()), true);
  return tree;
}
 

@Nullable
private String evaluateExpression(final @NotNull String isolateId,
                                  final @Nullable Frame vmTopFrame,
                                  final @Nullable XExpression xExpression) {
  final String evalText = xExpression == null ? null : xExpression.getExpression();
  if (vmTopFrame == null || StringUtil.isEmptyOrSpaces(evalText)) return null;

  final Ref<String> evalResult = new Ref<>();
  final Semaphore semaphore = new Semaphore();
  semaphore.down();

  myDebugProcess.getVmServiceWrapper().evaluateInFrame(isolateId, vmTopFrame, evalText, new XDebuggerEvaluator.XEvaluationCallback() {
    @Override
    public void evaluated(@NotNull final XValue result) {
      if (result instanceof DartVmServiceValue) {
        evalResult.set(getSimpleStringPresentation(((DartVmServiceValue)result).getInstanceRef()));
      }
      semaphore.up();
    }

    @Override
    public void errorOccurred(@NotNull final String errorMessage) {
      evalResult.set("Failed to evaluate log expression [" + evalText + "]: " + errorMessage);
      semaphore.up();
    }
  });

  semaphore.waitFor(1000);
  return evalResult.get();
}
 

@Nullable
private String evaluateExpression(final @NotNull String isolateId,
                                  final @Nullable Frame vmTopFrame,
                                  final @Nullable XExpression xExpression) {
  final String evalText = xExpression == null ? null : xExpression.getExpression();
  if (vmTopFrame == null || StringUtil.isEmptyOrSpaces(evalText)) return null;

  final Ref<String> evalResult = new Ref<>();
  final Semaphore semaphore = new Semaphore();
  semaphore.down();

  myDebugProcess.getVmServiceWrapper().evaluateInFrame(isolateId, vmTopFrame, evalText, new XDebuggerEvaluator.XEvaluationCallback() {
    @Override
    public void evaluated(@NotNull final XValue result) {
      if (result instanceof DartVmServiceValue) {
        evalResult.set(getSimpleStringPresentation(((DartVmServiceValue)result).getInstanceRef()));
      }
      semaphore.up();
    }

    @Override
    public void errorOccurred(@NotNull final String errorMessage) {
      evalResult.set("Failed to evaluate log expression [" + evalText + "]: " + errorMessage);
      semaphore.up();
    }
  });

  semaphore.waitFor(1000);
  return evalResult.get();
}
 

@Override
protected void startComputingSourcePosition(XValue value, XNavigatable navigatable) {
  value.computeTypeSourcePosition(navigatable);
}
 

@Nonnull
@Override
public String getTitle(@Nonnull Pair<XValue, String> descriptor) {
  return descriptor.getSecond();
}
 

public Pair<XValue, String> waitFor(long timeoutInMilliseconds) throws InterruptedException {
  Assert.assertTrue("timed out", XDebuggerTestUtil.waitFor(myFinished, timeoutInMilliseconds));
  return Pair.create(myResult, myErrorMessage);
}
 

@Override
public void evaluated(@Nonnull XValue result) {
  myResult = result;
  myFinished.release();
}
 

@Override
protected void startComputingSourcePosition(XValue value, XNavigatable navigatable) {
  // This case only typically works for Function objects where the source
  // position is available.
  value.computeSourcePosition(navigatable);
}
 

public void markValue(@Nonnull XValue value, @Nonnull ValueMarkup markup) {
  //noinspection unchecked
  M m = myProvider.markValue((V)value);
  myMarkers.put(m, markup);
}
 

public boolean canMarkValue(@Nonnull XValue value) {
  Class<V> valueClass = myProvider.getValueClass();
  if (!valueClass.isInstance(value)) return false;

  return myProvider.canMark(valueClass.cast(value));
}
 

@Override
protected void startComputingSourcePosition(XValue value, XNavigatable navigatable) {
  value.computeTypeSourcePosition(navigatable);
}
 

public static <V extends XValue, M> XValueMarkers<V, M> createValueMarkers(@Nonnull XValueMarkerProvider<V, M> provider) {
  return new XValueMarkers<V, M>(provider);
}
 

private void showTree(@Nonnull XValue value) {
  XValueMarkers<?,?> valueMarkers = ((XDebugSessionImpl)myDebugSession).getValueMarkers();
  XDebuggerTreeCreator creator = new XDebuggerTreeCreator(myDebugSession.getProject(), myDebugSession.getDebugProcess().getEditorsProvider(),
                                                          myDebugSession.getCurrentPosition(), valueMarkers);
  showTreePopup(creator, Pair.create(value, myValueName));
}
 

@Override
protected void startComputingSourcePosition(XValue value, XNavigatable navigatable) {
  // This case only typically works for Function objects where the source
  // position is available.
  value.computeSourcePosition(navigatable);
}
 

@Override
protected void startComputingSourcePosition(XValue value, XNavigatable navigatable) {
  value.computeSourcePosition(navigatable);
}