fieldRead.setVariable(variable); fieldRead.setTarget(target); fieldRead.setType(target.getAccessedType()); res = fieldRead; } else if (isPrimitive(value.getClass()) || value instanceof String) { fieldRead.setVariable(variableRef); fieldRead.setTarget(target); fieldRead.setType(declaringClass); res = fieldRead; } else {
/** * Creates a class access expression of the form <code>C.class</code>. * * @param <T> * the actual type of the accessed class if available * @param type * a type reference to the accessed class * @return the class access expression. */ public <T> CtFieldAccess<Class<T>> createClassAccess(CtTypeReference<T> type) { @SuppressWarnings({ "rawtypes", "unchecked" }) CtTypeReference<Class<T>> classType = (CtTypeReference) factory.Type().createReference(Class.class); CtTypeAccess<T> typeAccess = factory.Code().createTypeAccess(type); CtFieldReference<Class<T>> fieldReference = factory.Core().createFieldReference(); fieldReference.setSimpleName("class"); fieldReference.setType(classType); fieldReference.setDeclaringType(type); CtFieldRead<Class<T>> fieldRead = factory.Core().createFieldRead(); fieldRead.setType(classType.clone()); fieldRead.setVariable(fieldReference); fieldRead.setTarget(typeAccess); return fieldRead; }
} else if (Logger.observations.get(index).equals(Double.NEGATIVE_INFINITY)) { final CtFieldRead<Double> fieldNegativeInfinity = factory.createFieldRead(); fieldNegativeInfinity.setType(factory.createCtTypeReference(Double.class)); final CtField<Double> negative_infinity = (CtField<Double>) factory.Class().get(Double.class).getField("NEGATIVE_INFINITY"); fieldNegativeInfinity.setVariable(negative_infinity.getReference()); } else if (Logger.observations.get(index).equals(Double.POSITIVE_INFINITY)) { final CtFieldRead<Double> fieldPositiveInfinity = factory.createFieldRead(); fieldPositiveInfinity.setType(factory.createCtTypeReference(Double.class)); final CtField<Double> positive_infinity = (CtField<Double>) factory.Class().get(Double.class).getField("POSITIVE_INFINITY"); fieldPositiveInfinity.setVariable(positive_infinity.getReference());
@Override public boolean visit(ClassLiteralAccess classLiteral, BlockScope scope) { CtTypeReference<Class<Object>> ref = references.getTypeReference(classLiteral.targetType); CtFieldReference<Class<Object>> fr = factory.Core().createFieldReference(); fr.setSimpleName("class"); fr.setType(ref); fr.setDeclaringType(ref); CtFieldRead<Class<Object>> fa = factory.Core().createFieldRead(); fa.setType(ref); fa.setVariable(fr); context.enter(fa, classLiteral); return true; }
/** * Creates a class access expression of the form <code>C.class</code>. * * @param <T> * the actual type of the accessed class if available * @param type * a type reference to the accessed class * @return the class access expression. */ public <T> CtFieldAccess<Class<T>> createClassAccess(CtTypeReference<T> type) { @SuppressWarnings({ "rawtypes", "unchecked" }) CtTypeReference<Class<T>> classType = (CtTypeReference) factory.Type().createReference(Class.class); CtFieldReference<Class<T>> field = factory.Core().<Class<T>>createFieldReference().setDeclaringType(type).setType(classType).setSimpleName("class"); return factory.Core().<Class<T>>createFieldRead().<CtFieldRead<Class<T>>>setType(classType).<CtFieldRead<Class<T>>>setVariable(field); }