Java 类org.eclipse.debug.core.model.IWatchExpressionListener 实例源码

public void evaluate(String expression, InvocationResult listener) {
        IExpressionManager expressionManager = DebugPlugin.getDefault().getExpressionManager();
        StackFrameModel stackFrame = getTopFrame();
        IWatchExpressionDelegate delegate = expressionManager.newWatchExpressionDelegate(stackFrame.getStackFrame().getModelIdentifier());  
        delegate.evaluateExpression(expression, stackFrame.getStackFrame(), new IWatchExpressionListener() {
            public void watchEvaluationFinished(IWatchExpressionResult result) {
                listener.valueReturn(result.getValue());
//              setChanged();
//              notifyObservers(new Event<IStackFrameModel>(Event.Type.EVALUATION, getTopFrame()));
//              try {
//                  evaluationNotify();
//              } catch (DebugException e) {
//                  e.printStackTrace();
//              }
            }
        });
    }

@Override
public void evaluateExpression(String expression, IDebugElement context, IWatchExpressionListener listener) {
    this.expression = expression;
    this.context = context;
    this.listener = listener;
    if (context instanceof PyStackFrame) {

        AbstractDebugTarget target = (AbstractDebugTarget) context.getDebugTarget();
        if (target == null) {
            return; //disposed
        }

        // send the command, and then busy-wait
        EvaluateExpressionCommand cmd = new EvaluateExpressionCommand(target, expression, ((PyStackFrame) context)
                .getLocalsLocator().getPyDBLocation(), false);
        cmd.setCompletionListener(this);
        target.postCommand(cmd);

    } else {
        addError("unknown expression context");
        listener.watchEvaluationFinished(this);
    }
}

public void evaluateExpression(final String expression, final IDebugElement context,
    final IWatchExpressionListener listener) {
  final DebugElementImpl contextImpl = (DebugElementImpl) context;
  if (!contextImpl.getDebugTarget().isSuspended()) {
    // can only evaluate while suspended. Notify empty result.
    listener.watchEvaluationFinished(new IWatchExpressionResult() {

      public String[] getErrorMessages() {
        return EMPTY_STRINGS;
      }

      public DebugException getException() {
        return null;
      }

      public String getExpressionText() {
        return expression;
      }

      public IValue getValue() {
        return null;
      }

      public boolean hasErrors() {
        return false;
      }
    });
    return;
  }

  final EvaluateContext evaluateContext =
      (EvaluateContext) contextImpl.getAdapter(EvaluateContext.class);
  if (evaluateContext == null) {
    listener.watchEvaluationFinished(new BadWatchExpressionResult(
        new DebugException(new Status(Status.ERROR,
            ChromiumDebugUIPlugin.PLUGIN_ID,"Bad debug context")), //$NON-NLS-1$
        expression));
    return;
  }

  evaluateContext.getJsEvaluateContext().evaluateAsync(
      expression, null,
      new JsEvaluateContext.EvaluateCallback() {
        @Override
        public void success(ResultOrException result) {
          ValueBase valueBase = result.accept(new ResultOrException.Visitor<ValueBase>() {
            @Override public ValueBase visitResult(JsValue value) {
              return Value.create(evaluateContext, value,
                  ExpressionTracker.createExpressionNode(expression));
            }
            @Override
            public ValueBase visitException(JsValue exception) {
              return new ValueBase.ErrorMessageValue(evaluateContext, "<abnormal return>",
                  exception);
            }
          });
          listener.watchEvaluationFinished(new GoodWatchExpressionResult(valueBase, expression));
        }

        @Override
        public void failure(Exception cause) {
          String message = cause.getMessage();
          listener.watchEvaluationFinished(new BadWatchExpressionResult(new DebugException(
              createErrorStatus(message == null
                  ? Messages.JsWatchExpressionDelegate_ErrorEvaluatingExpression
                  : message, null)), expression));
          return;
        }
      },
      null);
}