How to use

getValue

method

in

spoon.reflect.code.CtLiteral

@Override
public <T> void visitCtLiteral(CtLiteral<T> e) {
  final CtLiteral peek = (CtLiteral) this.other;
  if (e.getValue() == null) {
    if (peek.getValue() != null) {
      setNotEqual(CtRole.VALUE);
    }
  } else if (peek.getValue() == null) {
    setNotEqual(CtRole.VALUE);
  } else if (!e.getValue().equals(peek.getValue())) {
    setNotEqual(CtRole.VALUE);
  }
  super.visitCtLiteral(e);
}

@SuppressWarnings("unchecked")
@Override
public <T, U> U getValue(T element) {
  return ((U) ((Object) (castTarget(element).getValue())));
}

if (literal.getValue() == null) {
  return "null";
} else if (literal.getValue() instanceof Long) {
  return literal.getValue() + "L";
} else if (literal.getValue() instanceof Float) {
  return literal.getValue() + "F";
} else if (literal.getValue() instanceof Character) {
  appendCharLiteral(sb, (Character) literal.getValue(), mayContainsSpecialCharacter);
  sb.append('\'');
  return sb.toString();
} else if (literal.getValue() instanceof String) {
  boolean mayContainsSpecialCharacters = true;
    mayContainsSpecialCharacters = ((String) literal.getValue()).length() != stringLength;
  return "\"" + getStringLiteral((String) literal.getValue(), mayContainsSpecialCharacters) + "\"";
} else if (literal.getValue() instanceof Class) {
  return ((Class<?>) literal.getValue()).getName();
} else {
  return literal.getValue().toString();

public <T> void visitCtLiteral(spoon.reflect.code.CtLiteral<T> e) {
  ((spoon.reflect.code.CtLiteral<T>) (other)).setValue(e.getValue());
  super.visitCtLiteral(e);
}

/**
 * Gets the index of a one-dimension array (helper).
 */
@SuppressWarnings("unchecked")
public static Integer getIndex(CtExpression<?> e) {
  if (e.getParent() instanceof CtArrayAccess) {
    CtExpression<Integer> indexExpression = ((CtArrayAccess<?, CtExpression<Integer>>) e.getParent()).getIndexExpression();
    return ((CtLiteral<Integer>) indexExpression).getValue();
  }
  return null;
}

/**
 * Actually invokes from a compile-time invocation (by using runtime
 * reflection).
 */
@SuppressWarnings("unchecked")
public static <T> T invoke(CtInvocation<T> i)
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  Object target = i.getTarget() == null ? null : ((CtLiteral<?>) i.getTarget()).getValue();
  List<Object> args = new ArrayList<>();
  for (CtExpression<?> e : i.getArguments()) {
    args.add(((CtLiteral<?>) e).getValue());
  }
  Class<?> c = i.getExecutable().getDeclaringType().getActualClass();
  ArrayList<Class<?>> argTypes = new ArrayList<>();
  for (CtTypeReference<?> type : i.getExecutable().getActualTypeArguments()) {
    argTypes.add(type.getActualClass());
  }
  return (T) c.getMethod(i.getExecutable().getSimpleName(), argTypes.toArray(new Class[0]))
      .invoke(target, args.toArray());
}

/**
 * for input `element` expression `X` in expression `X[Y]` it returns expression `X[Y]`
 * and registers extra {@link ListParameterInfo} to the parameter assigned to `X`
 * @param pep pair of parameter and element which has to be transformed
 * @return
 */
private ParameterElementPair transformArrayAccess(ParameterElementPair pep) {
  CtElement element = pep.element;
  if (element.isParentInitialized()) {
    CtElement parent = element.getParent();
    if (parent instanceof CtArrayAccess<?, ?>) {
      CtArrayAccess<?, ?> arrayAccess = (CtArrayAccess<?, ?>) parent;
      CtExpression<?> expr = arrayAccess.getIndexExpression();
      if (expr instanceof CtLiteral<?>) {
        CtLiteral<?> idxLiteral = (CtLiteral<?>) expr;
        Object idx = idxLiteral.getValue();
        if (idx instanceof Number) {
          return new ParameterElementPair(new ListParameterInfo(((Number) idx).intValue(), pep.parameter), arrayAccess);
        }
      }
    }
  }
  return pep;
}

  return (T) getShortSignatureForJavadoc(((CtExecutable<?>) value).getReference());
} else if (value instanceof CtLiteral) {
  Object val = ((CtLiteral<Object>) value).getValue();
  return val == null ? null : (T) val.toString();
} else if (value instanceof Enum) {

  } catch (Exception e) {
    return ((CtLiteral<?>) ((CtFieldReference<?>) value).getDeclaration().getDefaultExpression()
        .partiallyEvaluate()).getValue();
} else if (value instanceof CtLiteral) {
  return ((CtLiteral<?>) value).getValue();
} else if (value instanceof CtCodeElement) {

@Override
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator) {
  CtExpression<?> operand = evaluate(operator.getOperand());
  if (operand instanceof CtLiteral) {
    Object object = ((CtLiteral<?>) operand).getValue();
    CtLiteral<Object> res = operator.getFactory().Core().createLiteral();
    switch (operator.getKind()) {
    case NOT:
      res.setValue(!(Boolean) object);
      break;
    default:
      throw new RuntimeException("unsupported operator " + operator.getKind());
    }
    setResult(res);
    return;
  }
  setResult(operator.clone());
}

