How to use

setValue

method

in

spoon.reflect.code.CtLiteral

  @Override
  public <T, U> void setValue(T element, U value) {
    castTarget(element).setValue(castValue(value));
  }
}

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

switch (operator.getKind()) {
case AND:
  res.setValue((Boolean) leftObject && (Boolean) rightObject);
  break;
case OR:
  res.setValue((Boolean) leftObject || (Boolean) rightObject);
  break;
case EQ:
  if (leftObject == null) {
    res.setValue(leftObject == rightObject);
  } else {
    res.setValue(leftObject.equals(rightObject));
    res.setValue(leftObject != rightObject);
  } else {
    res.setValue(!leftObject.equals(rightObject));
  res.setValue(((Number) leftObject).doubleValue() >= ((Number) rightObject).doubleValue());
  break;
case LE:
  res.setValue(((Number) leftObject).doubleValue() <= ((Number) rightObject).doubleValue());
  break;
case GT:
  res.setValue(((Number) leftObject).doubleValue() > ((Number) rightObject).doubleValue());
  break;
case LT:
  res.setValue(((Number) leftObject).doubleValue() < ((Number) rightObject).doubleValue());
  break;
case MINUS:

/**
 * Creates a one-dimension array that must only contain literals.
 */
@SuppressWarnings("unchecked")
public <T> CtNewArray<T[]> createLiteralArray(T[] value) {
  if (!value.getClass().isArray()) {
    throw new RuntimeException("value is not an array");
  }
  if (value.getClass().getComponentType().isArray()) {
    throw new RuntimeException("can only create one-dimension arrays");
  }
  final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType());
  final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef);
  CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference);
  for (T e : value) {
    CtLiteral<T> l = factory.Core().createLiteral();
    l.setValue(e);
    array.addElement(l);
  }
  return array;
}

/**
 * Creates a literal with a given value.
 *
 * @param <T>
 *         the type of the literal
 * @param value
 *         the value of the literal
 * @return a new literal
 */
public <T> CtLiteral<T> createLiteral(T value) {
  CtLiteral<T> literal = factory.Core().<T>createLiteral();
  literal.setValue(value);
  if (value != null) {
    literal.setType((CtTypeReference<T>) factory.Type().<T>createReference((Class<T>) value.getClass()).unbox());
  } else {
    literal.setType((CtTypeReference<T>) factory.Type().nullType());
  }
  return literal;
}

@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());
}

if (actualClass != null) {
  CtLiteral<Class<?>> literal = fieldAccess.getFactory().Core().createLiteral();
  literal.setValue(actualClass);
  setResult(literal);
  return;
  .isSubtypeOf(fieldAccess.getVariable().getDeclaringType())) {
CtLiteral<CtFieldReference<?>> l = fieldAccess.getFactory().Core().createLiteral();
l.setValue(fieldAccess.getVariable());
setResult(l);
return;

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

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

if (isLiteralType(r)) {
  CtLiteral<T> l = invocation.getFactory().Core().createLiteral();
  l.setValue(r);
  setResult(l);
  return;

public static <T> CtLiteral<T> newLiteral(Factory factory, T value) {
  CtLiteral<T> newLiteral = factory.Core().createLiteral();
  newLiteral.setValue(value);
  return newLiteral;
}

/**
 * Creates a literal with a given value.
 *
 * @param <T>
 *         the type of the literal
 * @param value
 *         the value of the literal
 * @return a new literal
 */
public <T> CtLiteral<T> createLiteral(T value) {
  return factory.Core().<T>createLiteral().setValue(value);
}

@Override
public boolean visit(TrueLiteral trueLiteral, BlockScope scope) {
  CtLiteral<Boolean> l = factory.Core().createLiteral();
  l.setValue(true);
  context.enter(l, trueLiteral);
  return true;
}

@Override
public boolean visit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope) {
  CtLiteral<String> l = factory.Core().createLiteral();
  l.setValue(new String(extendedStringLiteral.source()));
  context.enter(l, extendedStringLiteral);
  return true;
}

@Override
public boolean visit(CharLiteral charLiteral, BlockScope scope) {
  CtLiteral<Character> l = factory.Core().createLiteral();
  l.setValue(charLiteral.constant.charValue());
  context.enter(l, charLiteral);
  return true;
}

@Override
public boolean visit(QualifiedTypeReference arg0, BlockScope arg1) {
  if (skipTypeInAnnotation) {
    return true;
  }
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getTypeReference(arg0.resolvedType));
  context.enter(l, arg0);
  return true; // do nothing by default, keep traversing
}

@Override
public boolean visit(ArrayTypeReference arrayTypeReference, BlockScope scope) {
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getTypeReference(arrayTypeReference.resolvedType));
  context.enter(l, arrayTypeReference);
  return true;
}

@Override
public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope) {
  if (skipTypeInAnnotation) {
    return true;
  }
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getBoundedTypeReference(parameterizedSingleTypeReference.resolvedType));
  context.enter(l, parameterizedSingleTypeReference);
  return true;
}

@Override
public boolean visit(IntLiteral intLiteral, BlockScope scope) {
  CtLiteral<Integer> l = factory.Core().createLiteral();
  CtTypeReference<Integer> r = references.getTypeReference(intLiteral.resolvedType);
  l.setType(r);
  if (intLiteral.constant != null) { // check required for noclasspath mode
    l.setValue(intLiteral.constant.intValue());
  }
  context.enter(l, intLiteral);
  return true;
}

@Override
public boolean visit(LongLiteral longLiteral, BlockScope scope) {
  CtLiteral<Long> l = factory.Core().createLiteral();
  l.setValue(longLiteral.constant.longValue());
  CtTypeReference<Long> r = references.getTypeReference(longLiteral.resolvedType);
  l.setType(r);
  context.enter(l, longLiteral);
  return true;
}