@Override public <T> void visitCtConstructor(CtConstructor<T> c) { if (c.getDeclaringType() != null) { write(c.getDeclaringType().getQualifiedName()); } write("("); for (CtParameter<?> p : c.getParameters()) { scan(p.getType()); write(","); } if (!c.getParameters().isEmpty()) { clearLast(); } write(")"); }
/** * Generates a constructor from a template constructor by substituting all * the template parameters by their values. * * @param targetClass * the target class where to insert the generated constructor * @param template * the template instance that holds the source template * constructor and that defines the parameter values * @param sourceConstructor * the source template constructor * @return the generated constructor */ @SuppressWarnings("unchecked") public static <T> CtConstructor<T> insertConstructor(CtClass<T> targetClass, Template<?> template, CtConstructor<?> sourceConstructor) { CtConstructor<T> newConstrutor = substitute(targetClass, template, (CtConstructor<T>) sourceConstructor); // remove the implicit constructor if clashing if (newConstrutor.getParameters().isEmpty()) { CtConstructor<?> c = targetClass.getConstructor(); if (c != null && c.isImplicit()) { targetClass.removeConstructor((CtConstructor<T>) c); } } targetClass.addConstructor(newConstrutor); return newConstrutor; }
public <T> void visitCtConstructor(final spoon.reflect.declaration.CtConstructor<T> c) { spoon.reflect.declaration.CtConstructor other = ((spoon.reflect.declaration.CtConstructor) (this.stack.peek())); enter(c); biScan(spoon.reflect.path.CtRole.ANNOTATION, c.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.PARAMETER, c.getParameters(), other.getParameters()); biScan(spoon.reflect.path.CtRole.THROWN, c.getThrownTypes(), other.getThrownTypes()); biScan(spoon.reflect.path.CtRole.TYPE_PARAMETER, c.getFormalCtTypeParameters(), other.getFormalCtTypeParameters()); biScan(spoon.reflect.path.CtRole.BODY, c.getBody(), other.getBody()); biScan(spoon.reflect.path.CtRole.COMMENT, c.getComments(), other.getComments()); exit(c); }
public <T> void visitCtConstructor(final CtConstructor<T> c) { enter(c); scan(CtRole.ANNOTATION, c.getAnnotations()); scan(CtRole.PARAMETER, c.getParameters()); scan(CtRole.THROWN, c.getThrownTypes()); scan(CtRole.TYPE_PARAMETER, c.getFormalCtTypeParameters()); scan(CtRole.BODY, c.getBody()); scan(CtRole.COMMENT, c.getComments()); exit(c); }
@java.lang.Override public <T> void visitCtConstructor(final spoon.reflect.declaration.CtConstructor<T> c) { replaceInListIfExist(c.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(c)); replaceInListIfExist(c.getParameters(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableParametersReplaceListener(c)); replaceInSetIfExist(c.getThrownTypes(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableThrownTypesReplaceListener(c)); replaceInListIfExist(c.getFormalCtTypeParameters(), new spoon.support.visitor.replace.ReplacementVisitor.CtFormalTypeDeclarerFormalCtTypeParametersReplaceListener(c)); replaceElementIfExist(c.getBody(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableBodyReplaceListener(c)); replaceInListIfExist(c.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(c)); }
@Override public boolean matches(CtConstructor<?> element) { return element.getParameters().stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } });
@Override public int compare(CtConstructor<?> constructor1, CtConstructor<?> constructor2) { return this.costToGenerateParameters(constructor1.getParameters()) - this.costToGenerateParameters(constructor2.getParameters()); }
public <T> void visitCtConstructor(final spoon.reflect.declaration.CtConstructor<T> c) { spoon.reflect.declaration.CtConstructor<T> aCtConstructor = c.getFactory().Core().createConstructor(); this.builder.copy(c, aCtConstructor); aCtConstructor.setAnnotations(this.cloneHelper.clone(c.getAnnotations())); aCtConstructor.setParameters(this.cloneHelper.clone(c.getParameters())); aCtConstructor.setThrownTypes(this.cloneHelper.clone(c.getThrownTypes())); aCtConstructor.setFormalCtTypeParameters(this.cloneHelper.clone(c.getFormalCtTypeParameters())); aCtConstructor.setBody(this.cloneHelper.clone(c.getBody())); aCtConstructor.setComments(this.cloneHelper.clone(c.getComments())); this.cloneHelper.tailor(c, aCtConstructor); this.other = aCtConstructor; }
@Override public boolean matches(CtConstructor<?> element) { return element.hasModifier(ModifierKind.PUBLIC) && element.getParameters() .stream() .map(CtParameter::getType) .filter(reference -> ! reference.equals(type)) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } }).isEmpty()) ||
@Override public CtConstructor<T> getConstructor(CtTypeReference<?>... parameterTypes) { for (CtConstructor<T> c : constructors) { boolean cont = c.getParameters().size() == parameterTypes.length; for (int i = 0; cont && (i < c.getParameters().size()) && (i < parameterTypes.length); i++) { if (!c.getParameters().get(i).getType().getQualifiedName() .equals(parameterTypes[i].getQualifiedName())) { cont = false; } } if (cont) { return c; } } return null; }
public <T> void visitCtConstructor(CtConstructor<T> c) { write(c.getDeclaringType().getQualifiedName()); write("("); for (CtParameter<?> p : c.getParameters()) { scan(p.getType()); write(","); } if (!c.getParameters().isEmpty()) { clearLast(); } write(")"); }
/** * Generates a constructor from a template constructor by substituting all * the template parameters by their values. * * @param targetClass * the target class where to insert the generated constructor * @param template * the template instance that holds the source template * constructor and that defines the parameter values * @param sourceConstructor * the source template constructor * @return the generated constructor */ @SuppressWarnings("unchecked") public static <T> CtConstructor<T> insertConstructor(CtClass<T> targetClass, Template<?> template, CtConstructor<?> sourceConstructor) { CtConstructor<T> newConstrutor = substitute(targetClass, template, (CtConstructor<T>) sourceConstructor); // remove the implicit constructor if clashing if (newConstrutor.getParameters().isEmpty()) { CtConstructor<?> c = targetClass.getConstructor(); if (c != null && c.isImplicit()) { targetClass.getConstructors().remove(c); } } targetClass.addConstructor(newConstrutor); // newConstrutor.setParent(targetClass); return newConstrutor; }
.filter(ctConstructor -> ctConstructor.hasModifier(ModifierKind.PUBLIC) && ctConstructor.getParameters().stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType) selectedConstructor = constructors.get(RandomHelper.getRandom().nextInt(constructors.size())); selectedConstructor.getParameters().forEach(parameter -> constructorCall.addArgument(ValueCreator.generateRandomValue(parameter.getType(), depth + 1)) );
final List<CtExpression> generatedConstructors = constructors.stream().map(ctConstructor -> { final CtConstructorCall<?> clone = constructorCall.clone(); ctConstructor.getParameters().forEach(parameter -> clone.addArgument(ValueCreator.generateRandomValue(parameter.getType(), 0)) );
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) { super.visitCtConstructorCall(ctConstructorCall); String type = ctConstructorCall.getType().getQualifiedName(); List<CtExpression<?>> argumentlist = ctConstructorCall.getArguments(); List<String> orig = resolveTypes(argumentlist); CtClass classname = parser.getClassMap().get(type); if(classname!=null) { Set<CtConstructor<T>> constructors=classname.getConstructors(); for(CtConstructor constructor:constructors) { List<CtParameter> paramlist=constructor.getParameters(); List<String> target=resolveParams(paramlist); transformOneMethod(orig,target,ctConstructorCall); } } else { List<Class[]> params = parser.fetchMethods(type, type); for (Class[] p : params) transformOneConstructor(orig, ctConstructorCall, p); } }
public <T> void visitCtConstructor(CtConstructor<T> c) { enter(c); scan(c.getAnnotations()); scan(c.getParameters()); scanReferences(c.getThrownTypes()); scanReferences(c.getFormalTypeParameters()); scan(c.getBody()); exit(c); }
public <T> void visitCtConstructor(CtConstructor<T> c) { visitCtNamedElement(c); writeModifiers(c); writeFormalTypeParameters(c.getFormalTypeParameters()); write(c.getDeclaringType().getSimpleName()); write("("); if (c.getParameters().size() > 0) { for (CtParameter<?> p : c.getParameters()) { visitCtParameter(p); write(" ,"); } removeLastChar(); } write(") "); if ((c.getThrownTypes() != null) && (c.getThrownTypes().size() > 0)) { write("throws "); for (CtTypeReference<?> ref : c.getThrownTypes()) { scan(ref); write(" , "); } removeLastChar(); write(" "); } scan(c.getBody()); }