@java.lang.Override public <T> void visitCtFieldRead(final spoon.reflect.code.CtFieldRead<T> fieldRead) { spoon.reflect.code.CtFieldRead<T> aCtFieldRead = fieldRead.getFactory().Core().createFieldRead(); this.builder.copy(fieldRead, aCtFieldRead); aCtFieldRead.setAnnotations(this.cloneHelper.clone(fieldRead.getAnnotations())); aCtFieldRead.setTypeCasts(this.cloneHelper.clone(fieldRead.getTypeCasts())); aCtFieldRead.setTarget(this.cloneHelper.clone(fieldRead.getTarget())); aCtFieldRead.setVariable(this.cloneHelper.clone(fieldRead.getVariable())); aCtFieldRead.setComments(this.cloneHelper.clone(fieldRead.getComments())); this.cloneHelper.tailor(fieldRead, aCtFieldRead); this.other = aCtFieldRead; }
@Override public <T> CtFieldRead<T> createFieldRead() { CtFieldRead<T> e = new CtFieldReadImpl<>(); e.setFactory(getMainFactory()); return e; }
@java.lang.Override public <T> void visitCtFieldRead(final spoon.reflect.code.CtFieldRead<T> fieldRead) { spoon.reflect.code.CtFieldRead other = ((spoon.reflect.code.CtFieldRead) (this.stack.peek())); enter(fieldRead); biScan(spoon.reflect.path.CtRole.ANNOTATION, fieldRead.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.CAST, fieldRead.getTypeCasts(), other.getTypeCasts()); biScan(spoon.reflect.path.CtRole.TARGET, fieldRead.getTarget(), other.getTarget()); biScan(spoon.reflect.path.CtRole.VARIABLE, fieldRead.getVariable(), other.getVariable()); biScan(spoon.reflect.path.CtRole.COMMENT, fieldRead.getComments(), other.getComments()); exit(fieldRead); }
/** * 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()); fieldNegativeInfinity.setFactory(factory); valueToReplace.replace(fieldNegativeInfinity); } 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()); fieldPositiveInfinity.setFactory(factory); valueToReplace.replace(fieldPositiveInfinity); } else {
@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; }
fieldRead.setTarget(factory.createTypeAccess(ctTypeOfException)); final CtFieldReference fieldReference = factory.createFieldReference(); fieldReference.setDeclaringType(ctTypeOfException); fieldReference.setSimpleName("class"); fieldRead.setVariable(fieldReference);
private static CtFieldRead getCtFieldRead(Object value, Factory factory) { final CtFieldRead fieldRead = factory.createFieldRead(); final CtClass<?> doubleClass = factory.Class().get(value.getClass()); final CtField<?> field = doubleClass.getField(getRightField(value, factory)); final CtFieldReference<?> reference = field.getReference(); fieldRead.setVariable(reference); return fieldRead; }
CtTypeAccess target = getFactory().Code().createTypeAccess(getFactory().Type().createReference(((Field) value).getDeclaringClass())); CtFieldRead fieldRead = getFactory().Core().createFieldRead(); fieldRead.setVariable(variable); fieldRead.setTarget(target); fieldRead.setType(target.getAccessedType()); res = fieldRead; } else if (isPrimitive(value.getClass()) || value instanceof String) { CtTypeAccess target = getFactory().Code().createTypeAccess(declaringClass); CtFieldRead fieldRead = getFactory().Core().createFieldRead(); fieldRead.setVariable(variableRef); fieldRead.setTarget(target); fieldRead.setType(declaringClass); res = fieldRead; } else {
@Override public <T> void visitCtFieldRead(final CtFieldRead<T> fieldRead) { enter(fieldRead); scan(CtRole.ANNOTATION, fieldRead.getAnnotations()); scan(CtRole.CAST, fieldRead.getTypeCasts()); scan(CtRole.TARGET, fieldRead.getTarget()); scan(CtRole.VARIABLE, fieldRead.getVariable()); scan(CtRole.COMMENT, fieldRead.getComments()); exit(fieldRead); }
/** * 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); }
private static CtFieldRead<Number> getCtFieldRead(Class<?> clazz, String fieldName, Factory factory) { final CtFieldRead<Number> fieldRead = factory.createFieldRead(); final CtClass<?> doubleClass = factory.Class().get(clazz); final CtField<Number> field = (CtField<Number>) doubleClass.getField(fieldName); final CtFieldReference<Number> reference = field.getReference(); fieldRead.setVariable(reference); return fieldRead; }
@Override public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead) { enter(fieldRead); scan(fieldRead.getAnnotations()); scan(fieldRead.getTypeCasts()); scan(fieldRead.getVariable()); scan(fieldRead.getTarget()); exit(fieldRead); }
@Override public <T> CtFieldRead<T> createFieldRead() { CtFieldRead<T> e = new CtFieldReadImpl<T>(); e.setFactory(getMainFactory()); return e; }
@Override public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead) { super.visitCtFieldRead(fieldRead); enter(fieldRead); scan(fieldRead.getVariable()); scan(fieldRead.getAnnotations()); scan(fieldRead.getTypeCasts()); scan(fieldRead.getVariable()); scan(fieldRead.getTarget()); exit(fieldRead); }
@java.lang.Override public <T> void visitCtFieldRead(final spoon.reflect.code.CtFieldRead<T> fieldRead) { replaceInListIfExist(fieldRead.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(fieldRead)); replaceInListIfExist(fieldRead.getTypeCasts(), new spoon.support.visitor.replace.ReplacementVisitor.CtExpressionTypeCastsReplaceListener(fieldRead)); replaceElementIfExist(fieldRead.getTarget(), new spoon.support.visitor.replace.ReplacementVisitor.CtTargetedExpressionTargetReplaceListener(fieldRead)); replaceElementIfExist(fieldRead.getVariable(), new spoon.support.visitor.replace.ReplacementVisitor.CtFieldAccessVariableReplaceListener(fieldRead)); replaceInListIfExist(fieldRead.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(fieldRead)); }