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