CtExpression<?> right = evaluate(operator.getRightHandOperand());
if ((left instanceof CtLiteral) && (right instanceof CtLiteral)) {
  Object leftObject = ((CtLiteral<?>) left).getValue();
  Object rightObject = ((CtLiteral<?>) right).getValue();
  CtLiteral<Object> res = operator.getFactory().Core().createLiteral();
  switch (operator.getKind()) {
    expr = left;
  Object o = literal.getValue();
  CtLiteral<Object> res = operator.getFactory().Core().createLiteral();
  switch (operator.getKind()) {

@Override
public void visitCtWhile(CtWhile whileLoop) {
  CtWhile w = whileLoop.clone();
  w.setLoopingExpression(evaluate(whileLoop.getLoopingExpression()));
  // If lopping Expression always false
  if ((whileLoop.getLoopingExpression() instanceof CtLiteral) && !((CtLiteral<Boolean>) whileLoop
      .getLoopingExpression()).getValue()) {
    setResult(null);
    return;
  }
  w.setBody(evaluate(whileLoop.getBody()));
  setResult(w);
}

@Override
public void apply() {
  previousValue = target.getValue();
  target.setValue(newValue);
}

@Override
public void apply() {
  previousValue = affected.getValue();
  affected.setValue(placeholder_name);
}

  @Override
  public <T> void visitCtConditional(CtConditional<T> conditional) {
    CtExpression<Boolean> r = evaluate(conditional.getCondition());
    if (r instanceof CtLiteral) {
      CtLiteral<Boolean> l = (CtLiteral<Boolean>) r;
      if (l.getValue()) {
        setResult(evaluate(conditional.getThenExpression()));
      } else {
        setResult(evaluate(conditional.getElseExpression()));
      }
    } else {
      CtConditional<T> ifRes = conditional.getFactory().Core().createConditional();
      ifRes.setCondition(r);
      ifRes.setThenExpression(evaluate(conditional.getThenExpression()));
      ifRes.setElseExpression(evaluate(conditional.getElseExpression()));
      setResult(ifRes);
    }
  }
}

public <T> void visitCtLiteral(CtLiteral<T> literal) {
  if (literal.getValue() != null) {
    write(literal.toString());
  } else {
    write("null");
  }
}

  @Override
  public void process(CtLiteral ctLiteral) {
    Literal constant = AccessFactory.literal(ctLiteral.getValue(), nopolContext);
    if (candidates.add(constant)) {
      logger.debug("[data] " + constant);
    }
  }
}

if (r instanceof CtLiteral) {
  CtLiteral<Boolean> l = (CtLiteral<Boolean>) r;
  if (l.getValue()) {
    setResult(evaluate(ifElement.getThenStatement()));
  } else {

public <T> void visitCtLiteral(CtLiteral<T> literal) {
  enter(literal);
  scan(literal.getAnnotations());
  scan(literal.getType());
  scanReferences(literal.getTypeCasts());
  T value = literal.getValue();
  if (value instanceof CtReference)
    scan((CtReference) value);
  exit(literal);
}

public void visitCtWhile(CtWhile whileLoop) {
  CtWhile w = whileLoop.getFactory().Core().clone(whileLoop);
  w.setLoopingExpression(evaluate(w, whileLoop.getLoopingExpression()));
  // If lopping Expression always false
  if ((whileLoop.getLoopingExpression() instanceof CtLiteral) && !((CtLiteral<Boolean>) whileLoop
      .getLoopingExpression()).getValue()) {
    setResult(null);
    return;
  }
  w.setBody(evaluate(w, whileLoop.getBody()));
  setResult(w);
}