private ExecutableElement findDefaultConstructor(TypeElement element) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); for (ExecutableElement constructor : constructors) { if (constructor.getParameters().isEmpty()) { return constructor; } } return null; } }
private Stream<CompilationMessage> validateConstructor( Element extensionClass ) { Optional<ExecutableElement> publicNoArgConstructor = constructorsIn( extensionClass.getEnclosedElements() ).stream() .filter( c -> c.getModifiers().contains( Modifier.PUBLIC ) ) .filter( c -> c.getParameters().isEmpty() ).findFirst(); if ( !publicNoArgConstructor.isPresent() ) { return Stream.of( new ExtensionMissingPublicNoArgConstructor( extensionClass, "Extension class %s should contain a public no-arg constructor, none found.", extensionClass ) ); } return Stream.empty(); } }
private static List<ExecutableElement> getConstructorsWithAnnotations( Element exploringConstructor, List<String> annotations) { return constructorsIn(exploringConstructor.getEnclosingElement().getEnclosedElements()).stream() .filter(constructor -> hasAnyOfAnnotation(constructor, annotations)) .sorted(Comparator.comparing((e -> e.getSimpleName().toString()))) .collect(toImmutableList()); }
private static boolean hasStringArrayConstructor(TypeElement element) { for (ExecutableElement e : ElementFilter.constructorsIn(element.getEnclosedElements())) { if (e.getModifiers().contains(Modifier.PUBLIC) && e.getParameters().size() == 1) { if (isArrayOfStrings(e.getParameters().get(0).asType())) { return true; } } } return false; }
@Override public Optional<ExecutableElement> factoryMethod() { Optional<ExecutableElement> staticFactory = ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equalsIgnoreCase("create")) .filter(element -> element.getParameters().size() > 0) .filter(element -> element.getReturnType().equals(element().asType())) .findAny(); Optional<ExecutableElement> constructor = ElementFilter.constructorsIn(element().getEnclosedElements()).stream() .filter(element -> element.getParameters().size() > 0) .findAny(); return staticFactory.isPresent() ? staticFactory : constructor; }
private boolean hasAccessibleConstructor(Element type) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(type.getEnclosedElements()); if (constructors.isEmpty()) { // It is unclear (not checked) if we will have syntethic no-arg constructor // included, so we will assume no constructor to equate having a single constructors. return true; } for (ExecutableElement c : constructors) { if (c.getParameters().isEmpty()) { return !Visibility.of(c).isPrivate(); } } return false; } }
public void isAbstractOrHasEmptyOrContextConstructor(Element element, ElementValidation valid) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); if (!annotationHelper.isAbstract(element)) { if (constructors.size() == 1) { ExecutableElement constructor = constructors.get(0); if (!annotationHelper.isPrivate(constructor)) { if (constructor.getParameters().size() > 1) { valid.addError("%s annotated element should have a constructor with one parameter max, of type " + CanonicalNameConstants.CONTEXT); } else if (constructor.getParameters().size() == 1) { VariableElement parameter = constructor.getParameters().get(0); if (!parameter.asType().toString().equals(CanonicalNameConstants.CONTEXT)) { valid.addError("%s annotated element should have a constructor with one parameter max, of type " + CanonicalNameConstants.CONTEXT); } } } else { valid.addError("%s annotated element should not have a private constructor"); } } else { valid.addError("%s annotated element should have only one constructor"); } } }
private void handleBaseBuilder() { if (!MoreTypes.isTypeOf(Object.class, baseBuilder.asType())) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(baseBuilder.getEnclosedElements()); Optional<ExecutableElement> constructor = constructors.stream().filter(c -> c.getParameters().size() == 0).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), false)); } else { constructor = constructors.stream().filter(c -> c.getParameters().size() == 1 && Types.CONTEXT.equals(TypeName.get(c.getParameters().get(0).asType()))).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), true)); } else { final AnnotationMirror mirror = baseAnnotation.getAnnotationMirrors().stream() .filter(m -> MoreTypes.isTypeOf(Configuration.class, m.getAnnotationType())) .findAny().orElseThrow(IllegalArgumentException::new); messager.printMessage(Diagnostic.Kind.ERROR, "Classes used as base builder must have a constructor which takes no arguments, " + "or exactly one argument of type Class", baseAnnotation, mirror, mirror.getElementValues().entrySet().stream() .filter(entry -> entry.getKey().getSimpleName().toString().equals("builderSuperClass")).findAny().map(Map.Entry::getValue).orElse(null)); throw new IllegalArgumentException(); } } handleBaseBuilderMethods(); } }
public void isAbstractOrHasEmptyConstructor(Element element, ElementValidation valid) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); if (!annotationHelper.isAbstract(element)) { if (constructors.size() == 1) { ExecutableElement constructor = constructors.get(0); if (!annotationHelper.isPrivate(constructor)) { if (constructor.getParameters().size() != 0) { valid.addError("%s annotated element should have an empty constructor"); } } else { valid.addError("%s annotated element should not have a private constructor"); } } else { valid.addError("%s annotated element should have only one constructor"); } } }
private void setConstructor() { constructor = generatedClass.constructor(PRIVATE); JVar constructorContextParam = constructor.param(getClasses().CONTEXT, "context"); JBlock constructorBody = constructor.body(); List<ExecutableElement> constructors = ElementFilter.constructorsIn(annotatedElement.getEnclosedElements()); ExecutableElement superConstructor = constructors.get(0); if (superConstructor.getParameters().size() == 1) { constructorBody.invoke("super").arg(constructorContextParam); } constructorBody.assign(getContextField(), constructorContextParam); }
final List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); for (ExecutableElement constructor : constructors) { final List<? extends VariableElement> parameters = constructor.getParameters();
private boolean verifyServiceProviderSignature(TypeElement clazz, Class<? extends Annotation> annotation) { AnnotationMirror ann = findAnnotationMirror(clazz, annotation); if (!clazz.getModifiers().contains(Modifier.PUBLIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must be public", clazz, ann); return false; } if (clazz.getModifiers().contains(Modifier.ABSTRACT)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must not be abstract", clazz, ann); return false; } if (clazz.getEnclosingElement().getKind() != ElementKind.PACKAGE && !clazz.getModifiers().contains(Modifier.STATIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must be static", clazz, ann); return false; } { boolean hasDefaultCtor = false; for (ExecutableElement constructor : ElementFilter.constructorsIn(clazz.getEnclosedElements())) { if (constructor.getModifiers().contains(Modifier.PUBLIC) && constructor.getParameters().isEmpty()) { hasDefaultCtor = true; break; } } if (!hasDefaultCtor) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must have a public no-argument constructor", clazz, ann); return false; } } return true; }
private void handleConstructors(EntityType entityType, List<? extends Element> elements) { for (ExecutableElement constructor : ElementFilter.constructorsIn(elements)) { if (configuration.isValidConstructor(constructor)) { List<Parameter> parameters = transformParams(constructor.getParameters()); entityType.addConstructor(new Constructor(parameters)); } } }
private void generateConstructors(TypeSpec.Builder builder) { // copy the existing constructors for (ExecutableElement constructor : ElementFilter.constructorsIn( typeElement.getEnclosedElements())) { // constructor params List<? extends VariableElement> parameters = constructor.getParameters(); if (!parameters.isEmpty()) { MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder(); constructorBuilder.addModifiers(constructor.getModifiers()); List<String> parameterNames = new ArrayList<>(); for (VariableElement parameter : parameters) { Modifier[] modifiers = parameter.getModifiers().toArray( new Modifier[parameter.getModifiers().size()]); String parameterName = parameter.getSimpleName().toString(); parameterNames.add(parameterName); ParameterSpec.Builder parameterBuilder = ParameterSpec.builder( TypeName.get(parameter.asType()), parameterName, modifiers); constructorBuilder.addParameter(parameterBuilder.build()); } // super parameter/arguments StringJoiner joiner = new StringJoiner(",", "(", ")"); parameterNames.forEach(joiner::add); constructorBuilder.addStatement("super" + joiner.toString()); builder.addMethod(constructorBuilder.build()); } } }
Element elementType = typeUtils.asElement(elementTypeMirror); DeclaredType daoWithTypedParameters = ormLiteHelper.getTypedDao(element); for (ExecutableElement constructor : ElementFilter.constructorsIn(elementType.getEnclosedElements())) { List<? extends VariableElement> parameters = constructor.getParameters(); if (parameters.size() == 1) {
public void validateRestSimpleParameter(Element element, String requiredClass, String parameterName, ElementValidation validation) { TypeMirror requiredType = annotationHelper.typeElementFromQualifiedName(requiredClass).asType(); DeclaredType paramterType = annotationHelper.extractAnnotationClassParameter(element, annotationHelper.getTarget(), parameterName); if (paramterType != null) { if (annotationHelper.isSubtype(paramterType, requiredType)) { Element parameterElement = paramterType.asElement(); if (parameterElement.getKind().isClass()) { if (!annotationHelper.isAbstract(parameterElement)) { if (parameterElement.getAnnotation(EBean.class) != null) { typeIsValid(EBean.class, paramterType, validation); return; } List<ExecutableElement> constructors = ElementFilter.constructorsIn(parameterElement.getEnclosedElements()); for (ExecutableElement constructor : constructors) { if (annotationHelper.isPublic(constructor) && constructor.getParameters().isEmpty()) { return; } } validation.addError(element, "The " + parameterName + " class must have a public no argument constructor or must be annotated with @EBean"); } else { validation.addError(element, "The " + parameterName + " class must not be abstract"); } } else { validation.addError(element, "The " + parameterName + " class must be a class"); } } else { validation.addError(element, "The " + parameterName + " class must be a subtype of " + requiredClass); } } }
public List<CharSequence> getConstructorAnnotations() { if (constructorAnnotations == null) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); for (ExecutableElement c : constructors) { if (c.getParameters().isEmpty()) {
if (!annotationHelper.isAbstract(converterElement)) { if (converterElement.getAnnotation(EBean.class) == null) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(converterElement.getEnclosedElements()); boolean hasPublicWithNoArgumentConstructor = false; for (ExecutableElement constructor : constructors) {
if (!annotationHelper.isAbstract(interceptorElement)) { if (interceptorElement.getAnnotation(EBean.class) == null) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(interceptorElement.getEnclosedElements()); boolean hasPublicWithNoArgumentConstructor = false; for (ExecutableElement constructor : constructors) {
for (ExecutableElement c : ElementFilter.constructorsIn(includedType.getEnclosedElements())) { if (DeclaringType.suitableForBuilderConstructor(c)) { builder.add(interners.forProto(